kiwi-ecs 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b17b772e56b3533bac84c71c609eb8544908667c4cac99725327399d1fd44fed
+  data.tar.gz: d8669b034e3db56f038919b60aa8f7f2b36eb6b98e7f12d22f533ac2c2680454
+SHA512:
+  metadata.gz: f5e2f0b3770ffe2eeebd64f590aec863fc8074f4ec1331578f1a7f5ee42ac69e8ca257c3cf9717f8e7b43c876dbe80f946e9e74045e0a4efa9feaeb78b8b05c7
+  data.tar.gz: a42b7f00ee919b7cd1d37f70c0a19f1b217d429f604f67e0a99734c4de4336d7bcecea9235e244fb884c93288f06df38c9b9e4a453520e7ce86809c92ad5a6e0

data/lib/arch_store.rb

@@ -0,0 +1,30 @@
+require_relative 'archetype'
+
+class ArchStore
+  # [[Integer]:Integer]
+  attr_accessor :compMap
+  
+  def initialize
+    # [Archetype]
+    @archetypes = []
+    # [[ComponentId]:ArchetypeId]
+    @compMap = Hash.new
+  end
+
+  def get(archetypeId)
+    return @archetypes[archetypeId]
+  end
+
+  # @params [Array<Integer>] componentIds: a sorted array of component ids
+  def get_archetype_id(componentIds)
+    archId = @compMap[componentIds]
+    if archId != nil
+      return archId
+    else
+      id = @archetypes.size
+      @archetypes.push Archetype.new(componentIds)
+      @compMap[componentIds] = id
+      return id
+    end
+  end
+end

data/lib/archetype.rb

@@ -0,0 +1,93 @@
+ComponentColumn = Struct.new(:components)
+
+class Archetype
+  # @params [Array<Integer>] componentIds
+  def initialize(componentIds)
+    # [Integer(componentId): ComponentColumn]
+    @components = componentIds.map do |compId|
+      [compId, ComponentColumn.new([])]
+    end.to_h
+    @availableEntityRows = []
+    @entities = []
+  end
+
+  # @return [int]
+  def new_arch_row_id(entityId)
+    id = @availableEntityRows.pop
+    if id != nil
+      @entities[id] = entityId
+      return id
+    else
+      id = @entities.size
+      @entities.push entityId
+      return id
+    end
+  end
+
+  def set_component(archRowId, component)
+    compCol = @components[component.class.object_id]
+    if compCol.components.size <= archRowId
+      compCol.components.push component
+    else
+      compCol.components[archRowId] = component
+    end
+  end
+
+  def get_component(archRowId, componentId)
+    return @components[componentId].components[archRowId]
+  end
+
+  def has_component(componentId)
+    return @components[componentId] != nil
+  end
+
+  def remove_entity(archRowId)
+    @availableEntityRows.push(archRowId)
+    @entities[archRowId] = nil
+  end
+
+  # @return [[Component, EntityId]]
+  def active_components(componentIds)
+    # [comp1a, comp1b]
+    # [comp2a, comp2b]
+    # ...
+    components = componentIds
+      .map do |compId|
+        @components[compId].components
+      end
+    compCount = componentIds.size
+
+    @entities
+      .each_with_index
+      .filter do |entId, _|
+        entId != nil
+      end
+      .map do |_, rowIdx|
+        (0...compCount).map do |compRowId|
+          components[compRowId][rowIdx]
+        end
+      end
+  end
+
+  def components_and_ids(componentIds)
+    # [comp1a, comp1b]
+    # [comp2a, comp2b]
+    # ...
+    components = componentIds
+      .map do |compId|
+        @components[compId].components
+      end
+    compCount = componentIds.size
+
+    @entities
+      .each_with_index
+      .filter do |entId, _|
+        entId != nil
+      end
+      .map do |entId, rowIdx|
+        [entId, *(0...compCount).map do |compRowId|
+          components[compRowId][rowIdx]
+        end]
+      end
+  end
+end

data/lib/bitmap.rb

@@ -0,0 +1,32 @@
+# TODO: actual bitmap implementation
+class Bitmap
+  def initialize
+    @flags = []
+  end
+
+  def contains(id)
+    return (@flags.size > id) && @flags[id]
+  end
+
+  def set(id)
+    if @flags.size < id
+      (@flags.size...id).each do |i|
+        @flags.push false
+      end
+    end
+
+    @flags[id] = true
+  end
+  
+  def remove(id)
+    if @flags.size > id
+      @flags[id] = false
+    end
+  end
+
+  def clear
+    (0...@flags.size).each do |i|
+      @flags[i] = false
+    end
+  end
+end

data/lib/entity.rb

