akhra

🏴🚩⚧️⚢♾️ΘΔ⚪

  • &🍯she/her 🐲xie/xer 🦡e/em/es

wenchcoat system:
🍯 Akhra (or Melli to disambiguate), ratel.
🐲 Rhiannon, drangolin.
🦡 Lenestre, American badger.

unless tagged or otherwise obvious, assume 🍯🐲🦡 in chorus; even when that's not quite accurate, we will always be in consensus. address collectively as Akhra (she/her), or as wenchcoat (she/her or plural).

💞@atonal440
💕@cattie-grace
❤️‍🔥(not#onhere)
🧇@Reba-Rabbit


Discord (mention cohost, I get spam follows)
@akhra
Discord server ostensibly for the Twitch channel but with Cohost in hospice y'know what let's just link it here
discord.gg/AF57qnub3D

finally seeing the light at the end of my burnout, and been poking around game engines. after the Unity debacle there was a ton of love for Godot so it was top of my list to start poking at. soon as I really got into it tho, I discovered that the lead is an outspoken anti-ECS grognard who adores single-inheritance and I am suddenly deeply leery of what kind of code I'm gonna have to write here.

so the question is: how does this shake out in practice? am I going to get dragged into managing inheritance trees within my own code, or is it reasonable (beyond toy scale) to just inherit from built-in classes for nearly everything, keeping it mostly just one layer deep?

because I can deal with the latter in exchange for a good tooling suite; but if it's the former I need to start mulling the choice between Unity(😬) which appears to be the only option supporting paradigms I don't actively loathe and all those slick pretty tools, or just abandoning the allure of GUI engines (and escaping OOP entirely, because if it's gonna be all bare code, it's gonna be Haskell).


You must log in to comment.

in reply to @akhra's post:

In practice the engine is flexible enough with the node and signal system that an ECS (or even just reusable components) as a paradigm is possible, but may not have the performance of one.

This seems to be one of the only written resources I could find, but some of the GDScript will likely be out of date for Godot 4.

https://www.gdquest.com/tutorial/godot/design-patterns/entity-component-system/

There is a more up to date video resource for Godot 4; I haven't gone into the further videos of this series but the first one made the concept click for me to attempt the rest myself.

https://www.youtube.com/watch?v=zUeLesdL7lE

Of course these are the lowest friction options to hit the ground running, there is also diving into the Godot Server Architecture (barely documented) to write systems outside of the base engine.

thanks for the resources, I'll take a look! and yeah I'm not really concerned about performance for this project (2D, turn-based) nor actually married to ECS; it's just the most likely candidate in the OOP realm for a paradigm that won't feel like a slog through a minefield after years of attunement to FP. 😛

If you want Unity-like ECS stuff but without shitty devs, maybe check out Flax. https://github.com/FlaxEngine/FlaxEngine

It's not too difficult from what I messed around with. Has C# support but more importantly has really easy C++ support. Like, I didn't feel like I was fighting the engine to get C++ stuff working. It's also less distinctly corporatized than Unity, though it's not proper FOSS. So there's still licensing fees, but they're definitely not bad. And only kick in after $250,000 in revenue at this point.

I enjoy using Godot for my own projects, I find it very easy to iterate with. However, things like multiple inheritance may be more difficult to work with (unless you just have multiple sub-nodes with your various child classes operating on your main node or something), so if that's a requirement for you, do consider checking Flax.

ooh, hadn't heard of this one! for the projects I'm looking at immediately (fairly simple, minimal performance concerns) I'm only compromising into OOP at all for access to a nice integrated GUI tool suite; if I give up on that, I'm just gonna do it in Haskell lmao. (and I flat refuse to touch C++, now that Rust exists.) solid list of features here tho, and C# is tolerable, glad to have it on my radar!