Inspired by this Lobsters thread, and some of the great comments within it, I would like to ask if anybody is doing some hobby programming this weekend?
Working on my latest videogame, very early stages but it’s coming along nicely.
I also sot up a git server at home and a ssh access key on my el-cheapo laptop and I feel very good every time I push a branch from it to home.
I do have performance issues with Rider though (JetBrains C# IDE), I have disabled basically everything except syntax coloring and still it’s just lagging insanely all the time. 20 seconds i7 quad core peak because I (shudder) select text, or erase some letters in a comment. Aaaaaa! If anyone knows a C# ide that works well with Godot on linux I’m all ears. Syntax coloring, debugging & autocomplete if possible, FOSS would be fantastic (microsoft code thingy sucks ass btw IMO).
Godot is fantastic BTW!
Check out DotRush. It’s made for VSCode/Codium but can be used with pretty much anything else with its LSP. https://github.com/JaneySprings/DotRush
Thanks, but vscode already do c# (and is quite shitty IMO)?
Sure, but DotRush can work well with other editors with LSP support, like NeoVim, Zed, and Sublime as noted here. I’m pretty sure it can work with other editors, too, like emacs, but haven’t tried (yet?). It also explicitly supports Godot.
Looking for a job :(
Yeah, Same here honestly
Realized, while disabling registration (due to heavy bot activity), my CI was broken so took the weekend to fix it https://github.com/idrissbellil/gossiper https://app.v3m.pw/
I’m relearning arduino!
I’ve got a couple 382p’s laying around and wanna build an RTOS for them, eventually drive a CYD to interface with them.
End goal: Affordable offline-first PDA.
I have a couple of ideas bouncing around, but they might be too ambitious (plus harder that I use a less common language, often via bindings).
The first is a lot of ideas for a mesh editor, but not sure where to start. Technically, I already started a while ago with a text-based* polygon format/loader for Raylib so if I had some (high-level) way to export that polygon to a 3D file (single/double-sided faces or extruded) that’d be the first step. However I never really used/continued what I made (2D) because of how windings (fan vs strip) are, not good** as you’d need to keep track of it during usage. Perhaps something else might be better, like p5js?
The other is a frameless+floating X11 WM, and I’m similarly unsure of what I should use for drawing a title/titlebar and window buttons (and inset controls if possible).
.xpmfor bar/buttons is a maybe.* sparse (a rectangle is 4 numbers on an otherwise empty grid), not like traditional (filled) ASCII art
** maybe expecting winding from an unordered list of points is too much, but not sure there’s an easy way to cover windings for most situations. Color index (8-way) used as face hints, or similar (4-way?) for inside direction? Multiple origins for raycasts?
fan vs strip
Why not just work with a collection of triangles directly? It uses more memory, yes, but it’s simpler to reason about and can also have parallelism benefits (since each triangle is independent).
It can still be useful to track shared vertices (and reference them by index) though.
That’s how it could work when it gets to 3D anyway (with face-corner vertex color which I might not always need) but that’d be a pain to define by hand and the format I have I don’t actually have a way to define the same point more than once as it’s on a text grid.
for example, an oval
Note: it appears round here, but it isn’t
#values: matrix_xres matrix_yres target_size vert_num #vert pattern is cntrclckwse (related: replace 0 with @ for closed shape) or |/|/ 31 15 160.0 9 1 2 8 3 @ 7 4 6 5Easier to edit in a text editor with syntax highlighting that marks spaces for a visible grid.
My face hinting idea also doesn’t work with this shape due to orientation (would work as a more traditional octagon), it also seems to be more obvious/viable with a larger grid (looks right for a 32x32 star shape).
I’m not sure I quite get it, but if I’m following correctly, you’re using the numbers to indicate a sequence of vertices for a triangle fan here (with
indicating the central vertex), right? If so, the vertices are used in more than one triangle;(0, 1, 2)and(0, 2, 3)are triangles that reuse vertex 0 () and vertex2.If that’s what’s going on then it should be fairly straightforward to turn shapes defined like this into extrusions; for the simplest case you duplicate and offset the triangle fan for the other end and then generate quads/pairs of triangles for the extruded faces of the prism – and for more complicated cases you can repeat that (with planar alignment if needed) following a curve in small increments.
I might not be following though since I don’t know what you mean by color index face hints.
You are right about a few things, though the key is that Raylib is what’s creating the polygon (after I parse the text file into a sequence) and ideally I don’t handle face/mesh creation myself (at low-level). Maybe eventually.
what you mean by color index face hints
For additional context on where faces are.
I’ve mentioned vertex color (ideal as face colors), but I probably do want to handle a 3-digit-hex color palette with object-library-wide management.
here's what I was thinking with verts no longer numbered (instead E for external, C for corner. even-odd might work better in some cases), index numbers as hints and for color
Each arm would be its own color
#values: matrix_xres matrix_yres target_size vert_num #IDEA, fails with heart as there is only 1 corner vertex 32 32 160.0 11 E 1 E2 C C 3E 1 2@3 4 5 C C C 4 5 E E
The reason I’m thinking about this is that it would be better to have one way to define verts. triangle_strip can generally do more (shapes with no central point) than triangle_fan, though I think the star here is the sort-of-thing that a single triangle_strip cannot do. That, and with numbering it only allows 62 verts (0…9, a…z, A…Z), and is a bit clunky to iterate on. Numbering, especially with a strip, is also a lot more complex as you get more verts. If I got to the point of making my own editor*, I might abstract this away so the user only works with points.
Use-in-code-wise I may have already solved fan-vs-strip with a function that just compares the values of the first few points to choose draw type, though I wasn’t confident in that as it’d require a lot more testing. Might be better to store that in an enum as well.
* I wasn’t quite sure of using what I already made for anything more than a simple arcade-like game, so that sort of kills motivation, needing to do even more technical work just to get visible results.
OK. I think I see what you’re getting at. If you can figure out how to get it to the point of an outline, there are triangulation libraries that can fill in the mesh for you (I think I’ve mentioned one to you before a long time ago) if you want flat end caps on the extrusion. I’m not sure off the top of my head how you’d get to an outline from that star example though – a few ideas come to mind, but they’re very much half-baked ideas… :p
Best of luck!
Edit: the triangulation library I was thinking of: https://github.com/mapbox/earcut
I’ve been tinkering with integrated programming and physical circuits. Working with my hands to “code” a physical piece of hardware that does a specific purpose has been a breath of fresh air in the age of Al.
I’m messing with making a kernel softmac driver that can handle Nintendo specific 802.11 frames so that MelonDS can connect to a real DS or to another device using the native Nintendo wirelesss protocol.
Lot’s of interesting reading and packet capture fun with Wireshark has given me an idea of where to start, but the tricky part is that the DS needs less than 20us of round trip latency for it to work, which is insanely low. Otherwise the connection is considered interrupted and gets dropped.
afaik, the only part that “verifies” the latency are ACK frames which the DS expects a return for every frame transmitted, so it should in theory be possible to just make a small driver that generates ACK frames at kernel priority, and forwards the rest of the frame to MelonDS for actual game handling.
I’m hoping it turns out that easy but the MelonDS forums have a long ass thread about how much of a PITA the DS wireless multiplayer timing synchronization requirements are.
Wow, this would be quite cool. When DS emulators were new, I wanted this to be a thing so bad.
Unrelated (and not what I’m doing this weekend), but I’ve always been interested in reversed-engineering the DS / DSi firmware drivers that connects to WiFi to attempt to backport the 802.11b driver to WEP-only DS games.
Ooh, It does sound interesting. My wild conspiracy is that Nintendo has made hardware offloaded functions that run with sub-microsecond latencies so this 20 us looks more like blocking non-DS hardware from communicating with the DS.
1h of videogame dev every day keeps the depression away
So, what kind of game are you making?
procgen towerdefense
there are a couple games that describe themselves like that, but none of then scratched the itch I had and were not what I had in mind, so I’m making my own
Keep us updated!
Where though 😅
I find daily is better than weekly because I can actually remember what I was doing. However, it is mostly just a few hours each weekend for me a the moment.
Just finished “version 0” for a very simple programming language yesterday, and I’m looking to work on “version 1” this weekend. Rust is truly fun to program in… although writing all the tests was not a very fun experience. But doing the work for that meant I was guaranteed to have a reasonably good grasp of the semantics by the time I finished.
Since it’s Rust, there’s no garbage collector – heck, for this particular language, there’s not even any memory allocation after startup. Instead you get a giant global array of “memory” to work with. The only data type is the 32-bit integer (and thus, using UTF-32 for strings is actually the """correct""" choice for this language). I’m using a vaguely Lisp-like syntax that revolves around
{[a tree] formed from (brackets and whitespace)}… which was probably slightly easier to parse than more traditional syntax, but Rust’s current lack of pattern matching “through”Vec(for example, letting you extractefrom{a b [c (d e)] f}in one step) didn’t always make it feel that way.Nest up: adding while loops, exponentiation and bitwise operators, and most interestingly, string and character literals. (The char literals would just evaluate to their character codes, and string literals would only be usable in a specific write-to-memory construct.) And also expanding the standard library. I’d say “version 1” would really be the more properly “complete” version of the language. I also want to do a functional programming variation (ditching the global memory in favour of reference counted cons cells), and also the whole language is kind of just a stripped down version of another much bigger language half-formed in my head, but that’s all probably for… not this weekend, at any rate.
Trying to get a release of Summit (!summit@lemmy.world) ready. I’ve been trying to catch back up after taking a month hiatus about 2 months ago and still playing catch up.
Been ignoring the community for too long so after this release will need to go tend to requests and bug reports. It’s a lot of work :/
I’m spending part of it on one of those changes that sounds tiny but touches half the desktop app: keeping a WebKit-backed terminal alive while SwiftUI rebuilds navigation. SSH can remain connected while the UI loses scrollback and visual state, so I’m separating the long-lived session from the transient view tree and letting SwiftUI rebuild only the native shell. Then feedback triage, and deliberately no new feature this weekend.
I’m trying to build my own Wayland WM. why when there are so many out there? because I don’t feel like any of them do them well. either they all focus on fancy animations (hyprland) or slam you with features without focusing on specific things (mangowm) or primarily have issues with mouse/keyboard focus on games in window mode or just games in general when you toggle away from them and back (all of them) and that annoys me.
There’s one specific game I play in window mode with multiple clients of the game running, it’s EVE Online. ALL the Wayland WM’s have issues with this. you move away from the window and back it doesn’t grab the mouse back the first time or the keyboard won’t work the first time going back. X11 WMs have ZERO issues with this. but like with Niri you have to switch workspaces and back just for it to grab the mouse/keyboard again. Hyprland you have to switch windows and back. Sway is the same type of deal.
So I’m trying to build a Wayland WM with a focus on gaming and vim style navigation as that’s what I do on my machines. game and code. I just want to take a suckless type approach and do one thing and one thing well. I’m also tired of the idiotic configs and resource hogs of many of these. there’s an x11 WM called SXWM written by a 13 year old whose config file is the most simple and clean one I’ve ever seen. many x11 WMs are like this (CTWM is another example of a clean and simple config) I want to adapt that to Wayland as hyprlands switch to lua and thus turning it into a mess also annoyed me.
it’s a big project but one that I feel needs to be done. so I’m just building something that tiles, is solid with the mouse and keyboard, and has a very simple config and low resources. that’s it.
Good luck with it. You will learn a lot. Also there is no such thing as a Wayland wm, but rather a Wayland compositor, and that is a distinct difference between X11 and Wayland.
Writing code inside Mindustry’s logic processor that test belt speeds, benchmark different schematics, etc.
I got interested in constraint programming, and I had NO idea how it worked. It seemed like magic.
I have started on following the slides and code of MiniCP, and have started implementing the first steps in Rust. I find it very challenging but it is a great learning experience. I got such a thrill from solving the N-Queens problem in milliseconds from a program that I had written myself.
I am continuing to develop the implementation for a few hours this weekend. Because writing a constraint system is hard, I am also learning some new parts of Rust that I have not touched before.
I wrote a memory scanner that can regex over a processes memory. Goal was to make it easy to find CTF flags in memory. Dunno how useful it is in reality, but it was a fun tangent.