@@ -0,0 +1,102 @@
+require 'set'
+require_relative 'bitmap'
+
+Entity = Struct.new(:archId, :archRow)
+
+class EntityStore
+  def initialize
+    # [Entity]
+    @entities = []
+    # [Bitmap]
+    @flags = []
+    @nextId = 0
+    @deadEntities = Set.new
+  end
+
+  # Returns a new entity id (int)
+  def new_id
+    id = @deadEntities.first
+    if id != nil
+      @deadEntities.delete id
+      return id
+    else
+      id = @nextId
+      @nextId += 1
+      return id
+    end
+  end
+
+  # Spawn a new entity with the given ids
+  def spawn(entityId, archId, archRowId)
+    if @entities.count <= entityId
+      @entities.push(Entity.new(archId, archRowId))
+    else
+      @entities[entityId] = Entity.new(archId, archRowId)
+      self.reset_flags(entityId)
+    end
+  end
+
+  # Returns an entity
+  # @param [Integer] entityId
+  def get(entityId)
+    return @entities[entityId]
+  end
+
+  # def exists?(entityId)
+  #   return @entities.size > entityId
+  # end
+
+  # Mark an entity as dead
+  def kill(entityId)
+    @deadEntities.add entityId
+  end
+
+  def entity_count
+    return ((0...@entities.count).reduce(0) do |count, id|
+      if @deadEntities.include? id
+        return count
+      else
+        return count + 1
+      end
+    end)
+  end
+
+  # @param [Integer, #read] entityId
+  # @param [Integer, #read] flagId
+  # @return [bool]
+  def has_flag(entityId, flagId)
+    if @flags.size <= entityId
+      return false
+    else
+      return @flags[entityId].contains(flagId)
+    end
+  end
+
+  def set_flag(entityId, flagId)
+    if @flags.size <= entityId
+      (@flags.size..entityId).each do |_|
+        @flags.push(Bitmap.new)
+      end
+    end
+
+    @flags[entityId].set(flagId)
+  end
+
+  def remove_flag(entityId, flagId)
+    if @flags.size <= entityId
+      return
+    end
+
+    @flags[entityId].remove(flagId)
+  end
+  
+  def reset_flags(entityId)
+    @flags[entityId].clear()
+  end
+
+  def entity_ids
+    return (0...@nextId).filter do |id|
+      !@deadEntities.include?(id)
+    end
+  end
+end

data/lib/kiwi-ecs.rb

@@ -0,0 +1,20 @@
+# Kiwi ecs
+#
+# An easy-to-use ECS implementation focussed on fast iteration of components
+#
+# Copyright (C) 2023  Jonas Everaert
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+require_relative 'world'

data/lib/query.rb

@@ -0,0 +1,56 @@
+module Query
+  # @return [enumerator<Integer>]
+  def query_ids
+    if block_given?
+      @entityStore.entity_ids.each do |id|
+        yield id
+      end
+    else
+      return @entityStore.entity_ids
+    end
+  end
+
+  def query(*componentType)
+    componentIds = componentType.map { |type| type.object_id }
+
+    result = @archStore.compMap
+      .filter do |archComponents, _|
+        (componentIds - archComponents).empty?
+      end
+      .flat_map do |_, archId|
+        @archStore
+          .get(archId)
+          .active_components(componentIds)
+      end
+
+    if block_given?
+      result.each do |a|
+        yield a
+      end
+    else
+      return result.to_enum
+    end
+  end
+
+  def query_with_ids(*componentType)
+    componentIds = componentType.map { |type| type.object_id }
+
+    result = @archStore.compMap
+      .filter do |archComponents, _|
+        (componentIds - archComponents).empty?
+      end
+      .flat_map do |_, archId|
+        @archStore
+          .get(archId)
+          .components_and_ids(componentIds)
+      end
+
+    if block_given?
+      result.each do |a|
+        yield a
+      end
+    else
+      return result.to_enum
+    end
+  end
+end

data/lib/world.rb

