/agdg/ - Amateur Game Development General

realtime_search.webm
[Hide] (3.2MB, 800x690, 00:25)

>>1316
>I'm thinking of adding a real-time search so you can type into a text box and the results update automatically
I randomly felt like adding this to my file text search tool yesterday, and coincidentally yesterday was exactly 1 year away from that post. I also added other little quality of life things. The text input boxes are still fake (only supports typing and backspace, no selections or anything).

You can save paths and search queries by pressing the square on the right, right click opens a dropdown menu. They're saved into text files so you can also edit those if you want. I want to add a way to manage blacklist/whitelist for file names or extensions, but I'm still thinking about how to do that because I can imagine it being a pain to manage them.

shortpath.png
[Hide] (51.7KB, 800x411)

>>2070
I JUST came up with another quality of life thing: the gray path is shortened so it starts from the first folder.

Looks like some interesting stuff, Anon. Nice work.

>>2070
Updates:
- Made the text fields work properly. No mouse interaction though.
- When you type into the path field, it now shows a list of other folders, and pressing enter will autocomplete into the closest folder.
- Added a settings file, so you can configure some things. For example when you click a text match, you can launch a custom command so you can make it open in different programs.
- Added scrollbar (visual only).
I put it up on my website: https://sundee.neocities.org/stst/index.html

>>2073
Naicu. What language did you program your search tool in?

I hope nobody tried to download that because I fucked up the filename so the link didn't work. It's fixed now.

>2074
C. Far from perfect, but still closest to my ideal programming language.
Coincidentally, I have an entire article rambling about changes that I'd make to C: https://sundee.neocities.org/programminglanguage/index.html

>>2075
Thanks! I might look into it then. Cheers.

>>2075
I noticed on your page:
https://sundee.neocities.org/c/simplegame_sdl_linux#setup

You seem to have 'images' & 'audio' terms swapped?
For images: SDL_Mixer, install with sudo apt install libsdl2-mixer-dev
For audio: SDL_Image, install with sudo apt install libsdl2-image-dev

>>2076
Look into C? "Approach with caution" is what I would say, it's not for everyone. It's extremely difficult to recommend any language because everyone cares about different things, I used Javascript for several years at first and I doubt I would have wanted to use C back then. But even if you desire more control than Javascript on a web browser, there's several levels of depth between that and C.

>2077
Yep that's wrong, good find, thanks.

I don't know how I keep screwing up these quotes.
>>2077

I did some Stalker Anomaly modding again.

I modified starting loadouts, now you have no items by default, there's a lot more items to choose from, and you can pick as many of them as you want. Limiting the choices makes sense, but if you've played the game a lot and have self-control, then it's better to have the ability to customize freely.

I've had all my story quests break too many times due to some bug, so I decided to start playing on "azazel mode" instead (special game mode where dying causes you to switch to another NPC instead of getting a game over). I modified the script so the equipment you get are both less predictable and more fair (it used to always give you a silly starting loadout). I also changed which NPC is picked, it now prioritizes NPCs from the same faction, and NPCs that are in adjacent maps. I can't seem to be able to spawn ammo, I'm doing it exactly the same way as in other scripts but it doesn't work, so the only ammo you'll have is the ones in your guns. I'll probably check what you have on you and spawn something similar, I play with Toxic Air so it would be nice to give you a gas mask if you had one previously. If you had an artifact detector, increase the chance of giving the new character a detector too. Give a random backpack that's lower tier than your previous one. Wouldn't have to start completely from 0.

I found the script where enemy loot drops are handled, so I added a filter that downgrades their ammo. Now there's % chance to downgrade to a "weaker" variant (e.g. AP -> FMJ), and another % chance to downgrade from normal to old/broken ammo. Lower ranked NPCs have higher % chance. I'm considering completely overhauling how loot is generated, but I also need to be able to manage stash loot or else it's wasted effort.

---

Following the loot drop stuff, I explored the script where loot stashes are created, but I don't understand how it works. It seems simple at first but then just.. what? It splinters into different directions and the function names don't seem to match what they do. get_random_stash will actually create a stash, it also calls set_random_stash which spawns loot, but there's also a spawn_treasure function which spawns loot and it's called when the stash is opened, but get_random_stash which spawns loot is called when the game starts, so the loot is spawned twice?

It doesn't help that there's a callback "on_game_load", but nowhere is it explained when it gets called. When you start the game? When you start a new run? Every time you load a save? This script creates the stashes from it which implies that it's only called when a new playthrough is started, but based on context in other scripts, it seems to be when you start playing a save but there's a "load_state" callback for that, and in others it seems like when the game is booted but there's a "on_game_start" function which does that.

I tried to look into how quests are generated because I'm tired of there being so many "bring me 8 of this highly specific item that you've never had any of and if you did then you'd want to use it yourself" quests, but jesus christ it's a convoluted mess too.

>>2167
I was just tweaking the azazel NPC selection priority, and came up with an interesting trick:
[code]
int priority = 0;
if (npc_faction != player_faction) priority += 160000;
if (npc_rank    >  player_rank)    priority += 80000;
if (npc_pos.z   >  player_pos.z)   priority += 40000; // Prioritize npcs who are more in the south than you.
if (npc_map     == player_map)     priority += 20000;
priority += distance(npc_pos, player_pos); // Distance is at most about 10000.
[/code]
The above is similar to sorting objects into a 5D array, except you only need single integer. Multiplying the value on each condition by 2 causes each condition to always have higher priority than the less important conditions, for example 8+4+2+1 = 15, still lower than 16.

I hate these motherfucking tags.
int priority = 0;
if (npc_faction != player_faction) priority += 160000;
if (npc_rank    >  player_rank)    priority += 80000;
if (npc_pos.z   >  player_pos.z)   priority += 40000; // Prioritize npcs who are more in the south than you.
if (npc_map     == player_map)     priority += 20000;
priority += distance(npc_pos, player_pos); // Distance is at most about 10000.

>>2169
Actually, IMHO they are
a)  much-more in line with markdown
b)  the syntax highlighting here is invaluable.

---

Anyway, interesting work with NPC 'weightings'. Mind explaining where/how you'll use this in your code?

priority.png
[Hide] (19KB, 1984x468)

>>2167
I just spent like 2 hours trying to spawn ammo in azazel mode. I think the problem is that since the NPC you're possessing is in another map, they're in an "offline simulation" so the "iterate through inventory items" method doesn't exist on them. There's another part of the script I didn't notice which loops through all items in the game, checks if they're owned by the NPC, and transfers them to the player, I put the ammo spawning in there and now it works.

>>2170
Most imageboards use [code] tags and some imageboards have switched back and forth between backticks and [code] tags, so it's impossible to remember which ones to use.

>where/how you'll use this
I just loop through all NPCs in the game, select the NPC with lowest priority value, and possess that character. Or more specifically, I pick a random NPC from the first "category".

Pic related is a visualization of how the priority values end up. The red numbers on the bottom are the "categories", if there's no perfect match then it'll pick the next best category, and so on. To get the category, sort the list by priority, remove everything after the first NPC that has a 10k+ priority difference compared to the next one, you'll get a list of all NPCs in the same category regardless of what the min/max priority values were.

ray.webm
[Hide] (10.3MB, 1280x720, 00:54)

>>2167
I was trying to make sense of the loot spawning script again. I still don't really get it, so I gave up and started writing a new loot spawning script from scratch just to get a sense of how I ideally would want to do it. I quickly realized that rather than picking random pre-existing stashes to put loot into, there should be areas where loot boxes may spawn dynamically. The world would be infinitely more fun to explore if every corner and crevice and rock and box and car had the potential to have a stash in it, and you couldn't just run from one pre-existing stash to another. After exploring other mods, I now know how to spawn inventory boxes and how to do ray casts to find surfaces.

Things I still need to figure out:
- How to rotate the object to match the surface. I know how to get the surface normal, but I'm not familiar with the math for rotating the object to match it, especially because I want to also give the object a random rotation in the vertical axis.
- How to draw better visualizations than these white dots, they "sink" and disappear into any nearby surfaces so I have to lift them up arbitrarily in order to see them. I saw another mod use some kind of debug drawing system, but it requires newer version of "modded exes", I don't want to use it since it doesn't work properly on Windows 7. For now if I want to visualize a line I'll have to draw a row of these dots.
- Why spawning an object requires a "game vertex ID" and a "level vertex ID". I have no idea what they are or where you're supposed to get them, currently I'm just copying them from the player and it seems to work... maybe that parents them to the player and they'll disappear when you leave the map or something.

