moecs - easy to use entity component system crafted with odin

modev

I am writing this project in my spare time, just like all my other hobby gamedev. If you want the highest performance, it's best not to use any ECS. I love ECS because it allows you to systematize and separate/parallelize logic/data, move each part of the game into its own system, customize its operation, and generalize logic for entities with different components. moecs only has the basics and doesn't yet have some of the features found in others (hierarchy, relationships, prefabs, etc.) and perhaps will never have because of performance overhead. But if you really need some feature you can open an issue. As for speed, it will vary on different computers. You can play around with main.odin, and see the benchmarks (I use this code for testing). I'd be interested in seeing your results.

My tests show this:

With 7 components, 3 systems, 1 million entities, 6 archetypes, world progress 100 times takes 56 milliseconds (at each iteration: 1 system adding component to 100 entities and despawning one entity and 2 others getting 6 components for each entity)

Complete description with examples you can find in readme on github: helioscout/moecs

I also built simple space game as a demo.
helioscout/mouniverse

Peter

Nice. I read the Wikipedia article but still don't fully understand what an ECS is.
https://en.wikipedia.org/wiki/Entity_component_system
As far as I understand it, it helps to "manage" 3D objects and complex data.

This ECS is usable only with the Odin programming language?

modev

Yes, this one only with Odin.
Very popular one is flecs - https://flecs.dev.
It have bindings to other languages.
ECS helps write game logic in data oriented style.
You create entity, it can be a spaceship, then you add Position, Sprite, Rotation components.

You have a systems - functions that select entities/components by some configuration (set of them) and you can iterate through entities and make some actions, draw them for example, or update their components values based on physics changes in other system.
Systems executes one by one, so you craft your game logic this way.

If you have collision from physics library you can add Collision component (data struct instance) to collided entities and in some other system you select such entities and make some actions, draw spark or smth.

ECS is just a tool, many devs do not like them.
I like for the reason I wrote in first message of this post.

Peter

modev Ah, I understand now. Thanks for the explanation.

For small games an ECS is overkill I think. But I can see its use cases now. :) Edit: For example quests in an RPG I think. But many other stuff, too.

modev

I have added ability to relate entities by some relationship type + data.

import ecs "moecs/src"

Joint :: struct {
  type : u8,
  data : [16]f32
}

/* Related event callback. Relation of `type` is set from `entity` to `target` using `relation` data. */
related :: proc(world: ^ecs.World, entity: ^ecs.Entity, event: ecs.Event, type: typeid, target: rawptr,
  relation: rawptr) {
	switch type {
		case ecs.ChildOf: fmt.printfln("Related: %v, %v", type, (cast(^ecs.ChildOf)relation)^)
		case ecs.ParentOf: fmt.printfln("Related: %v, %v", type, (cast(^ecs.ParentOf)relation)^)
		case Joint: fmt.printfln("Related: %v, %v", type, (cast(^Joint)relation)^)
	}
}

main :: proc() {
  arr := [3]int{ 3, 7, 14 }
  
  ecs.init()
  world := ecs.new_world()
  /* ...register tags and components types here. */
  /* You have to register relation type. */
  ecs.register(world, .RELATION, Joint)
  ecs.run(world)

  /* You can query entities with relations as you made for components/tags in systems. */
  ecs.mount(world, query = { Joint, ecs.ParentOf }, callback = drive)
  /* You can set observers for creating/destroying relations between entities. */
  ecs.observe(world, event = .RELATED,   types = { ecs.ParentOf, ecs.ChildOf, Joint }, callback = related)
  ecs.observe(world, event = .UNRELATED, types = { ecs.ParentOf, ecs.ChildOf, Joint }, callback = unrelated)

  e1 : ^ecs.Entity = ecs.spawn(world, .DYNAMIC)
  e2 : ^ecs.Entity = ecs.spawn(world, .DYNAMIC)
  e3 : ^ecs.Entity = ecs.spawn(world, .DYNAMIC)

  /* Set e1 as parent of e2. */
  ecs.parent_of(e1, e2)
  /* Set e1 as parent of e3 and add relation data. */
  ecs.relate(e1, ecs.ParentOf { data = nil }, e3)
  /* Relate e1 with e3 by Joint relation and add relationship data. */
  ecs.relate(e1, Joint { type = 7, data = { 0 = 1, 1 = 2, 2..<16 = 3 }}, e3)
  /* Relate e1 with e2 by Joint (add e2 to this relation targets list),
     relationship data is replaced, here by zeroed struct (Joint {}). */
  ecs.relate(e1, Joint, e2)

  fmt.printfln("e1 is parent of e2: %v", ecs.is_parent_of(e1, e2))
  fmt.printfln("e2 is child of e1: %v", ecs.is_child_of(e2, e1))

  e4 := ecs.spawn(world, .DYNAMIC)
  e5 := ecs.spawn(world, .DYNAMIC)

  /* Make e1 also parent of e4 (e3 is still a child), data replaced. */
  ecs.parent_of(e1, ecs.ParentOf { data = &arr }, e3, e4)

  fmt.printfln("e1 is parent of e2, e3, e4: %v", ecs.related(e1, ecs.ParentOf, e2, e3, e4))
  fmt.printfln("e2 has relations: %v", ecs.is_relation(e2))
  fmt.printfln("e2 is relation target of e1: %v", ecs.is_relation_of(e2, e1))
  fmt.printfln("e2 is relation target of e3: %v", ecs.is_relation_of(e2, e3))
  fmt.printfln("e3 with e1 relation of count: %v", ecs.relation_of_count(e3, e1))

  /* Remove Joint relation between e1 and e3. */
  ecs.unrelate(e1, Joint, e3)
  /* Remove relation ParentOf between e1 and e3 using specific proc. */
  ecs.unrelate_with(e1, ecs.ParentOf, e3)
  /* Remove all parent relations with all e1 children. */
  ecs.unrelate(e1, ecs.ParentOf)
  
  fmt.printfln("e1 is parent of e2, e3, e4: %v", ecs.related(e1, ecs.ParentOf, e2, e3, e4))

  /* Set e1 and e2 as parents of e4. */
  ecs.child_of(e4, e1, e2)
  
  fmt.printfln("e4 is child of e1: %v", ecs.is_child_of(e4, e1))
  fmt.printfln("e4 is child of e2: %v", ecs.is_child_of(e4, e2))

  /* Get all ParentOf relations of e1, e is a slice to entity pointers, r - relation data pointer. */
  r, e := ecs.relations(e1, ecs.ParentOf)
  /* Get first parent of e4, parent is pointer to the entity. */
  parent := ecs.parent(e4)
  /* Get all parents of e4, parents is a slice of pointers to the entities. */
  parents := ecs.parents(e4)
  /* Get first child entity of e1, child is pointer to the entity. */
  child := ecs.child(e1)
  /* Get all children of e1, children is a slice of entity pointers. */
  children := ecs.children(e1)

  ecs.destroy()
}