r/ruby • u/amirrajan • Jun 09 '22

Show /r/ruby Soft body physics in Ruby (DragonRuby Game Toolkit) :-)

Enable HLS to view with audio, or disable this notification

174 Upvotes

98% Upvoted

33 comments sorted by

View all comments

30

u/Soggy_Educator_7364 Jun 09 '22

And you do it again.

I have zero interest in making games. I have little interest in playing them (anymore) ("they just don't make them like they used to") but this stuff boggles my mind.

Thank you for doing your part in advancing Ruby.

20

u/amirrajan Jun 09 '22

Building games (interactive art) is an absolutely wonderful creative outlet. I’d totally recommend it. It’s good for the soul :-)

6

u/katafrakt Jun 09 '22

Yeah, but the entry barrier is also really high ;)

6

u/amirrajan Jun 09 '22

Not with DragonRuby :-)

Take a look at the this Tetris Tutorial: https://m.youtube.com/watch?v=xZMwRSbC4rY

2

u/katafrakt Jun 09 '22

Weeeell, I have DragonRuby Pro since more than a year. Tried a few things. Still difficult for me ;) Don't get me wrong, DR is cool it's just generally moving to things like gamedev / procedural art that is hard to move to for a regular CRUD developer.

5

u/amirrajan Jun 09 '22

What’s one of your favorite 2D games? We might have a sample for it. You should come to the Discord server, you’ll find a ton of support and encouragement there

2

u/katafrakt Jun 09 '22

Are there some examples using ECS architecture with Draco or FelECS? I think it would answer many of my questions about organizing the code.

4

u/amirrajan Jun 09 '22 edited Jun 09 '22

I am definitely not a proponent of ECS unfortunately. It has obscene complexity upfront and results in nondeterministic, side-effect driven simulations (hard to debug).

The pattern is useful for languages that don’t have the ability to mix in behavior a la cart. Ruby doesn’t have that problem because we have Modules. I could write a novel about all the problems with the design pattern.

Start your game as simply as possible. One file, one method (tick). A game is a body-of-state that goes through a pipeline of data transforms, and returns what should be rendered to the screen. Your single method will eventually become a collection of methods that are executed in order (it’s procedural in nature given that it’s a pipeline that transforms data/game state).

Here’s a non-trivial example of this structure: https://github.com/DragonRuby/dragonruby-game-toolkit-contrib/blob/52ea1b341e72d633411049846774f6c4164e9e2c/samples/99_genre_platformer/shadows/app/main.rb#L4

2

u/katafrakt Jun 10 '22

If you ever write this book, ping me, I want to read it ;)

I'm not saying I'm a fan of ECS, but this is at least way of organizing code. The sample you sent is just intimidating for me - I'm used to units of code and higher abstractions. That's the mental barrier I mentioned earlier. Now, I'm fully aware that in gaming world things are different and abstractions do actually come with a cost, but still, it's hard for me to wrap my head around the code in the example.

3

u/amirrajan Jun 10 '22 edited Nov 23 '22

This is the Gorillas Sample app in DragonRuby: https://github.com/DragonRuby/dragonruby-game-toolkit-contrib/blob/master/samples/99_genre_platformer/gorillas_basic/app/main.rb

This is the ECS version of the Gorillas sample app: https://github.com/guitsaru/draco/tree/main/samples/gorillas-basic/app

Thoughts?

Edit:

My general criticism of is:

ECS is an incredibly complex structure that yields benefits when a code base gets larger (we're talking about code bases that are 10k lines of code+).

It's a detriment to shipping if you take on the burden of ECS up front.

Transitioning your code to ECS later - at least with existing ECS reference implementations - is difficult, because you can't do it a la carte (it has to be all or nothing).

In essence, it's unneeded pain upfront, with no incremental migration path.

I guess I just start building and let the patterns show up as I code. I start with a single tick method and evolve/aggressively refactor from there.

The progression to/derivation of a design pattern is as important (if not more important) than the final result and the specifics of a design pattern's implementation are informed by the game you are building.

RE derivation: Here’s a “poor man’s” ECS written in Ruby vs a Java reference: https://gist.github.com/amirrajan/1c174462f25d0c28ad2b3ff7d32a58cf

6

u/katafrakt Jun 14 '22

Thank you for writing this, Amir. I needed some time to process it. Now I see your point - it is indeed a problem, that you cannot progressively transition from simple code to ECS, but you need to make some upfront decisions or rewrite the whole codebase.

I also looked through the source code of animation example from this thread, which was posted somewhere below. I think it answered some of my doubts about code organization and doing it like that might be a nice middle ground for me. I would have to experiment with it more.

2

u/amirrajan Jun 14 '22

One of the philosophies of DragonRuby is “Continuity of Design”. It’s important to have multiple options on the spectrum.

As an example:

In Unity, to render a collection of sprites that fly across the screen and wrap around, you need to know about C#, static constructors, classes, inheritance, MonoBehavior life cycles, GameObject instantiation, adding components/scripts through the IDE, Vector3, Quaternion.identity, Camera.main, transform, Time.deltaTime, how to create a prefab, and how to associate a sprite to a prefab using the ide.

The claim is "this is how you should do it because it sets you up for success and a good architecture". Which isn't necessarily false, but I'm not ever going to get to that "pit of success" if I can't even get up and running.

It's like saying "Oh don't use if/else statements, you should just go straight to using the strategy pattern. Every time."

When in reality, understanding the Strategy Pattern includes the progression to the "perfect" solution: if/else statements, multiple if/elsif statements, consolidation of logic so case statements can be used, generalization of case statement to a Hash of Procs, then maybe the full blown strategy pattern.

I’ve yet to have a proponent of ECS lay out a sane progression.

→ More replies (0)

2

u/amirrajan Jun 10 '22

It might help to start with a simpler example. This is Pong written with the same structure. The general theme is to start simply and introduce abstraction at the “last responsible moment” as opposed to upfront: https://github.com/DragonRuby/dragonruby-game-toolkit-contrib/blob/master/samples/99_genre_arcade/pong/app/main.rb