This opens up more potential developments.
1. I should be able to use the same system to place loose items too, like bottles on tables. Ideally I'd want to find how/where those are defined so I can absorb all the existing loot spots into a new loot spawning script that handles all the stashes and loose items together.
2. Placing objects in the world is one of the most important mechanics for creating quests. I might already be able to do something like placing a note/PDA into a stash that points you to another more hidden stash with loot on it. I wouldn't even have to interact with the clusterfuck of a quest system to do that.

My current goal is to create some kind of controls that allow me to just run around placing a million points/lines/rectangles in the world, and save those as spawn regions where loot boxes may spawn. They should also light up when I walk next to them so I can easily analyze the spawn regions in the world.

surface_editor.webm
[Hide] (7.2MB, 1280x720, 00:39)

>>2177
Surface editing UI works pretty good so far. Unexpectedly, the biggest problem is that this gets super laggy when there's a lot of these white points being drawn. I'm hiding shapes that aren't close to the target cursor, but still I can barely fill all the surfaces in 1 room before the framerate tanks. The position of the points are also imprecise since I have to move them towards the camera to make them visible.

This isn't ideal yet because I can't edit any extra information about the surface. I want to be able to add flags that describe the surface, which could then be used to control what kinds of stashes/items can spawn on it. For example surfaces on a window sill shouldn't be able to have big boxes or backpacks on it. I also want to make lines along a wall that could have a box or weapon leaning against it, and tight spaces behind a couch would need the container to be rotated 90 degrees.

lines.webm
[Hide] (627.3KB, 1280x720, 00:03)

>>2178
Okay this is way more labor intensive than I expected. Maybe my sense of time is distorted because I keep fixing bugs and making little improvements and fighting with Lua and I need to restart the game every time, but I've already marked 254 surfaces and I haven't even left the starting town yet.

Also these dots are probably laggy because they linger around for a few frames, so each dot I'm drawing is actually 3-5 dots. It became very obvious when I animated the outlines.

new_editor.webm
[Hide] (19.5MB, 1280x720, 01:28)

I was supposed to work on another project, but I accidentally managed to untangle the web of pOOP and XML file parsers that this game's UI system uses. I always thought that the UI system in this game was a horrible abomination, but it actually seems very well made if you peel off enough shit layers and use the base level UI classes directly. There's literally 0 examples of the text node being used anywhere in the game's scripts. Now I can properly display debug information in the corner.

This also fires up my thinking hat because the ability to modify the HUD opens up a lot of modding possibilities. For example I kind of want to buff the geiger counter, I could add a symbol to the UI if there's a radiation field nearby and you have a geiger equipped. I've also considered replacing the game's buff/debuff system with a new much more versatile one, the main reason I didn't do it so far is because I didn't know how to modify the UI. The stat bars on bottom left are also pretty lousy and what you see in the video is the best I've been able to do just by replacing textures, but now I could just replace the whole widget with my own solution.

Anyway, the interface for editing these shapes is near it's final form, it's now very fast and easy to add new shapes and tweak existing ones, it's actually kind of satisfying to walk around filling in all the surfaces and corners and hidden spots. I can't rotate circles or use a third vertex to create an ellipse though, I don't want to learn 3D math with a game where I have to spend 30 seconds on loading screens every time I want to restart the game and try some new code.

I also don't have visualization for spawn methods, each shape may spawn items in one of 4 possible ways: directly on top of the line, in front of the line, behind the line, or inside the shape it creates. Don't want items to spawn inside walls.

Also in video are 2 separate tools: a visualizer for the vanilla item spawn points, and a tool that highlights nearby game objects. I wanted to use the latter to find all the stashes in the world and delete them, but turns out they're part of the level geometry so I can't remove them without editing the level files. I can still use it to analyze how the game works though (I already learned a few interesting things), and compare my own spawn spawn points with existing stashes.

>>2187
Sounds like you're making good progress now, Anon. GG.

I came up with a trick to check if any word of 8 bytes or below is a keyword, using just an integer comparison.
u64 value = 0;
memcpy(&value, word.data, word.length);
switch (value) {
	case *(u64*)"if\0\0\0\0\0\0": return KEY_IF;
	case *(u64*)"for\0\0\0\0\0": return KEY_FOR;
	case *(u64*)"else\0\0\0\0": return KEY_ELSE;
	case *(u64*)"break\0\0\0": return KEY_BREAK;
	case *(u64*)"while\0\0\0": return KEY_WHILE;
	case *(u64*)"return\0\0": return KEY_RETURN;
	case *(u64*)"struct\0\0": return KEY_STRUCT;
	case *(u64*)"continue": return KEY_CONTINUE;
	case *(u64*)"function": return KEY_FUNCTION;
}
It may not work depending on compiler: it may not accept the fact that the string is a constant. I suppose you could replace it with an equivalent hexadecimal value.

>>2189
Neat! That should be fast, Anon.

3c9e36927c316c98e22a559b635e578bbe95113d1f5f299731ea71c03ce5058e.jpg
[Hide] (44.9KB, 592x790)

>try to learn 3D math
>hmm it would be nice to have a constant variable that is PI*2
>try to use windows calculator
>it truncates several digits from the result
>had other problems in the past where divisions return some stupid scientific notation which I can't put into config files or anywhere and it's a pain in the ass to convert it
>time to look for a new calculator
>find exactly one that isn't some gay web app
>same problem
>I wonder if there's math libraries for doing calculations with infinite precision
>find several, all of them suck
>one of them is at least somewhat usable but it's way too clumsy to actually use, also fucking annoying to read because every single line of code has a comment on separate line saying what it does, usually just repeating what's on the line except in slightly more english words
>another one has an expression parser that lets you just input a string, but the library is an absolutely fucking nightmarish labyrinth of OOP spaghetti and C++ libraries glued to one another, literally 4 functions/methods/overloads and 2+ classes just to do 1 operation, and that's not counting all the other classes and methods that those use
>try to adapt the parser to the better library
>fail and end up making my own
1 day later I have no idea what I was trying to do originally, but at least I can now type infinitely precise equations and get infinitely precise results. Here's some PI values with 80 decimal digits, cut them to your preferred size:
#define MATH_PI_MUL_PI    9.86960440108935861883449099987615113531369940724079062641334937622004482241920524 // PI * PI
#define MATH_PI_MUL_4    12.56637061435917295385057353311801153678867759750042328389977836923126562514483599 // PI * 4
#define MATH_PI_MUL_2     6.283185307179586476925286766559005768394338798750211641949889184615632812572418 // PI * 2
#define MATH_PI           3.141592653589793238462643383279502884197169399375105820974944592307816406286209 // PI
#define MATH_PI_DIV_2     1.5707963267948966192313216916397514420985846996875529104874722961539082031431045 // PI / 2
#define MATH_PI_DIV_4     0.78539816339744830961566084581987572104929234984377645524373614807695410157155225 // PI / 4
#define MATH_PI_DIV_180   0.01745329251994329576923690768488612713442871888541725456097191440171009114603449 // PI / 180
#define MATH_PI_DIV_360   0.00872664625997164788461845384244306356721435944270862728048595720085504557301725 // PI / 360
#define MATH_180_DIV_PI  57.29577951308232087679815481410517033240547246656432154916024386120284714832155263 // 180 / PI
#define MATH_360_DIV_PI 114.59155902616464175359630962821034066481094493312864309832048772240569429664310526 // 360 / PI
#define math_deg_to_rad(deg) ((deg) * MATH_PI_DIV_180)
#define math_rad_to_deg(rad) ((rad) * MATH_180_DIV_PI)
>inb4 muh compiler will do it
I don't care.

>>2192
Cool story, bro.  :D

>...but at least I can now type infinitely precise equations and get infinitely precise results
Pretty neat. GG, Anon.

I fell back into the rabbit hole of Stalker modding again, this time trying to change how loot is generated when an enemy dies. I kind of get it, but also don't, frankly I think it's completely fucked and even the developers don't really understand how it works. There's a couple functions that are called multiple times for the same NPC, they generate and delete items in very conflicting ways and some parts of the code are duplicated in different functions. If you imagine trying to design and balance loot drops, I just can't see how anyone could understand what's happening in this system.

My conclusion is that the best way to rebalance loot would be to disable everything that's happening in that script, and start over by detecting enemy deaths from another script and manage loot from there. The only reason I didn't start doing that is the fact that the loot script simulates a fake inventory for NPCs, which is also used when you trade with the NPC.

