rotor-nelua's Introduction

Rotor

Rotor an ECS written in Nelua.

Please check the docs and the examples.

Simple Example

local math = require 'math'
local os   = require 'os'
local io   = require 'io'

local storage   = require 'rotor.storage'
local component = require 'rotor.component'
local entity    = require 'rotor.entity'
local system    = require 'rotor.system'

-- components --
local Position = @component(@record{ x: integer, y: integer })
local Velocity = @component(@record{ x: integer, y: integer })
local Name     = @component(@record{ data: string })

local Rightmost = @record{
  pos: Position,
  name: Name
}

-- systems --
local MovementSystem = @record{}

function MovementSystem:run(c: record{vel: *Velocity, pos: *Position})
  c.pos.x = c.pos.x + c.vel.x
  c.pos.y = c.pos.y + c.vel.y
end

local RightmostSystem = @record{
  rightmost: Rightmost,
}

function RightmostSystem:init()
  self.rightmost.pos.x = math.mininteger
end

function RightmostSystem:run(c: record{pos: *Position, name: *Name})
  if c.pos.x > self.rightmost.pos.x then
    self.rightmost.pos = $c.pos
    self.rightmost.name = $c.name
  end
end

local Systems = @record{
  movement_system: system(MovementSystem.run),
  rightmost_system: system(RightmostSystem.run),
}

-- entity --
local BasicEntity = @entity(@record{
  position: Position,
  velocity: Velocity,
  name: Name,
})

-- setup --
local entity_storage: storage(BasicEntity, 64)
local systems: Systems

systems.rightmost_system.data:init()

-- let's create 64 entities!
print 'creating!'

for i = 0, < 64 do
  math.randomseed(os.time())

  -- create a new entity with an position, velocity and name
  local ok, id, entity = entity_storage:push({
    position = { x = math.random(-100, 100), y = i },
    velocity = { x = math.random(-200, 200), y = 0 },
    name = { 'some entity' },
  })
  assert(ok)
  assert(entity.name.data == 'some entity')
end

-- running --
-- let's execute movement system 10 times
for _ = 1, 10 do
  print ('executing movement system')
  systems.movement_system:run(&entity_storage)
end

print ('executing rightmost system')
systems.rightmost_system:run(&entity_storage)

local rightmost = systems.rightmost_system.data.rightmost

io.printf("entity '%s' is in the rightmost position.x: %d\n", rightmost.name.data, rightmost.pos.x)

rotor-nelua's People

Contributors

Stargazers

Watchers

rotor-nelua's Issues

Add new rotor concept: `entity_compatible_with(MyEntity.value)` and it's `ptr` variant

This eases development with derived entities.

Usage example:

local rotor_concepts = require 'rotor.concepts'

local SpriteEntity = @entity(@record{
  entity_data: EntityData,
  sprite: Sprite,
  painter: Painter,
})

local an_sprite_entity_ptr = #[rotor_concepts.value.entity_ptr_compatible_with(SpriteEntity.value)]#

local Inputs = @record{ --[[...]] }

function SpriteEntity.derived_init(sprite_entity: an_sprite_entity_ptr, inputs: Inputs)
  sprite_entity.entity_data = {
    id = inputs.sprite.id,
    mask = inputs.sprite.mask,
  }

  -- ...
end

`storageT:push` should also return a reference to the newer entry

If I push an entity and then need to make some configuration on it, then something like this is needed:

local ok, id = Enemy.storage:push(Enemy.Entity.init(pos))
check(ok, 'error: enemy could not be pushed to storage')

local ok, enemy = Enemy.storage:mget(id)
check(ok, 'error: enemy could not be got from storage')

enemy.collider.entity_id = id

If push also returned a reference to the pushed entry, then this nicer code would be possible:

local ok, id, enemy = Enemy.storage:push(Enemy.Entity.init(pos))
check(ok, 'error: enemy could not be pushed to storage')

enemy.collider.entity_id = id