kiwi-ecs 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b17b772e56b3533bac84c71c609eb8544908667c4cac99725327399d1fd44fed
-  data.tar.gz: d8669b034e3db56f038919b60aa8f7f2b36eb6b98e7f12d22f533ac2c2680454
+  metadata.gz: 3c28c74f941f35abc3fe5ae1d565f8942f7676b01341e4c3efeef7969dcb1512
+  data.tar.gz: 6ac603e29b87be9c27da787dc330291f8c6bc8ce28e8807e4b8d36294609638e
 SHA512:
-  metadata.gz: f5e2f0b3770ffe2eeebd64f590aec863fc8074f4ec1331578f1a7f5ee42ac69e8ca257c3cf9717f8e7b43c876dbe80f946e9e74045e0a4efa9feaeb78b8b05c7
-  data.tar.gz: a42b7f00ee919b7cd1d37f70c0a19f1b217d429f604f67e0a99734c4de4336d7bcecea9235e244fb884c93288f06df38c9b9e4a453520e7ce86809c92ad5a6e0
+  metadata.gz: db0833836918141ec6f231b943c9c2fb6455e232c6d451cb46b80ff949eb245a164d037dfd984054af69019bf717ebe380734c6a74a1493db429623ed22825d1
+  data.tar.gz: a1d9e6d195d65505ea25f21f5cc98224c4bf4729adaca7fb4a0fa9725a74e3748956853d7fda3e22d6108eab4d98651a612a10b847784f8bee3c99f47f3bd7b3

data/README.md

@@ -0,0 +1,145 @@
+# 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
+
+The library is available from [ruby gems](https://rubygems.org/gems/kiwi-ecs):
+
+```sh
+gem install kiwi-ecs
+```
+
+To use it in your ruby source files:
+
+```ruby
+require 'kiwi-ecs'
+```
+
+## Usage
+
+### The world
+
+The world is the main object that controls the ecs.
+
+```ruby
+world = Kiwi::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
+world.query_with_ids(Pos)
+  .filter do |id, pos|
+    world.has_flag(id, Flags::Player)
+  end
+  .each do |id, pos|
+    # Do something with the filtered query
+  end
+```
+
+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.

data/lib/arch_store.rb

@@ -1,5 +1,9 @@
 require_relative 'archetype'
 
+module Kiwi
+# Internal methods not meant for outside use
+module Internal
+
 class ArchStore
   # [[Integer]:Integer]
   attr_accessor :compMap
@@ -28,3 +32,6 @@ class ArchStore
     end
   end
 end
+
+end
+end

data/lib/archetype.rb

@@ -1,93 +1,97 @@
 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
+module Kiwi
+  module Internal
+    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
 
-  def remove_entity(archRowId)
-    @availableEntityRows.push(archRowId)
-    @entities[archRowId] = nil
-  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
 
-  # @return [[Component, EntityId]]
-  def active_components(componentIds)
-    # [comp1a, comp1b]
-    # [comp2a, comp2b]
-    # ...
-    components = componentIds
-      .map do |compId|
-        @components[compId].components
+      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
-    compCount = componentIds.size
 
-    @entities
-      .each_with_index
-      .filter do |entId, _|
-        entId != nil
+      def get_component(archRowId, componentId)
+        return @components[componentId].components[archRowId]
       end
-      .map do |_, rowIdx|
-        (0...compCount).map do |compRowId|
-          components[compRowId][rowIdx]
-        end
+
+      def has_component(componentId)
+        return @components[componentId] != nil
       end
-  end
 
-  def components_and_ids(componentIds)
-    # [comp1a, comp1b]
-    # [comp2a, comp2b]
-    # ...
-    components = componentIds
-      .map do |compId|
-        @components[compId].components
+      def remove_entity(archRowId)
+        @availableEntityRows.push(archRowId)
+        @entities[archRowId] = nil
       end
-    compCount = componentIds.size
 
-    @entities
-      .each_with_index
-      .filter do |entId, _|
-        entId != nil
+      # @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
-      .map do |entId, rowIdx|
-        [entId, *(0...compCount).map do |compRowId|
-          components[compRowId][rowIdx]
-        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
   end
 end

data/lib/bitmap.rb

@@ -1,3 +1,6 @@
+module Kiwi
+module Internal
+
 # TODO: actual bitmap implementation
 class Bitmap
   def initialize
@@ -30,3 +33,6 @@ class Bitmap
     end
   end
 end
+
+end
+end

data/lib/entity.rb

@@ -1,6 +1,9 @@
 require 'set'
 require_relative 'bitmap'
 
+module Kiwi
+module Internal
+
 Entity = Struct.new(:archId, :archRow)
 
 class EntityStore
@@ -100,3 +103,6 @@ class EntityStore
     end
   end
 end
+
+end
+end

data/lib/query.rb

@@ -1,3 +1,5 @@
+module Kiwi
+module Internal
 module Query
   # @return [enumerator<Integer>]
   def query_ids
@@ -54,3 +56,5 @@ module Query
     end
   end
 end
+end
+end

data/lib/world.rb

@@ -2,63 +2,65 @@ require_relative 'entity'
 require_relative 'arch_store'
 require_relative 'query'
 
-class World
-  def initialize
-    @entityStore = EntityStore.new
-    @archStore = ArchStore.new
-  end
+module Kiwi
+  class World
+    def initialize
+      @entityStore = Kiwi::Internal::EntityStore.new
+      @archStore = Kiwi::Internal::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)
+    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
-    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 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 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 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_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_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 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 set_flag(entityId, flagId)
+      @entityStore.set_flag(entityId, flagId)
+    end
 
-  def remove_flag(entityId, flagId)
-    @entityStore.remove_flag(entityId, flagId)
-  end
+    def remove_flag(entityId, flagId)
+      @entityStore.remove_flag(entityId, flagId)
+    end
 
-  include Query
+    include Kiwi::Internal::Query
+  end
 end

metadata

@@ -1,158 +1,25 @@
 --- !ruby/object:Gem::Specification
 name: kiwi-ecs
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Jonas Everaert
-autorequire:
+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:
+description: |-
+  == Description
+    Kiwi is a versatile entity component system that is focussed on fast iteration and a nice api
+email: 
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.md
 files:
+- README.md
 - lib/arch_store.rb
 - lib/archetype.rb
 - lib/bitmap.rb
@@ -164,7 +31,7 @@ homepage: https://github.com/jomy10/kiwi-ecs-ruby
 licenses:
 - LGPL-3.0-or-later
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -179,8 +46,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
-signing_key:
+rubygems_version: 3.3.26
+signing_key: 
 specification_version: 4
 summary: An entity component system with a nice api, fit for a variety of use cases
 test_files: []