It's just kind of depressing how entangled everything is. In a better engine the items would actually be in NPC inventory, not in some kind of fake list stored in a script. I think part of the reason they aren't real items is probably because the engine's game object ID is a 16-bit integer. Every single item (spawned in world, in a stash, in NPC/trader inventories) and NPC and monster and anomaly and item stash and interactable object (doors, ladders, campfires) and breakable object and AI logic node that exists in the game world is a game object, they all exist in all maps simultaneously because of how the world sim system in Stalker (A-Life) works, and because of the 16-bit ID there can only be 65536 game objects at once.

>>2192
I decided to make a program out of it:
https://sundee.neocities.org/simpleexpressioncalculator/index.html

I've never found a real use case for SIMD.

I have a function for blending pixel colors, I've tried to optimize it many times but the most obvious solution always remains the fastest, and the SIMD method is always slower than every other solution.
Rgba8 blend (Rgba8 dest, Rgba8 src) {
	// Float method.
	f32 a1 = (f32)src.a / 255.0f;
	f32 a2 = 1.0f - af1;
	dest.r = src.r * a1 + dest.r * a2;
	dest.g = src.g * a1 + dest.g * a2;
	dest.b = src.b * a1 + dest.b * a2;
	
	// Uint method.
	u32 a1 = src.a;
	u32 a2 = 255u - src.a;
	dest.r = ((u32)src.r * a1 + (u32)dest.r * a2) / 255u;
	dest.g = ((u32)src.g * a1 + (u32)dest.g * a2) / 255u;
	dest.b = ((u32)src.b * a1 + (u32)dest.b * a2) / 255u;
	
	// Float method with SIMD.
	f32 a = (f32)src.a * (1.0f/255.0f);
	__m128i result = _mm_cvtps_epi32(
		_mm_add_ps(
			_mm_mul_ps(
				_mm_set_ps(src.r, src.g, src.b, src.a),
				_mm_set1_ps(a)
			),
			_mm_mul_ps(
				_mm_set_ps(dest.r, dest.g, dest.b, dest.a),
				_mm_set1_ps(1.0f - a)
			)
		)
	);
	dest.r = ((u8*)&result)[sizeof(i32)*3];
	dest.g = ((u8*)&result)[sizeof(i32)*2];
	dest.b = ((u8*)&result)[sizeof(i32)*1];
	
	
	return dest;
}
It's hard to tell whether the float method or uint method is faster (int method seems slightly faster without optimizations, but with optimizations they seem even), but they're much faster than the SIMD method, and I don't know how to improve it any further than this. I assume the biggest problem are the set functions, but there's no helping it since SIMD doesn't have any good ways to take in or return back 8-bit integers.

I wanted to try SIMDifying the uint method, but SIMD is missing a lot of very obvious functions, for example there's no way to multiply 4 integers even though there's a million super esoteric obscure functions that I can't even imagine the use of. I always struggle massively at doing even the most obvious things because of that. There's _mm_mul_epi32 and _mm_mul_epu32 for multiplying signed and unsigned integers respectively, but those functions multiply only 2 of the integers and convert them to 64-bit integers instead of what you'd expect (multiply 4 32-bit ints and keep them as 32-bit). I don't really understand the use case of multiplying 2 ints and converting them to 64-bit, but multiplying 4 ints seems very obviously useful.

I also don't know if it's safe to directly read the SIMD value the way I do above, but intuitively it feels like the most efficient way (just take the first byte of each int directly). The alternative is to use _mm_store_ps to store the float values into an array, but once again there's no equivalent for storing integers, except for maybe _mm_maskstore_epi32, which requires some kind of mask as a third argument. Again, why is having to create a bit mask more useful than just reading the fucking values? I don't understand the reasoning behind SIMD at all.

>>2201
That looks like some good work, Anon. I presume you're working on some kind of game engine with this?

>>2201
I realized that the float method doesn't actually give the correct result: drawing a color on top of the same color may result in a color that is off by 1. You need to round the result (or add +0.5), which probably also makes it more accurate.

I also realized that dividing by 256 instead of 255 in the uint method allows me to change the division into a bit shift, which definitely makes the uint method fastest. Problem is that the maximum color value is 255, so dividing by 256 is slightly off and you can never get a pure color. If I add something like 255 before the division, then it produces a similar-ish result as the rounded float method, but I don't know what I should compare against to test correctness. Maybe I should be adding 128 or something? I dunno.

>>2202
I draw pixels on the CPU for all kinds of reasons, sometimes for game-related things, but usually for drawing non-game graphics. This code mostly runs when rendering text since the font edges are semi-transparent, sometimes for fading out icons, lazily highlighting something by drawing a semi-transparent rectangle, drop shadows...

>>2203
Here's the bit shifted uint method:
u32 a1 = src.a;
u32 a2 = 255u - src.a;
dest.r = ((u32)src.r * a1 + (u32)dest.r * a2 + 255u) >> 8;
dest.g = ((u32)src.g * a1 + (u32)dest.g * a2 + 255u) >> 8;
dest.b = ((u32)src.b * a1 + (u32)dest.b * a2 + 255u) >> 8;
I'll be using this from now on unless it turns out to be a problem.

>>2204
New discovery.
Painting with rgba 0,0,0,254 on top of 1,1,1,255 does nothing.
Same with 255,255,255,254 on top of 254,254,254,255.
The purpose of those values is to test how high of an opacity you need in order to change the canvas into the same color as the paint. The answer is 100%, it's impossible to change the final 1 value difference using any semi-transparent paint color.

If I switch to the float blend method, then opacity of ~128 is enough to change those colors, which seems more appropriate. The original divide-by-255 uint method works similarly if I add +128 before the division (not sure if +127 would be better).

The uint shift method is fine for most purposes and I'll continue using it, but the other two are better if you need a correct result. Here's the final versions of the 3 methods:
// Float multiply method.
f32 a1 = src.a * (1.0f/255.0f);
f32 a2 = 1.0f - a1;
dest.r = src.r * a1 + dest.r * a2 + 0.5f;
dest.g = src.g * a1 + dest.g * a2 + 0.5f;
dest.b = src.b * a1 + dest.b * a2 + 0.5f;

// Uint div method, similar performance and accuracy as the above.
u32 a1 = src.a;
u32 a2 = 255u - src.a;
dest.r = (src.r * a1 + dest.r * a2 + 128u) / 255u;
dest.g = (src.g * a1 + dest.g * a2 + 128u) / 255u;
dest.b = (src.b * a1 + dest.b * a2 + 128u) / 255u;

// Uint shift method, faster than the other two, but slightly inaccurate.
u32 a1 = src.a;
u32 a2 = 255u - src.a;
dest.r = (src.r * a1 + dest.r * a2 + 255u) >> 8;
dest.g = (src.g * a1 + dest.g * a2 + 255u) >> 8;
dest.b = (src.b * a1 + dest.b * a2 + 255u) >> 8;

>>2205
Ideally you should be using more precise format for your framebuffer, you know like all graphics engines do. Otherwise you are losing information to rounding after every operation.

>>2206
High precision frame buffers only matter if you're stacking lighting/shader effects or gradients or something, otherwise you're not going to notice any difference. I don't foresee doing anything like that without the GPU in which case this code wouldn't be used anyway.

Screenshot.png
[Hide] (176.4KB, 1557x863)

Made a simple system monitor with web front-end. Mostly because I was getting increasingly annoyed with KDE's one getting slower and more annoying to setup every time they remake it.
Could use more eye candy, but at least it's usable.

>>2208
Nice work, Anon!

>>2208
>with web front-end
Wouldn't it be easier to just open a window and draw to it?

>>2210
>open a window and draw to it
That's what browser does :^) 
But if you mean "why two separate programs", that's because I wanted it to always run in the background and be super small. Alas, loading sensors and nvidia libraries completely negated my best attempts to keep memory footprint minimal, but I only realized that after I already finished. I even implemented sockets api at first (instead of using mongoose server) only to find out websockets thing is completely unrelated to that and runs on top of http protocol.
On that note, gnu sockets aren't as hard to use as I thought (especially if using epoll instead of their own shitty tracking function), it's just that documentation is a bit obtuse, and some bickering between gnu, linux, and posix.

New paper!
Blaze: Compiling JSON Schema for 10x Faster Validation
https://arxiv.org/abs/2503.02770

>>2212
Thanks, Anon! This can be useful for much more than just on games, of course. Cheers.