@@ -0,0 +1,64 @@
+require_relative 'entity'
+require_relative 'arch_store'
+require_relative 'query'
+
+class World
+  def initialize
+    @entityStore = EntityStore.new
+    @archStore = ArchStore.new
+  end
+
+  def spawn(*components)
+    compIds = components.map { |c| c.class.object_id }.sort
+    archId = @archStore.get_archetype_id(compIds)
+    entId = @entityStore.new_id
+    archetype = @archStore.get(archId)
+    archRowId = archetype.new_arch_row_id(entId)
+    @entityStore.spawn(entId, archId, archRowId)
+    for component in components
+      archetype.set_component(archRowId, component)
+    end
+    return entId
+  end
+
+  def get_component(entityId, componentType)
+    entity = @entityStore.get(entityId)
+    archetype = @archStore.get(entity.archId)
+    archetype.get_component(entity.archRow, componentType.object_id)
+  end
+
+  def kill(entityId)
+    entity = @entityStore.get entityId
+    @entityStore.kill(entityId)
+    archetype = @archStore.get(entity.archId)
+    archetype.remove_entity(entity.archRow)
+  end
+
+  def entity_count
+    return @entityStore.entity_count
+  end
+
+  def has_component(entityId, componentType)
+    entity = @entityStore.get(entityId)
+    archetype = @archStore.get(entity.archId)
+    return archetype.has_component(componentType.object_id)
+  end
+
+  def has_flag(entityId, flagId)
+    return @entityStore.has_flag entityId, flagId
+  end
+
+  def has_flags(entityId, *flagIds)
+    return flagIds.filter { |flagId| !@entityStore.has_flag entityId, flagId }.count == 0
+  end
+
+  def set_flag(entityId, flagId)
+    @entityStore.set_flag(entityId, flagId)
+  end
+
+  def remove_flag(entityId, flagId)
+    @entityStore.remove_flag(entityId, flagId)
+  end
+
+  include Query
+end

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: kiwi-ecs
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Jonas Everaert
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-08-11 00:00:00.000000000 Z
+dependencies: []
+description: |
+  # Kiwi
+
+  Kiwi is a versatile entity component system focussing on fast iteration and a nice api.
+
+  To get started, read the [usage guide](#usage) below.
+
+  [![Tests](https://github.com/Jomy10/kiwi-ecs-ruby/actions/workflows/tests.yml/badge.svg)](https://github.com/Jomy10/kiwi-ecs-ruby/actions/workflows/tests.yml)
+
+  ## Installation
+
+  This library is currently not on ruby gems, but will arrive shortly.
+
+  To use it now, simple `git clone https://github.com/jomy10/kiwi-ecs-ruby`.
+
+  Then incude the world.rb file in your ruby files like so:
+
+  ```ruby
+  require_relative 'kiwi-ecs-ruby/src/world.rb'
+  ```
+
+  ## Usage
+
+  ### The world
+
+  The world is the main object that controls the ecs.
+
+  ```ruby
+  world = World.new
+  ```
+
+  ### Components
+
+  Creating a component is as simple as declaring a struct:
+
+  ```ruby
+  Position = Struct.new :x, :y
+  ```
+
+  Classes can also be used instead of structs
+
+  ```ruby
+  class Velocity
+    attr_accessor :x
+    attr_accessor :y
+  end
+  ```
+
+  ### Entities
+
+  An entity is spawned with a set of components:
+
+  ```ruby
+  entityId = world.spawn(Position.new(10, 10))
+
+  world.spawn(Position.new(3, 5), Velocity.new(1.5, 0.0))
+  ```
+
+  The `world.spawn(*components)` function will return the id of the spawned entity.
+
+  Killing an entity can be done using `world.kill(entityId)`:
+
+  ```ruby
+  world.kill(entityId)
+  ```
+
+  ### Systems
+
+  #### Queries
+
+  Queries can be constructed as follows:
+
+  ```ruby
+  # Query all position componentss
+  world.query(Position) do |pos|
+      puts pos
+  end
+
+  # Query all entities having a position and a velocity component, and their entity ids
+  world.query_with_ids(Position, Velocity) do |id, pos, vel|
+    # ...
+  end
+  ```
+
+  ### Flags
+
+  Entities can be tagged using flags
+
+  #### Defining flags
+
+  A flag is an integer
+
+  ```ruby
+  module Flags
+    Player = 0
+    Enemy = 1
+  end
+  ```
+
+  #### Setting flags
+
+  ```ruby
+  id = world.spawn
+
+  world.set_flag(id, Flags::Player)
+  ```
+
+  #### Removing a flag
+
+  ```ruby
+  world.remove_flag(id, Flags::Player)
+  ```
+
+  #### Checking wether an entity has a flag
+
+  ```ruby
+  world.has_flag(id, Flags::Player)
+  ```
+
+  #### Filtering queries with flags
+
+  ```ruby
+  # TODO
+  ```
+
+  The `hasFlags` function is also available for when you want to check multiple flags.
+
+  ## Road map
+
+  - [ ] System groups
+
+  ## Contributing
+
+  Contributors are welcome to open an issue requesting new features or fixes or opening a pull request for them.
+
+  ## License
+
+  The library is licensed under LGPLv3.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/arch_store.rb
+- lib/archetype.rb
+- lib/bitmap.rb
+- lib/entity.rb
+- lib/kiwi-ecs.rb
+- lib/query.rb
+- lib/world.rb
+homepage: https://github.com/jomy10/kiwi-ecs-ruby
+licenses:
+- LGPL-3.0-or-later
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: An entity component system with a nice api, fit for a variety of use cases
+test_files: []