>>2211
Ah, I thought that having to do a trip through sockets was unnecessary complexity, but I wasn't thinking about it running in the background. And I suppose opening a window on Linux and drawing text and graphs are a bit of a headache if you don't already have a setup for that stuff.

segment_mixer.png
[Hide] (24.3KB, 576x667)

I've always used a selection sort because it's so simple and obvious, but I decided to try to make a better one.

Testing with array of 10k ints:
Completely random array = ~1.5-2x faster than selection sort, ~8-9x faster than insertion sort.
Sorted array where 2% of items are swapped = ~30x faster than selection sort, ~6x faster than insertion sort.
Sorted array where 20% of items are swapped = ~4x faster than selection sort, ~5x faster than insertion sort.
Backwards-sorted array where 2% of items are swapped = ~35x faster than selection sort, ~300x faster than insertion sort.
Backwards-sorted array where 20% of items are swapped = ~5-6x faster than selection sort, ~30-35x faster than insertion sort.

I dunno what this is called so I'm calling it "segment mixer". It finds segments from the array that are either ascending or descending, and then finds the segment that begins with the smallest item, and moves that item.

It's bad in terms of memory usage, but I'm not sure how much that matters in practice. It has to duplicate the array, and allocate a list of segment structs (they're just 2 ints for start and end positions).

>>2290
>get actual sorting algorithms from github
>I thought bubble sort was worst but it's surprisingly not bad, beats selection and insertion sort sometimes, in some cases by a lot
>heap sort is faster than my algorithm in every test except sometimes loses for arrays that are already 98% sorted, it doesn't even need to allocate memory
>merge sort needs to allocate but easily beats my algorithm in every test
>shell sort is 11 lines of code, doesn't allocate, isn't recursive, and beats my algorithm in every test except sometimes loses on nearly-sorted arrays
>quick sort beats the other algorithms more and more depending on how unsorted the array is, beats every other algorithm on a totally randomized array

The main drawback of heap/merge/quick sorts is that they all have recursive parts, which means they might overflow the stack if the array is big.

I'm genuinely baffled at how good shell sort is, it doesn't seem to have any weird caveats and it's so simple that you can practically copypaste it anywhere. I've been staring at this and trying to find the flaw but there isn't one.
void shell_sort (int count, u64* items) {
	for (int gap=count/2; gap>0; gap/=2) {
		for (int i=gap; i<count; ++i) {
			u64 temp = items[i];
			int ii = i;
			while (ii >= gap && temp < items[ii-gap]) {
				items[ii] = items[ii - gap];
				ii -= gap;
			}
			items[ii] = temp;
		}
	}
}
This will definitely be my new go-to. If more speed is needed, merge sort beats every other algorithm on every test, except loses to quick sort on completely random arrays by about 15-20%. I tested on arrays of 1000 to 100k items. Below 1000 it starts to become less obvious, merge sort still generally wins but at some point shell sort actually becomes significantly faster than the other algorithms for almost-sorted arrays (including backwards ones) and is comparable even on mixed arrays. My algorithm actually seems to be very fast on small (<200) arrays.

None of this takes into account parallelization, item size, or special array types (for example arrays where certain sections are already sorted, or with lots of repeated values). All these tests were done single-threaded with 8-byte size items. Apparently radix sort is good for parallelization, but it didn't perform too well on these tests, maybe because it does a ton of divisions, and it also has some weird requirements.

>>2291
I tested with arrays of <50 items, and selection sort actually gets ahead of other algorithms as long as the array isn't too badly backwards (backward arrays seems to destroy selection sort's performance). It's both interesting and depressing how many sorting algorithms you have to keep in mind for different kinds of arrays.

>>2295
>selection sort
Meant insertion sort.

Given how Linux works, I don't think that even with appimage anything compiled for it will "just work" even five years down the line.

>>2309
The secret to just-working on Linux is to make a Win32 program.

32597c257d2cc1f4301190959f147e4ce6dd3cc2.jpg
[Hide] (16.8KB, 231x250)

>>2309
It used to be pretty common for open source game devs to ship non-appimage portable builds for Linux games (less often with non-vidya software, as those usually had the sense to depend on distro package managers), and in my experience those builds still just work years later unless they rely on the old Open Sound System or something.
https://gist.github.com/flibitijibibo/b67910842ab95bb3decdf89d1502de88 has some simple, solid advice which carries over to portable builds of non-vidya Linux software. The results aren't as self-contained as an appimage, but unless you follow the MojoInstaller part of the guide, it gives users the same experience as installing Blender off the website or that of 99% of Windows games without installers (aka almost every game on itch.io). They get a gzipped tarball containing the executable script+libraries+resources, extract it into /opt or wherever they put their non-distro software /usr/local/games is where vidya should ideally go, and then either run it straight out of the directory or make a symlink in /usr/local/bin and then add it to their desktop environment's menu.
If that sounds like a lot of work, in practice this approach offers a lot of flexibility for different local setups, as it can be installed wherever users want extremely quickly or ran on the spot. It's also more broadly convenient than the route most proprietary Linux software takes nowadays, as the devs will only upload .deb and .rpm packages and thus implicitly give the middle finger to the many, many people on distros with different package managers. Appimages are alright for their relative simplicity, and flatpaks are annoying but tolerable (they don't integrate well with the host distro and pretend to be secure while shipping dangerously of date libraries and usually not sandboxing themselves correctly), but if you really want something that'll just work for almost everyone, this approach is old but incredibly reliable and convenient.

Now, if you really want to be adventurous, an option that's uncommon nowadays but even more convenient for its users and future proof is offering a musl libc build. Musl has not only way better forwards and backwards compatibility than glibc, but has WAY better static linking support. With musl you really can just ship a single statically linked binary (without linking to the kernel libraries and graphics drivers, obviously) and have your software just werk for anyone on a musl distro. It gives the experience which appimage tries to fake but can't fully manage because the program is still tied to glibc and suffering from the overhead of dynamic linking. It isn't quite as future proof as outright releasing your software's source code, will only benefit users on musl distros for now, and is a bit stricter than glibc in some areas, but the advantages are so strong that I still recommend familiarising yourself with it.

about_musl.png
[Hide] (462.7KB, 1378x2047)

>>2312
I may as well share pic related for the slightly lazy.

>>2312
I don't think linking against musl is going to be a good idea as long as 99% of linux distros use the bloat glibc.
What can work is a fully static musl build, as it will work on any linux system regardless of what libc it uses, but in that case you can't load any dynamic library, which means no OpenGL/Vulkan, among other things, which makes this approach a no-go for vidya in general (but can be useful in simpler, cli apps. Maybe even X11 apps if you don't mind the lack of HW acceleration).

>>2314
Can't you dynamically link to musl and a couple things like your graphics drivers while statically linking other libraries?

>>2315
The problem is glibc's and musl's ABI are not really compatible, so if you try that it might work in simpler cases, but will surely break randomly in more complex cases.
(Plus I'm not sure about musl, but I'm pretty sure in glibc if you statically link glibc, you can't use the dynamic linker, since then your shared libraries would require the shared library version of glibc, and if you try to pull in two libcs in one process, expect chaos. Like what abomination you have in windows, where if you malloc something in one DLL, you can't free it in another DLL unless both DLL's are compiled with the same MSVC version, just without any attempt at support from glibc)

>>2316
I probably shouldn't have brought up musl since I don't think either of us have used it much yet, and most importantly I've never tried testing if I could dynamically link to musl and a couple select ibraries while statically linking others within one binary. It would only be useful for musl distros if this worked, yes, but it could be convenient enough for software distribution that musl distros (using one of the existing glibc compatbility layers for glibc binaries) end up catching on beyond the server and container words.

>>2317
I never tried to mix glibc and musl. On my old laptop I had a static linked busybox with musl, and it had zero dependencies besides a linux kernel, not even a filesystem in a usable state (I used it because the disk which contained my root partition was dying, and it was useful when nothing else worked). Heck, it can even mostly work without a /proc or /sys. But running busybox and running a vidya is a very different beast
Also alpine (a linux distro using musl) pretty much recommends you to just set up a chroot with a glibc based distro if you want to run a glibc compiled program for anything but the most simple executables: https://wiki.alpinelinux.org/wiki/Software_management#Running_glibc_programs

>>2319
> it had zero dependencies besides a linux kernel, not even a filesystem in a usable state (I used it because the disk which contained my root partition was dying, and it was useful when nothing else worked). Heck, it can even mostly work without a /proc or /sys.
That's actually really cool. It sounds like it'd be a fun hobby setup even if it was partially spurred on by failing hardware.
As for chrooting still being the main way of running glibc software nowadays, that sadly isn't too surprising, as emulating glibc's quirks probably takes a lot of effort. I'd still like to mess around with musl builds for the fun of it, but yeah, those distros likely won't be completely desktop normalfag-friendly for a good while yet.

banner.webm
[Hide] (1018.5KB, 1000x600, 00:20)

>>2070
>>2073
Released 1.0 of this just now.
The reason I experimented with vectors >>2219 is so I could draw the favorite stars.

The only real thing missing is performance, but I can't be bothered to do anything since this is already fast enough for all of my needs. The amount of effort required to manage a path/file cache wouldn't be worth what I'd gain.

>>2335
Neat! Glad you've made such progress with it. Any plans for new projects now?

>>2336
I jump around projects randomly so I can't predict anything. Maybe an imageboard.

---

Speaking of making an imageboard, I'm thinking of how to store data in an efficient way in a database/whatever. A lot of strings are very short, so it feels dumb to store a 4-byte or 8-byte integer for their length, giving them a fixed length like 200 is also wasteful. On the other hand, if you use a small integer, then you may run into limitations. So, to make things easier and get all the advantages, I came up with a way to read and write variable-length integers, inspired by UTF-8. I can just use this and not have to think about it:
#define swap_endian_16(x) __builtin_bswap16(x)
#define swap_endian_32(x) __builtin_bswap32(x)
#define swap_endian_64(x) __builtin_bswap64(x)

static u64 flexint_read_u64 (void* data, u64* value) {
	if (*(u8*)data < 0b10000000) {
		*value = *(u8*)data;
		return 1;
	}
	else if ((*(u8*)data & 0b11000000) == 0b10000000) {
		*value = swap_endian_16(*(u16*)data) & 0b0011111111111111;
		return 2;
	}
	else if ((*(u8*)data & 0b11100000) == 0b11000000) {
		*value = swap_endian_32(*(u32*)data) & 0b00011111111111111111111111111111;
		return 4;
	}
	else {
		*value = swap_endian_64(*(u64*)data) & 0b0001111111111111111111111111111111111111111111111111111111111111;
		return 8;
	}
}
static u64 flexint_write_u64 (void* data, u64 value) {
	if (value < 0b10000000) { // 0 - 127
		*(u8*)data = (u8)value;
		return 1;
	}
	else if (value < 0b0100000000000000) { // 0 - 16,383
		value = swap_endian_64(value | 0b1000000000000000) >> 48;
		*(u16*)data = (u16)value;
		return 2;
	}
	else if (value < 0b00100000000000000000000000000000) { // 0 - 536,870,911
		value = swap_endian_64(value | 0b11000000000000000000000000000000) >> 32;
		*(u32*)data = (u32)value;
		return 4;
	}
	else if (value < 0b0010000000000000000000000000000000000000000000000000000000000000) { // 0 - 2,305,843,009,213,693,951
		value = swap_endian_64(value | 0b1110000000000000000000000000000000000000000000000000000000000000);
		*(u64*)data = (u64)value;
		return 8;
	}
	else {
		// Error: too big!
		return 0;
	}
}
As long as the string is 127 characters or less, you only need 1 byte to store it's length. 16383 and below only needs 2 bytes.

>>2337
Neat! I personally prefer the horrors of compile-time dispatch using Sepples templates, but this looks efficient.

>>2337
One downside of this is that it might be harder to resize data since the beginning of the string may need to move, you have to avoid overwriting the memory from the beginning of the string and such. Honestly, I've had variable length ints my mind for a long time but I can no longer remember what exactly I wanted them for. It was probably for some kind of string lists, arrays of arrays, maybe even data streams for an MMO, or to compete with JSON which technically only needs 3 bytes/characters to separate strings ("",).

I finally found a sweet spot for a custom "language" that's useful, easy to create, and is a pure upgrade instead of downgrading or sidegrading things. It's not really a language as much as a C pre-processor though, it just tweaks a few things about the code.

- New keyword: #section NAME. Starts a new section in the file, all sections with the same name will be combined from all the files. If you organize code into them properly, you won't need header files at all. They'll be in the order that the pre-processor found them in, you can list all the sections at the beginning of the first file to initialize them if you want.
- New keyword #import. It's exactly like #include, except the #import line will be deleted and the file will be loaded and parsed by this pre-processor, and it will only be loaded once so you can #import the same file many times from many files.
- Character literals will be converted to hex values, this allows you to use multiple characters. For example 'Ok!' -> 0x216B4F
- Strings can be prefixed with 'S', it will wrap the string into a struct with length. For example S"Loller coaster" -> ((String){.length=14,.data="Loller coaster"})

I'm wondering what else I could do. My biggest problem with making a pre-processor like this has been that sometimes #ifdefs and macros enable/disable parts of the code or generate names, so unless I process all the macros and #ifdefs myself, I won't be able to properly discover names or types or function definitions.
Here's some things I could potentially do:
- "here strings", i.e. strings with custom delimiters so you can put quotes and new lines in it easily. The main reason I'm not doing this is because my editor doesn't understand them so the syntax highlighting and tabs and everything get totally screwed up.
- A special version of COUNTER that allows you to create different numbers for different categories, for example #unique(foo). I've only wanted it a couple times in my life, so not much interest at the moment, plus you couldn't put it inside a macro.
- Bitfield enums, each member has a different bit enabled. Same as above, rarely need it. I'd want this more if I could fix enums in general.
- Function metaprogramming improvements, for example making a constant ID value available to every function, and having callbacks when you enter or exit a function. For a long time now I've wrapped all my functions and return values into macros because it lets me track/print the call stack without having to install Windows 11, I'd love to be able to just put some keyword somewhere (probably by replacing "static" with "function") and have all those macros injected automatically.

>>2423
https://sundee.neocities.org/slightlybetterc/

a51.png
[Hide] (255.3KB, 432x426)

>>2423
I managed to implement the function metaprogramming stuff. I added a new keyword "proc", it turns this:
proc int hello_world (int x, int y) {
	if (x < 0) return 0;
	y ++;
	return x * y;
}
Into this:
static int hello_world (int x, int y) {const int __func_id__=1;SBC_ENTER 
	if (x < 0) {SBC_EXIT return 0;}
	y ++;
	{SBC_EXIT return x * y;}
}
Basically each function will have a unique ID along with SBC_ENTER at the start, and SBC_EXIT before every return and/or at the end. The point of the special words is that I can now #define SBC_ENTER and add whatever profiling/analytics features I want into them. There's a minor flaw in that the return value should be settled before SBC_EXIT instead of after it, I can probably insert it into an "auto" variable first and return that, but it's slightly annoying to detect whether there is a return value or not.

There's also a list of function names which you can access easily with the function ID.

Several of my biggest annoyances with C are now fixed. Unfortunately all the other things that I most want would require some kind of type checking, and that's probably too complicated.

>>2428
I thought this language would make compile time slightly faster because I was doing something really dumb before (including every file multiple times), but my game ( >>2465 ) went from 2-3 seconds to 3-4 seconds. My "compiler" is basically instant so it's either because #line directives screw up something within GCC, because GCC secretly caches files (my language combines everything into a single file so it can't be cached), or most likely because I changed how some things are compiled. Previously my OS layer was compiled separately, now it's included, but it's also way more lean than before because I don't include the bloated windows headers anymore.

I don't know what to do about this. I want the release build of my game to be a "unity build", but I wonder if I could somehow do incremental builds during development. In an ideal world I would just use TCC instead of GCC, but I need nested functions which to my knowledge are only possible with GCC. I'd need to make a more full-featured compiler to implement those in my language. TCC also doesn't support typed enums (e.g. enum : unsigned short), but I can live without that. Not sure about typeof().

I think my game is still relatively small, everything combined is only ~30k lines of code (20k if you exclude comments and empty lines), stb libraries add another 15k. Compiling at 10000 lines per second is so awful that something must actually be going wrong somewhere, TCC claims to be 9x faster than GCC but even their comparison has GCC at 100k lines per second. I feel like I haven't even begun to implement the actual game.

When you statically compile with musl you get musl's version of dlopen which in theory isn't fully compatible with glibc-based libraries like those OpenGL wrapper libs (libEGL, libX11, etc.).

Which means there is no general solution to mixing glibc and musl based dynamic libraries in the same process memory. You just have to hope libEGL, libX11 etc. don't do anything crazy with pthreads or dynamic allocation as these are dependent on global states.

Also by mixing glibc and musl you'll have two different copies of errno.

A proper solution might have to use unshare/Linux namespaces as a low level isolation mechanism. You create a separate "process" that shares every page of memory. Linux doesn't care about the distinction between threads and processes.

The OpenGL functions you call must be run from the main threads for... reasons. If I have 2 different address spaces but run everything on 1 core, is that supported by your OpenGL implementation? Ask Copilot or ChatGPT reasons you can't call OpenGL from other threads, besides apparent issues with atomics/memory order/synchronization.

This is a huge pain in the butt. You need the skills of a virus maker.

>>2334
>>2498
continued:

From what I remember OpenGL impls depend on unstable, kernelspace ABI that are unique per distro per computer, which severely limits what static linking can do for you.

If a portable distribution is absolutely needed, these are the questions you have to find answers for.

- Why do I have to use an OpenGL function loader? Why can't I just statically link libX11 or libEGL?

- How does libX11 or libEGL communicate with the Linux kernel (I think it's via the Direct Rendering Manager API?) How do those libs communicate with Linux GPU drivers?

- Are those communication mechanisms "ABI-stable" across distros and computers?

- Why are so many OpenGL libraries single-context/single-window? How does that affect you if you require some library mixing or address space isolation/

- How did Blender do it? They have portable zips.

These are important questions if you don't want an unstable mess, but I can't answer all of them, neither can anyone on a random imageboard. Use AI to research.

>>2499
>Use AI to research
Be careful. I just tried to use AI to figure out a file format that's badly documented, and it eventually just started making things up.

screen.png
[Hide] (101.2KB, 760x620)

I think I was supposed to be working on my game, but I accidentally made an image viewer instead.
https://sundee.neocities.org/kaniview/

>>2501
I rember you. You and your LLM prodding.

gpt_problem_solving.png
[Hide] (218.9KB, 1182x4682)

>>2502
AI is great, I looked into gif specification a long time ago but could never actually parse gif files because I was unsure about some details (notably how the frame infos are connected to the frame images and whether the delays are after the frame info (i.e. before the frame) or after the upcoming frame) and because I couldn't find an easily readable implementation of LZW decompression anywhere. AI solved both of those problems because I can ask questions about the details of the format that I'm confused about, and because I can ask for a minimal implementation of LZW without having to spend 20 hours untangling someone else's unreadable mess.

I had some issues with my gif parser so I asked ChatGPT what could be wrong, and pic related is what I got. It told me what parts I'm doing wrong according to the gif spec, and detected a typical rectangle loop bug that I didn't notice (bug #1). Although the loop buy would have been easy to eventually find myself, it made debugging harder because it added an unrelated bug into the mix. Only on hindsight did I realize that one of the visual bugs was clearly caused by a wrong rectangle, but at the time I was interpreting it as being part of the transparency bug so I didn't think to check the loop.

APNG is even more complicated, there's almost no libraries that actually support it and PNG has all kinds of chunks that I don't know how to interpret or what order they're supposed to be in. I can simply ask AI how to approach cutting out APNG frames and converting them into static PNG images, how the different PNG chunks are supposed to play with each other and what order they're supposed to be in, etc.

Yagami_Kou_Presenting_Structured_COBOL.png
[Hide] (1.6MB, 1920x1080)

What are your takes on https://functionalcs.github.io/curriculum/ and https://learnaifromscratch.github.io/ ? They're by the anon who put together that "How to get a solid foundation in compsci mathematics" thread on /prog/ years ago, if any of you remember that ( https://archive.li/sud91 ).

>>2501
checking your website makes me want to stop trying, jesus christ.

>>2515
Why?

If it's because there's a lot of stuff, that's what happens when you program things for 15 years, even if you do it as a hobby and get demotivated for months straight now and then. The only unusual thing about me is how many things there are that I WANT to do, I have an infinite list of programs and websites and games that I still would like to make, but most of them are too big or I'm lacking the ability to do some particular thing. I'm still trying to build a more perfected renderer so I can make proper games, and make a server so I can start making websites or a browser MMO. And that's just programming, I occasionally want to do art and comics and learn music, I wish I got into electronics instead of programming so I could make neat gadgets or maybe even proper hardware or kitchen appliances or something.

If it's because even after all this time I have nothing more significant to show for it than a bunch of little things that are all incomplete and flawed, that's because of my personal problems. I try not to think about how far I could have gotten if I had just worked on stuff every day up to this point instead of procrastinating and losing interest all the time, it's depressing to think about. Psychologically I don't know how to stop doing that though. I've kept a list of ideas and thoughts regarding motivation in hopes of fixing it, one day I'll make a proper page for them. Everything seems to point towards the cause being that I'm too alone, but that's a problem I'm too autistic to fix. I'll make my own imageboard and get my fix of social interaction some day, surely...

>>2516
Multi-talented people often seem to have a penchant for underselling themselves. You have a truly enviable skillset, best of luck.

>>2517
I was probably lucky that I got into art when I was very young, but if I have a "talent" then it's that I don't think of anything as impossible. If I want to do something then I just start doing it, maybe it goes nowhere, maybe I'll learn how to do it along the way.

For example the MMO I mentioned, I've talked about wanting to make one many times in the past but everyone's brains seem to immediately shut off and switch into automatic reply mode and print out that it's impossible and I'm stupid for even thinking about it. Maybe not being that way is a talent of sorts, or maybe there's some ability to see things for what they really are. The way I see it, all I need to do is send a message to the server to move my dude, then the server sends everyone a message that my dude moved to [X,Y], whenever I receive that message from the server I will move the relevant dudes on my screen. That's basically an MMO and there's almost no difference compared to a chat program that a socket programming tutorial teaches you to make.

I also learned programming by just trying to do things, I didn't read any books or go to school. My first experience with programming was not reading a tutorial, it was when I was trying to add new blocks into Minecraft.

>>2518
>For example the MMO I mentioned, I've talked about wanting to make one many times in the past but everyone's brains seem to immediately shut off and switch into automatic reply mode and print out that it's impossible and I'm stupid for even thinking about it. Maybe not being that way is a talent of sorts, or maybe there's some ability to see things for what they really are. The way I see it, all I need to do is send a message to the server to move my dude, then the server sends everyone a message that my dude moved to [X,Y], whenever I receive that message from the server I will move the relevant dudes on my screen. That's basically an MMO and there's almost no difference compared to a chat program that a socket programming tutorial teaches you to make.
It's not an MMO but Atlyss is a great online experience heavily influenced by Phantasy Star Online which was developed by a single person, it's lobby based and online focused, you should check it out, maybe it'll give you some inspiration.

1109e5514311f27ce305a239c3b1e50b65c47c11dc15d614abafe36fca93fe0e.png
[Hide] (622.5KB, 720x540)

>>2516
Fuuuk I wish I'd started programming 10 years earlier or more. Feels like no amount of working my brain to plan something can beat just doing something badly and learning from the experience. So many soft skills like how to layout a project to not be a clusterfuck that I learn the hard way. And even when I'd heard the advice on how to do something properly, I wouldn't know what it really meant until fucking up some codebase later.

Also I played the village clicker and it was fun and I enjoyed depopulating the earth after making all the fishers unemployed.

>>2580
Can't change the past, all you can do is work towards the future. Will the (You) 10 years from now also think "I wish I started working hard 10 years ago"? I feel that way every time I think about the past, I'd probably be running a game company right now if I hadn't slacked off as much over the years (and still continue to). I want to change myself so that future me won't have to think it anymore.

It has already been over 4 months since I discovered >>2410 which I found very insightful, but I've pretty much already forgotten about it, nevermind "changing my workflow" like I was supposed to. I do it a tiny bit more I suppose. Maybe I need to start gluing these kinds of things onto my wall, or make some kind of weekly ritual out of re-reading them.

>played the village clicker
I'm glad you liked it, but I also feel bad because it has a lot of flaws and it would be very easy to improve in all kinds of ways. Problem is that when I think about it, I start drifting towards a different game and then it's not such a quick fix job anymore.

Usdfsdsdtitled.png
[Hide] (484.1KB, 893x886)

>>2581
Here's my "start every week by looking at this" wall for now.

EVERY_DAY.png
[Hide] (497.5KB, 892x1059)

>>2582
Forgot this little piece.

>>2581
>Can't change the past, all you can do is work towards the future. Will the (You) 10 years from now also think "I wish I started working hard 10 years ago"?
POTD
Words of wisdom right there tbh.

>>2582
>>2583
Neat! Thanks, Anon.

>>2428
I am SO CLOSE to making a huge upgrade to this language, but C is fucking shitty AIDS cancer trash so it's ultimately impossible for me to do it without completely changing everything.

The problem is that you can't forward declare a struct, they MUST be in the correct order:
typedef struct X X;
typedef struct Y Y;

struct Y {
	X* a; // OK thanks to the typedef above.
	X b; // Error: b has incomplete type.
};
struct X {
	int c;
};
The only way to fix this is to completely take over type definitions, take them out of the code, sort them, expand macros, parse and validate all the struct members and properties well enough that I can detect every possible error and prevent the C compiler from ever outputting an error related to structs, and probably say goodbye to ever being able to use a debugger with this.

>>2585
I don't want to discourage you or be one of those anons that post 'why don't you just [thing]' but is there a reason you're not using a language that has the features you desire? Or have you tried and don't like them?

>>2586
I hate every other language even more than I hate C.

C is like 90%+ of the way to being perfect for me, but the remaining 10% add friction that demoralizes me. I could fix almost all of it trivially if I didn't have to worry about the C compiler giving screwed up error messages or showing the wrong line numbers. I don't use a debugger but that would also become a problem if I transform the code too much.

>>2587
Unfortunately, C is the best that we have today, unless you'd like to make your game in BASIC.

milky_holmes_dont_forget_you're_here_forever.png
[Hide] (1.2MB, 1605x850)

>>2581
>Can't change the past
I'm not too bothered about the past to be honest. If anything, most of the major bottlenecks I've had probably could have been alleviated by just looking at other people/code and applying a bit more common sense.

>lot of flaws and it would be very easy to improve
Yeah it was kinda like that. I found myself using my click macro a decent amount to get started and I couldn't even demolish buildings I'd made by mistake. But I found it remarkable how I spent most my effort in my own imagination. It's not something I can do when just testing some prototype I've made since such exertion is exhausting. I suppose the point is I found it effortless to play. Contrast with times I've quit out on games that lathered me with UIs and tutorials.

>workflow
I only manage this when I make a new project and force myself to adapt the new change. Not sure why but it is what it is - some desire to maintain consistency with workflow I guess. Or some type of psychological gigo where I only really see myself program and become strangely set in my ways despite it not being that much to change. I guess this mirrors what I said at the start about interacting with more people.

>>2582
>>2583
Oh cool. Here's mine (pic related).
I try to do a bit everyday, but I've kind of transitioned to writing since it's so much easier to write that something happened instead of programming an entire interactive experience to show it. That, and after making a few barren simulation like things, I realised the meat of games to me is the story/aesthetic. Programming art does feel better though when 'player' is replaced by the actual character I had in mind.

I hate how hard it is to improve C syntax. I've thought about this for 8 million years by now and keep going in circles, trying the same old ideas again and expecting a different outcome. C is great in how there's almost no unnecessary words/symbols:
struct X {}; // Type
struct {} X; // Variable
struct {}; // Anonymous
int X;
typedef int X;
int X (int) {}
Enums require an extra symbol to separate the type, which is not ideal:
enum X {};
enum X : int {};
enum : int {};
The biggest problem however are functions and function pointers, which are a huge fucking mess:
[[nodiscard]] int __stdcall X (int) {};
[[nodiscard]] int (__stdcall *X) (int);
I think adding a new keyword for functions would be fine or even desireable (since that allows you to search for them), but it doesn't solve all the problems (the mess gets worse if you want to return a function pointer or something). I want to unify all of these into a very clean and consistent syntax, but the only way I can think of is to add a keyword:
// Define types or functions
define X int;
define X struct {};
define X enum u16 {};
define X func int (int x) __stdcall {}
// Variables, identical except change "define" into "var"
var X int;
var X struct {};
var X enum u16 {};
var X func int (int x) __stdcall;
This is the best syntax I have been able to come up with. What I like most is that the definition of the type/function stays exactly the same regardless of where it is. This is somewhat similar to the colon-based syntax that some new languages use (I think originating from Pascal?):
// Define types or functions
X :: int;
X :: struct {};
X :: enum u16 {};
X :: func int (int x) __stdcall {}
// Variables, identical except only 1 ":"
X : int;
X : struct {};
X : enum u16 {};
X : func int (int x) __stdcall;
I think my syntax is better. It's more descriptive, the colon is kind of distracting, you can intuitively make a variable constant just by replacing "var" with "const", and you can omit the keyword where variables are implied:
// Arguments and struct members are implicitly variables, so "var" is not necessary.
define X func int (x int, y int) {
	...
}
define X struct {
	x int;
	y int;
}
// The colon is ugly as shit, but removing it would create inconsistent syntax.
X :: func int (x : int, y : int) {
	...
}
X :: struct {
	x : int;
	y : int;
}

It would be cleaner to put the function return type after the arguments, but if the return type and function modifiers are in the same side, the function modifiers start to become hard to tell apart from the return type modifiers. The easiest way to see it is when you return a function pointer, which function do __stdcall and inline refer to, the returned function pointer or the function that returns it?:
define X func (x int, y int) &func (x int, y int) int __stdcall inline {}
By putting the return type before the arguments and modifiers after, it becomes more obvious:
define X func &func int (x int, y int) __stdcall (x int, y int) inline {}
It's still ugly but I don't know what else to do. This is useful with return type modifiers in general, like if you return a memory-aligned pointer or something. You could put function modifiers before arguments and I'm still considering it, but if a function has lots of modifiers it's easier to ignore them when they're after arguments:
// Modifiers after arguments
define X func int (x int, y int) [[nodiscard]] static inline __stdcall {}
// Modifiers before arguments
define X func [[nodiscard]] static inline __stdcall (x int, y int) int {}

>>2605
Just realized there's a small odd part in my syntax: defining a function vs defining a function type.
// Define a function.
define do_thing func (x int) int {
	printf("%i\n", x);
}
// Define a function type.
define do_thing func (x int) int;
The only way to differentiate them is the presence of a semicolon vs an open brace.

b956b1e88801e33c85cdfacaef9a43499401cf1a50346bfb9f44476f20fe3316.png
[Hide] (39.2KB, 640x480)

I made a kde plot of sentiment for all the posts on this board to measure poster wellbeing. Each post is a triplet [Neg,Neu,Pos] of scores in [0,1]. Density is somewhat analagous to frequency (probability density): a high density at Positive=0.1 means there's many posts with low positive sentiments. The area under each curve should be about same, representing all posts.


There's a few funny trends:
On the green graph on the right you see the twin peaks of Mt. Optimism followed by Mt. "Tthere's Still Hope" with the valley of broken dreams between.

This subsides to the blue moutain of semi-neutral progress-bores, with an undercurrent of seething impotent rage. 

The left shows the complete lack of positive thoughts that overwhelm the majority of posts, and to a lesser degree negative thoughts too since we are such well rounded people that do not take our anger out on our tools.

>ask Grok for code that puts files into a zip file
>works but 32-bit only (4 GB size limit)
>ask for 64-bit version
>doesn't work
>ask ChatGPT
>gives a 32-bit version despite me asking for 64-bit
>ask for 64-bit version
>breaks because I forgot to enable cookies
Had to ask Grok again with even more specific requirements. I have no idea how correct this actually is, but it seems to work, maybe some day I'll bother to check some kind of documentation to make sure:
typedef struct {
	char* name;
	char* path;
	u64 offset;
	u64 size;
	u32 crc;
} Zip_file;

static u32 zip_crc32 (u32 crc, u64 length, u8* data) {
	// u32 crc = zip_crc32(0xFFFFFFFF, x, x); // You can feed the crc back to this function if you want to generate the value in small chunks.
	for (u64 i=0; i<length; i++) {
		crc ^= data[i];
		for (int j=0; j<8; j++) crc = (crc >> 1) ^ (0xEDB88320 * (crc & 1));
	}
	return ~crc;
}
static int create_zip (char* path, int file_count, Zip_file* files) {
	File zip = create_file(path);
	
	#define WRITE_U16(value)    do{ u16 v = value; append_to_file(&zip, sizeof(v), &v); }while(0)
	#define WRITE_U32(value)    do{ u32 v = value; append_to_file(&zip, sizeof(v), &v); }while(0)
	#define WRITE_U64(value)    do{ u64 v = value; append_to_file(&zip, sizeof(v), &v); }while(0)
	#define WRITE(length, data) do{ append_to_file(&zip, length, data); }while(0)
	
	for (int i=0; i<file_count; i++) {
		Zip_file* file = files+i;
		
		u64 f_size = 0;
		void* f = NULL;
		read_file(file->path, &f_size, &f);
		if (!f_size) {
			printf("Failed %s\n", file->path);
			delete_file(&zip);
			return 1;
		}
		file->offset = zip.size;
		file->size = f_size;
		file->crc = zip_crc32(0xFFFFFFFF, f_size, (u8*)f);
		
		WRITE_U32(0x04034b50);
		WRITE_U16(45);
		WRITE_U16(0);
		WRITE_U16(0);
		WRITE_U16(0);
		WRITE_U16(0);
		WRITE_U32(file->crc);
		WRITE_U32(0xFFFFFFFF);
		WRITE_U32(0xFFFFFFFF);
		WRITE_U16(strlen(file->name));
		WRITE_U16(28);
		WRITE(strlen(file->name), file->name);
		WRITE_U16(0x0001);
		WRITE_U16(24);
		WRITE_U64(file->size);
		WRITE_U64(file->size);
		WRITE(f_size, f);
		
		free_file(&f);
	}
	
	u64 central_dir_start = zip.size;
	
	for (int i=0; i<file_count; i++) {
		Zip_file* file = files+i;
		
		WRITE_U32(0x02014b50);
		WRITE_U16(45);
		WRITE_U16(45);
		WRITE_U16(0);
		WRITE_U16(0);
		WRITE_U16(0);
		WRITE_U16(0);
		WRITE_U32(file->crc);
		WRITE_U32(0xFFFFFFFF);
		WRITE_U32(0xFFFFFFFF);
		WRITE_U16(strlen(file->name));
		WRITE_U16(32);
		WRITE_U16(0);
		WRITE_U16(0);
		WRITE_U16(0);
		WRITE_U32(0);
		WRITE_U32(0xFFFFFFFF);
		WRITE(strlen(file->name), file->name);
		WRITE_U16(0x0001);
		WRITE_U16(28);
		WRITE_U64(file->size);
		WRITE_U64(file->size);
		WRITE_U64(file->offset);
		WRITE_U32(0);
	}
	
	u64 central_dir_size = zip.size - central_dir_start;
	u64 zip64_eocd_offset = zip.size;
	
	WRITE_U32(0x06064b50);
	WRITE_U64(44);
	WRITE_U16(45);
	WRITE_U16(45);
	WRITE_U32(0);
	WRITE_U32(0);
	WRITE_U64(file_count);
	WRITE_U64(file_count);
	WRITE_U64(central_dir_size);
	WRITE_U64(central_dir_start);
	
	WRITE_U32(0x07064b50);
	WRITE_U32(0);
	WRITE_U64(zip64_eocd_offset);
	WRITE_U32(1);
	
	WRITE_U32(0x06054b50);
	WRITE_U16(0);
	WRITE_U16(0);
	WRITE_U16(0xFFFF);
	WRITE_U16(0xFFFF);
	WRITE_U32(0xFFFFFFFF);
	WRITE_U32(0xFFFFFFFF);
	WRITE_U16(0);
	
	close_file(&zip);
	
	return 0;
}
void main () {
	Zip_file files [] = {
		{.name="items.json", .path="C:/foo/items.json"},
		{.name="sprites.png", .path="C:/foo/sprites.png"},
		{.name="info.txt", .path="C:/foo/info.txt"},
	};
	create_zip("C:/foo/test.zip", sizeof(files)/sizeof(Zip_file), files);
}

On one hand it's great how I can get AI to handle file formats and APIs for me that I never had the motivation to research, but on the other hand it's concerning how often it doesn't work or has something weird about it. I just really don't want to start researching this kind of shit myself at all.

2026-03-30_tff.webm
[Hide] (501.6KB, 1000x600, 00:18)

Got motivated to work on my MS Paint. Selections were one of the critical missing features, they're actually usable now. Can't resize them though.

I've always wished these programs had a way to copy/paste RGBA color values, but then I realized that there isn't actually any benefit to having separate inputs for R/G/B/A.

>>2619
Not gonna lie, I love to use ai as easy documentation since it has a bunch of example usages of APIs in it's knowledge.

2026-03-30_crop.webm
[Hide] (254.9KB, 1000x600, 00:13)

2026-03-30_scroll.webm
[Hide] (161.8KB, 650x160, 00:20)

>>2622
Fixing some of my other MS Paint pet peeves. Dragging/pasting an image will place it as a selection, and there's buttons to expand/crop/replace the canvas. MS Paint replaces the current image and/or auto-resizes canvas, both of which can be annoying, but this way you have full control.

Clicking the RGB text input will select the clicked number for easy access, and using the scroll wheel will increment/decrement it (same as the gradient sliders).

This was already implemented, but: when I first learned that you can shorten a hex color like #FF44DD into just #F4D in the web, and that you can optionally add 2 and 1 digits to those respectively for alpha, I've always wondered what other ways you could shorten color values. So I added 1 and 2 -digit RGBA values for easy grayscale input, 1 digit puts the value into R/G/B and sets A to 255, and 2 digits puts the first into R/G/B and second into A.

>>2624
That's my favorite use of AI. As far as I'm concerned, whoever invents a file format should give you the code to read and write it, but as far as I know some things like GIF or APNG have no such thing. But simultaneously I hate libraries because of how bloated they are and how annoying it is to build things in C/C++, and even if you wanted to read the code, most people write very hard-to-read code. AI bridges that gap since I can get very minimal amount of code that does exactly the thing I need.

APIs have a similar but different problem: they're often convoluted and/or badly designed and/or it's hard to find the right things from documentation. For example file format libraries often have an "easy API" and a "low level API", the easy API makes some wrong assumptions like the fact that I'd want to give it a file path to load the file from, even though what I want is to give it a memory buffer with the file data in it. I don't want every library to implement OS file loading. But then the low level API that would allow me to do what I want is very convoluted and badly documented. There's a lot of things I haven't been able to do before because this is all so bothersome and too complicated to bother with, but AI makes it a breeze.

It still gets some things wrong sometimes though, or implements things in a strange way. Maybe the paid models are better, but I'm not paying for that.

124263475477.png
[Hide] (140.8KB, 403x445)

I just spent like 4 hours debugging, and turns out it's a Windows problem. There's a Windows API that randomly throws exceptions on purpose, not because there was an error, but just for some random internal state changes. If you capture exceptions and try to go run your own error handling routines, the Windows API will corrupt everything.

>>2627
That sucks (as expected of Wangblows). Did the last White man with two brain cells to rub together at least give you an exception type you could NOP on in your loop before he turned out the lights and left the building there at M$?
[code]catch (pooshit_exception_type_388904 const& e) {
  // do nothing because reasons lol
}[/code]

1393425383567.png
[Hide] (75.7KB, 231x231)

>>2627
>use the API to browse for files to load
>returns nothing no matter what I select
>use same API to browse for a path to save file to
>returns 2 file paths, one is the path I selected, the other is a completely unrelated path from my program and disconnected from any part of this process and never used in anything related to this API
>take a 3 hour break
>try to save a file again
>now it returns nothing too
I swear someone is watching and doing this to me and laughing right now. I finally start getting some of my productivity back, and this is the kind of shit that starts happening.

>>2628
It's not a C++ kind of exception. I'm using Windows' vectored exception handler which is called first when any exception anywhere occurs, I can fix this problem by switching to a "higher level" one (unhandled exception filter), but 99% of my own crashes will corrupt the call stack and/or related memory and prevent me from creating an error report. I don't actually know why but the vectored one seems to catch those crashes before they fuck shit up.

I can check for this particular exception code and pass it forward to whoever is expecting to handle it, but there might be other exceptions that fuck things up in a similar way, I can't check for those because I don't know if/what they are until they happen. I can disable exception handling when using this particular API, but firstly I don't know what other APIs might have the same problem, and secondly the exception handler is attached to all threads so disabling it will also disable error reporting for other threads. I could use a real debugger but that would require me to switch to Windows 11 and probably change my compiler which would require all kinds of changes in my codebase, I'd rather stop programming at that point. Basically there's no correct way to deal with this.

>>2629 
Never mind the second one started returning nothing because I had commented that part out.

>>2629
>anon using a 14 year old crop of mine
Horee shit.