game_ecs 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ececc23f2d9b4a5f22dd86c23315acc3aec9e1d7
+  data.tar.gz: d1c43248bcf8feed51969521b8b1b0e08917eb86
+SHA512:
+  metadata.gz: 182736984659f36cb814ff787560e0e18f210f7399f8cce7f29a981191ed926fac45487d2caba78f923b9e2c6ec7e54ce16f1e85a3a90987e5587fcb69faa959
+  data.tar.gz: f42a0e425250cc83998c11027b7b6cdc3d28987ac51dc460fe1b7acdded220e4570708a959b744d4877938ebd839cd75c2bc5b182abd27eb62fe28c58452620e

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+Gemfile.lock
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in game_ecs.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Shawn Anderson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,254 @@
+# GameEcs
+
+An easy to use Entity Component System library for use in game development. Learn more about ECS here: 
+* [Evolve Your Heirachy](http://cowboyprogramming.com/2007/01/05/evolve-your-heirachy/)
+* [Wikipedia](https://en.wikipedia.org/wiki/Entity%E2%80%93component%E2%80%93system)
+
+Getting Started
+
+* [Installation](#installation)
+* [Usage](#usage)
+  * [Components](#components)
+  * [Creating Entities](#creating-entities)
+  * [Add/Remove Components](#adding-and-removing-components)
+  * [Finding Entities](#finding-entities)
+  * [Updating Components](#updating-components)
+  * [Advanced Querying](#advanced-querying)
+  * [Big Picture](#big-picture)
+* [Notes](#notes)
+
+### Adding and Removing Components
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'game_ecs'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install game_ecs
+
+## Usage
+
+### Components
+
+Components in GameEcs are ordinary Ruby classes. In most cases, they should be struct-like classes with `attr_accessor` properties only. Adding default values in the constructor is as advanced as these objects should get.
+
+```ruby
+# Example components
+class Position
+  attr_accessor :x, :y
+  def initialize(x:0,y:0)
+    @x = x
+    @y = y
+  end
+end
+
+class Tag
+  attr_accessor :name
+  def initialize(name:)
+    @name = name
+  end
+end
+```
+
+### Creating Entities
+
+An Entity is simply a collection of Components joined together by an id. To create one, simply call the `add_entity` method with a list of the Components you want the Entity to initially have:
+
+```ruby
+# Create and save your store in your higher level Game / State class
+store = GameEcs::EntityStore.new 
+
+# Creating an entity returns its id.
+# In most cases, you will not need to keep this id around.
+ent_id = store.add_entity(Position.new(x:1,y:3), Tag.new(name:"Player"))
+```
+
+I recommend creating an `EntityFactory` or `Prefab` class to store factory methods that know how to build each kind of entity:
+
+```ruby
+class Prefab
+  def self.player_at(store:, x:,y:)
+    store.add_entity(Position.new(x:x,y:y), Tag.new(name:"Player"))
+  end
+
+  def self.tank(*args)
+    # ...
+  end
+
+  # etc
+end
+```
+
+### Adding and Removing Components
+
+The great thing about ECS is the ability to add/remove components at runtime. Here's how to do it:
+
+```ruby
+# add a Color component
+store.add_component(id: ent_id, component: Color.new(red: 255, green: 255, blue: 0))
+
+# we remove by class
+store.remove_component(id: ent_id, klass: Color)
+
+# remove an entire entity
+store.remove_entity(id: ent_id)
+
+# remove many entities
+store.remove_entities(ids: list_of_ids)
+```
+
+### Finding Entities
+
+There are two main ways of finding the entities you want. You can ask for them directly by id or you can search for them by Components.
+
+#### By Id
+Finding by id is nice if you are looking for a single entity. You merely specify the id and the components you want available for modification. If the id does not exist or the entity does not have one of the specified components, `nil` is returned.
+
+```ruby
+ent = store.find_by_id(ent_id, Position, Color)
+id = ent.id
+pos, color = ent.components
+```
+
+#### Querying by Components
+
+GameEcs has a `Query` class that can be used for more advanced queries, but the most common case is that you want all enitities that have all the components you're interested in. `musts` is short had for building these types of queries:
+
+```ruby
+ents_that_need_move = store.musts(Position, Velocity)
+ents_that_need_move.each do |ent|
+  pos,vel = ent.components
+  # modify pos based on vel
+end
+```
+
+This pattern of find the ents and loop over them is so common there is a helper that does just that called `each_entity`:
+
+```ruby
+store.each_entity(Position, Velocity) do |ent|
+  pos,vel = ent.components
+  # modify pos based on vel
+end
+```
+
+### Updating Components
+
+Once you've got hold of an "entity" from the store. You can access the components you queried for via the `components` method on the entity. Once you have it, you can directly modify its values.
+
+```ruby
+store.each_entity(Position, Velocity) do |ent|
+  pos,vel = ent.components
+  pos.x += vel.x * time_scale
+  pos.y += vel.y * time_scale
+end
+```
+
+### Advanced Querying
+
+`each_entity` and `musts` are really shorthand for creating `GameEcs::Query` objects and passing it to the `query` method. Let's look at the longhand version; the following two lines are synonymous:
+
+```ruby
+ents = store.query(Query.must(Position).must(Color))
+ents = store.musts(Position, Color)
+```
+
+By using the `Query` directly, we can add in `maybe` cases. A Maybe will still match if the entity does not have the desired component, but will return nil for that component.
+
+
+```ruby
+store.query(Query.must(Position).maybe(Color)).each do |ent|
+  # color may be nil
+  pos,color = ent.components
+end
+```
+
+#### Experimental!
+We can also query based on components' values using `with`:
+
+```ruby
+# Only entities with a Position component with x val == 12 will be returned
+store.query(Query.must(Position).with(x: 12).must(Color)).each do |ent|
+  pos,color = ent.components
+end
+```
+
+We can also use lambdas to determine if a value matches:
+```ruby
+# Only entities with a Position less than 12 will be returned
+store.query(Query.must(Position).with(x: ->(x){ x < 12 }).must(Color)).each do |ent|
+  pos,color = ent.components
+end
+```
+
+*_!! DANGER !!_*
+
+Currently the caching mechanism in GameEcs does not know if the value of a component has changed since it was cached. Only use this for component values that do not change often, or clear your cache to get the results to update. The rough plan here is to eventually change components to be more of a DSL and have them notify the store on value changes of interest (If any queries care about the change)
+
+### Big Picture
+
+`EntityStore` is meant to be constructed and passed into a list of processing systems. This gem is entirely agnostic to how you implement your Game and Systems. A quick example _could_ look like:
+
+```ruby
+class Game
+  def intialize
+    @store = GameEcs::EntityStore.new
+    @render_system = RenderSystem.new(@store)
+    @systems = [
+      MovementSystem.new(@store),
+      # .. other systems
+      @render_system
+    ]
+  end
+
+  def update(time_delta, inputs)
+    @systems.each{|sys| sys.update(time_delta, inputs) }
+  end
+
+  def draw
+    @render_system.render
+  end
+end
+
+class MovementSystem
+  def initialize(store)
+    @store = store
+  end
+
+  def update(dt, inputs)
+    @store.each_entity(Position, Velocity) do |ent|
+      pos,vel = ent.components
+      pos.x += vel.x * dt
+      pos.y += vel.y * dt
+    end
+  end
+end
+
+
+```
+For a more fully fleshed out game using ECS in this way, checkout [Pixel Monster](https://github.com/shawn42/pixel_monster)
+
+
+### Notes
+
+* entities can only have one instance of each component type
+* adding/removing entities and components is delayed until all iterating code has finished (calls to `each_entity`).
+* all queries are cached by default calling `clear_cache!` will reset the cache
+* to dump all entities and components from the store, use `clear!`
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/shawn42/game_ecs.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/contrib/sample_systems_components.rb

@@ -0,0 +1,56 @@
+# TODO docs here
+class TimerSystem
+  def update(store, inputs)
+    current_time_ms = inputs[:total_time]
+    store.each_entity Timer do |rec|
+      timer = rec.get(Timer)
+      ent_id = rec.id
+
+      if timer.expires_at
+        if timer.expires_at < current_time_ms
+          if timer.event
+            event_comp = timer.event.is_a?(Class) ? timer.event.new : timer.event
+            store.add_component component: event_comp, id: ent_id
+          end
+          if timer.repeat
+            timer.expires_at = current_time_ms + timer.total
+          else
+            store.remove_component(klass: timer.class, id: ent_id)
+          end
+        end
+      else
+        timer.expires_at = current_time_ms + timer.total
+      end
+    end
+  end
+end
+class Timer
+  attr_accessor :ttl, :repeat, :total, :event, :name, :expires_at
+  def initialize(name, ttl, repeat, event = nil)
+    @name = name
+    @total = ttl
+    @ttl = ttl
+    @repeat = repeat
+    @event = event
+  end
+end
+
+class SoundSystem
+  def preload(asset)
+    @assets ||= {}
+    @assets[asset] = Gosu::Sample.new(asset)
+  end
+  def update(store, inputs)
+    store.each_entity SoundEffectEvent do |rec|
+      ent_id = rec.id
+      effect = rec.get(SoundEffectEvent)
+      store.remove_component klass: effect.class, id: ent_id
+      if @assets[effect.sound_to_play]
+        @assets[effect.sound_to_play].play
+      else
+        puts "Warning:  #{effect.sound_to_play} is missing!"
+      end
+    end
+  end
+end
+SoundEffectEvent = Struct.new :sound_to_play

data/contrib/simple_system.rb

@@ -0,0 +1,53 @@
+module GameEcs
+  class SimpleSystem
+    def self.from_query(query, &block)
+      new(query, &block)
+    end
+    
+    def initialize(query=Query.none, &block)
+      @query = query
+      @system_block = block
+    end
+
+    def update(entity_store, *args)
+      before_update(entity_store, *args)
+      entity_store.query.each do |ent|
+        each(ent, *args)
+      end
+      after_update(entity_store, *args)
+    end
+
+    def before_update(entity_store, *args)
+    end
+    def after_update(entity_store, *args)
+    end
+    def update_each(entity_store, ent, *args)
+      # handle a single update of an ent
+      @system_block.call(entity_store, ent, *args)
+    end
+  end
+
+end
+
+if $0 == __FILE__
+include GameEcs
+  MovementSystem = SimpleSystem.from_query( Q.musts(Position, Velocity) ) do |store, ent, dt, input|
+    pos,vel = ent.components
+    pos.x += vel.x * dt
+    pos.y += vel.y * dt
+  end
+
+  # long hand via subclassing, allows for before/after overrides
+  class MovementSystem < SimpleSystem
+    def after_update(store, *args)
+      log "MovementSystem finished: #{Time.now}"
+    end
+    def update_each(store, ent, dt, input)
+      Q.each_entity(Position, Velocity) do
+        pos,vel = ent.components
+        pos.x += vel.x * dt
+        pos.y += vel.y * dt
+      end
+    end
+  end
+end

data/examples/coin_getter_game.rb

@@ -0,0 +1,215 @@
+$: << '../lib'
+$: << '../contrib'
+require_relative '../lib/game_ecs'
+require_relative '../contrib/sample_systems_components'
+
+require 'gosu'
+include Gosu
+Q = GameEcs::Query
+
+class CoinGetterGame < Window
+  def initialize
+    super(800,600)
+    @entity_store = GameEcs::EntityStore.new
+    @render_system = RenderSystem.new
+    @sound_system = SoundSystem.new
+    @sound_system.preload('coin.wav')
+    @downs = []
+
+    @systems = [
+      ControlSystem.new,
+      MotionSystem.new,
+      TimerSystem.new,
+      CoinSystem.new,
+      @sound_system,
+      @render_system
+    ]
+
+    Prefab.player(@entity_store, 400, 300)
+    10.times do
+      Prefab.coin(@entity_store, rand(50..750), rand(50..550))
+    end
+    Prefab.coin_gen_timer(@entity_store)
+  end
+
+  def button_down(id)
+    close if id == KbEscape
+    @downs << id
+  end
+  def button_up(id)
+    @downs.delete id
+  end
+
+  def update
+    @systems.each do |sys|
+      sys.update(@entity_store, {dt: relative_delta, down_ids: @downs, total_time: Gosu::milliseconds})
+    end
+    self.caption = "FPS: #{Gosu.fps}"
+  end
+
+  def draw
+    @render_system.draw(@entity_store, self)
+  end
+
+
+  private
+
+  MAX_UPDATE_SIZE_IN_MILLIS = 500
+  def relative_delta
+    total_millis = Gosu::milliseconds.to_f
+    @last_millis ||= total_millis
+    delta = total_millis
+    delta -= @last_millis if total_millis > @last_millis
+    @last_millis = total_millis
+    delta = MAX_UPDATE_SIZE_IN_MILLIS if delta > MAX_UPDATE_SIZE_IN_MILLIS
+    delta
+  end
+end
+
+class Prefab
+  def self.coin(store, x, y)
+    store.add_entity(Position.new(x,y,1), Velocity.new(0.5-rand,0.5-rand), Color.new(:green), Size.new(10), Tag.new("coin") )
+  end
+
+  def self.player(store, x, y)
+    store.add_entity(Position.new(400,40,3), Tag.new("p1"), Score.new(0))
+    store.add_entity(Position.new(x,y,2), Velocity.new(0,0), Color.new(:red), Tag.new("p1"), Input.new, Size.new(20))
+  end
+
+  def self.coin_gen_timer(store)
+    store.add_entity(Timer.new(:coin_gen, 2000, true, GenerateNewCoinEvent))
+  end
+end
+
+
+# Systems
+class ControlSystem
+  def update(store, inputs)
+    downs = inputs[:down_ids]
+    player_one = store.query(Q.must(Input).must(Tag).with(name: "p1")).first.get(Input)
+    player_one.left = downs.include?(KbLeft) || downs.include?(GpLeft)
+    player_one.right = downs.include?(KbRight) || downs.include?(GpRight)
+    player_one.up = downs.include?(KbUp) || downs.include?(GpUp)
+    player_one.down = downs.include?(KbDown) || downs.include?(GpDown)
+  end
+end
+class MotionSystem
+  MAX_VELOCITY = 2
+  ACCEL = 0.03
+  FRICTION = 0.96
+  def update(store, inputs)
+    time_scale = inputs[:dt] * 0.01
+    store.each_entity(Input, Velocity) do |ent|
+      input, vel = ent.components
+      vel.dx += ACCEL*time_scale if input.right
+      vel.dx -= ACCEL*time_scale if input.left
+      vel.dy += ACCEL*time_scale if input.down
+      vel.dy -= ACCEL*time_scale if input.up
+
+      vel.dx *= FRICTION
+      vel.dy *= FRICTION
+
+      mag = vec_mag(vel.dx, vel.dy) 
+      if mag > MAX_VELOCITY 
+        vel.dx, vel.dy = vec_clip_to_mag(vel.dx, vel.dy, MAX_VELOCITY)
+      end
+    end
+
+    store.each_entity(Position, Velocity) do |ent|
+      pos,vel = ent.components
+      pos.x += vel.dx*time_scale
+      pos.y += vel.dy*time_scale
+      pos.x %= 800
+      pos.y %= 600
+    end
+  end
+  def vec_mag(x,y)
+    Math.sqrt(x*x + y*y)
+  end
+  def vec_clip_to_mag(x,y,max_mag)
+    mag = vec_mag(x,y)
+    [x.to_f/mag*max_mag, y.to_f/mag*max_mag]
+  end
+end
+
+class RenderSystem
+  def initialize
+    @colors = {
+      red: Gosu::Color::RED,
+      green: Gosu::Color::GREEN
+    }
+    @font = Gosu::Font.new(40)
+  end
+  def update(store,inputs); end
+  def draw(store, target)
+    store.each_entity(Position, Score) do |ent|
+      pos, score = ent.components
+      @font.draw("#{score.points}", pos.x, pos.y, pos.z, 1.0, 1.0, Gosu::Color::WHITE)
+    end
+    store.each_entity(Position, Color, Size) do |ent|
+      pos, col, size = ent.components
+      w = size.width
+      c1 = c2 = c3 = c4 = @colors[col.name]
+      x1 = pos.x
+      x2 = pos.x + w
+      x3 = x2
+      x4 = x1
+
+      y1 = pos.y
+      y2 = y1
+      y3 = pos.y + w
+      y4 = y3
+
+      target.draw_quad(x1, y1, c1, x2, y2, c2, x3, y3, c3, x4, y4, c4, pos.z)
+    end
+  end
+end
+
+class CoinSystem
+  def update(store, inputs)
+    p1_score = store.query(Q.must(Score).must(Tag).with(name: "p1")).first
+    p1_score, _ = p1_score.components
+    p1 = store.query(Q.must(Position).must(Size).must(Tag).with(name: "p1")).first
+    p1_pos, p1_size, _ = p1.components
+
+    store.query(Q.must(Position).must(Size).must(Tag).with(name:"coin")).each do |coin|
+      coin_pos, coin_size, _ = coin.components
+      if (coin_pos.x >= p1_pos.x &&
+        coin_pos.x <= p1_pos.x + p1_size.width) ||
+        (coin_pos.x + coin_size.width >= p1_pos.x &&
+        coin_pos.x + coin_size.width <= p1_pos.x + p1_size.width)
+
+        if (coin_pos.y >= p1_pos.y &&
+          coin_pos.y <= p1_pos.y + p1_size.width) ||
+          (coin_pos.y + coin_size.width >= p1_pos.y &&
+          coin_pos.y + coin_size.width <= p1_pos.y + p1_size.width)
+
+          store.remove_entity(id: coin.id)
+          p1_score.points += 1
+          store.add_entity SoundEffectEvent.new('coin.wav')
+        end
+      end
+    end
+    store.each_entity(GenerateNewCoinEvent) do |ent|
+      Prefab.coin(store, rand(50..750), rand(50..550))
+      store.remove_component(klass: GenerateNewCoinEvent, id: ent.id)
+    end
+  end
+end
+
+# Components
+class Input
+  attr_accessor :left, :right, :up, :down
+end
+GenerateNewCoinEvent = Class.new
+Tag = Struct.new :name
+Position = Struct.new :x, :y, :z
+Size = Struct.new :width
+Velocity = Struct.new :dx, :dy
+Color = Struct.new :name
+Score = Struct.new :points
+
+if $0 == __FILE__
+  game = CoinGetterGame.new
+  game.show
+end

data/game_ecs.gemspec

@@ -0,0 +1,28 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "game_ecs/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "game_ecs"
+  spec.version       = GameEcs::VERSION
+  spec.authors       = ["Shawn Anderson"]
+  spec.email         = ["shawn42@gmail.com"]
+
+  spec.summary       = %q{Entity Component System architecture in Ruby}
+  spec.description   = %q{Entity Component System architecture in Ruby}
+  spec.homepage      = "https://github.com/shawn42/game_ecs"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry", "~> 0.12.0"
+end

data/lib/game_ecs.rb

@@ -0,0 +1,5 @@
+require_relative "./game_ecs/version"
+require_relative "./game_ecs/entity_store"
+
+module GameEcs
+end

data/lib/game_ecs/entity_store.rb

@@ -0,0 +1,469 @@
+require 'forwardable'
+require 'set'
+
+module GameEcs
+  class EntityStore
+    attr_reader :entity_count, :id_to_comp
+    def initialize
+      clear!
+    end
+
+    def deep_clone
+      # NOTE! does not work for Hashes with default procs
+      if _iterating?
+        raise "AHH! EM is still iterating!!" 
+      else
+        _apply_updates
+        clear_cache!
+        em = Marshal.load( Marshal.dump(self) )
+        em
+      end
+    end
+
+    def num_entities
+      @id_to_comp.keys.size
+    end
+
+    def clear!
+      @comp_to_id = {}
+      @id_to_comp = {}
+      @cache = {}
+      @entity_count = 0
+
+      @iterator_count = 0
+      @ents_to_add_later = []
+      @comps_to_add_later = []
+      @comps_to_remove_later = []
+      @ents_to_remove_later = []
+      clear_cache!
+    end
+
+    def clear_cache!
+      @cache = {}
+    end
+
+    def find_by_id(id, *klasses)
+      return nil unless @id_to_comp.key? id
+      ent_record = @id_to_comp[id]
+      components = ent_record.values_at(*klasses)
+      rec = build_record(id, @id_to_comp[id], klasses) unless components.any?(&:nil?)
+      if block_given?
+        yield rec
+      else
+        rec
+      end
+    end
+
+    def musts(*klasses)
+      raise "specify at least one component" if klasses.empty?
+      q = Q
+      klasses.each{|k| q = q.must(k)}
+      query(q)
+    end
+    alias find musts
+
+    def query(q)
+      # TODO cache results as q with content based cache
+      #   invalidate cache based on queried_comps
+      cache_hit = @cache[q]
+      return cache_hit if cache_hit
+
+      queried_comps = q.components
+      required_comps = q.required_components
+
+      required_comps.each do |k|
+        @comp_to_id[k] ||= Set.new
+      end
+
+      intersecting_ids = []
+      unless required_comps.empty?
+        id_collection = @comp_to_id.values_at(*required_comps)
+        intersecting_ids = id_collection.sort_by(&:size).inject &:&
+      end
+
+      recs = intersecting_ids.
+        select{|eid| q.matches?(eid, @id_to_comp[eid]) }.
+        map do |eid|
+          build_record eid, @id_to_comp[eid], queried_comps
+        end
+      result = QueryResultSet.new(records: recs, ids: recs.map(&:id))
+
+      @cache[q] = result if q.cacheable?
+      result
+    end
+
+    def first(*klasses)
+      find(*klasses).first
+    end
+
+    def each_entity(*klasses, &blk)
+      ents = find(*klasses)
+      if block_given?
+        _iterating do
+          ents.each &blk
+        end
+      end
+      ents
+    end
+
+    def remove_component(klass:, id:)
+      if _iterating?
+        _remove_component_later klass: klass, id: id
+      else
+        _remove_component klass: klass, id: id
+      end
+    end
+
+    def add_component(component:,id:)
+      if _iterating?
+        _add_component_later component: component, id: id
+      else
+        _add_component component: component, id: id
+      end
+    end
+
+    def remove_entites(ids:)
+      if _iterating?
+        _remove_entities_later(ids: ids)
+      else
+        _remove_entites(ids: ids)
+      end
+    end
+
+    def remove_entity(id:)
+      if _iterating?
+        _remove_entity_later(id: id)
+      else
+        _remove_entity(id: id)
+      end
+    end
+
+    def add_entity(*components)
+      id = generate_id
+      if _iterating?
+        _add_entity_later(id:id, components: components)
+      else
+        _add_entity(id: id, components: components)
+      end
+      id
+    end
+
+    private
+    def _add_entity_later(id:,components:)
+      @ents_to_add_later << {components: components, id: id}
+    end
+    def _remove_entities_later(ids:)
+      ids.each do |id|
+        @ents_to_remove_later << id
+      end
+    end
+    def _remove_entity_later(id:)
+      @ents_to_remove_later << id
+    end
+
+    def _remove_component_later(klass:,id:)
+      @comps_to_remove_later << {klass: klass, id: id}
+    end
+    def _add_component_later(component:,id:)
+      @comps_to_add_later << {component: component, id: id}
+    end
+
+    def _apply_updates
+      _remove_entites ids: @ents_to_remove_later
+      @ents_to_remove_later.clear
+
+      @comps_to_remove_later.each do |opts|
+        _remove_component klass: opts[:klass], id: opts[:id]
+      end
+      @comps_to_remove_later.clear
+
+      @comps_to_add_later.each do |opts|
+        _add_component component: opts[:component], id: opts[:id]
+      end
+      @comps_to_add_later.clear
+
+      @ents_to_add_later.each do |opts|
+        _add_entity id: opts[:id], components: opts[:components]
+      end
+      @ents_to_add_later.clear
+    end
+
+    def _iterating
+      @iterator_count += 1
+      yield
+      @iterator_count -= 1
+      _apply_updates unless _iterating?
+    end
+
+    def _iterating?
+      @iterator_count > 0
+    end
+
+    def _add_component(component:,id:)
+      raise "Cannot add nil component" if component.nil?
+
+      @comp_to_id[component.class] ||= Set.new
+      @comp_to_id[component.class] << id
+      @id_to_comp[id] ||= {}
+      ent_record = @id_to_comp[id]
+      klass = component.class
+
+      raise "Cannot add component twice! #{component} -> #{id}" if ent_record.has_key? klass
+      ent_record[klass] = component
+
+      @cache.each do |q, results|
+        # TODO make results a smart result set that knows about ids to avoid the linear scan
+        # will musts vs maybes help here?
+        comp_klasses = q.components
+        if comp_klasses.include?(klass)
+          if results.has_id?(id)
+            results.add_component(id: id, component: component)
+          else
+            results << build_record(id, ent_record, comp_klasses) if q.matches?(id, ent_record)
+          end
+        end
+      end
+      nil
+    end
+
+    def _remove_component(klass:, id:)
+      @comp_to_id[klass] ||= Set.new
+      @comp_to_id[klass].delete id
+      @id_to_comp[id] ||= {}
+      @id_to_comp[id].delete klass
+
+      @cache.each do |q, results|
+        comp_klasses = q.components
+        if comp_klasses.include?(klass)
+          results.delete(id: id) unless q.matches?(id, @id_to_comp[id])
+        end
+      end
+      nil
+    end
+
+    def _remove_entites(ids:)
+      return if ids.empty?
+
+      ids.each do |id|
+        @id_to_comp.delete(id)
+      end
+
+      @comp_to_id.each do |_klass, ents|
+        ents.delete_if{|ent_id| ids.include? ent_id}
+      end
+
+      @cache.each do |comp_klasses, results|
+        results.delete ids: ids
+      end
+    end
+
+    def _remove_entity(id:)
+      comp_map = @id_to_comp[id]
+      if @id_to_comp.delete(id)
+        ent_comps = comp_map.keys
+        ent_comps.each do |klass|
+          @comp_to_id[klass].delete id
+        end
+        @cache.each do |_query, results|
+            results.delete id: id
+        end
+      end
+    end
+
+    def _add_entity(id:, components:)
+      components.each do |comp|
+        _add_component component: comp, id: id
+      end
+      id
+    end
+
+    def generate_id
+      @entity_count += 1
+      @ent_counter ||= 0
+      @ent_counter += 1
+    end
+
+    def build_record(*args)
+      EntityQueryResult.new(*args)
+    end 
+
+    class QueryResultSet
+      def initialize(records:, ids:)
+        @records = records
+        @ids = Set.new(ids)
+      end
+      def <<(rec)
+        @ids << rec.id
+        @records << rec
+      end
+      def has_id?(id)
+        @ids.include? id
+      end
+      def add_component(id:, component:)
+        index = @records.index{ |rec| id == rec&.id }
+        @records[index].update_component(component) if index >= 0
+      end
+      def delete(id:nil, ids:nil)
+        if id
+          @records.delete_at(@records.index{ |rec| id == rec&.id } || @records.size) if @ids.include? id
+          @ids.delete id
+        else
+          unless (@ids & ids).empty?
+          # ids.each do |id|
+          #   @ids.delete id
+          # end
+            @ids = @ids - ids
+            @records.delete_if{|res| ids.include? res.id}
+          end
+        end
+      end
+      def each
+        @records.each do |rec|
+          yield rec
+        end
+      end
+      extend ::Forwardable
+      def_delegators :@records, :first, :any?, :size, :select, :find, :empty?, :first, :map, :[]
+
+    end
+
+    class EntityQueryResult
+      attr_reader :id
+      def initialize(id, components, queried_components)
+        @id = id
+        @components = components
+        @queried_components = queried_components
+      end
+
+      def get(klass)
+        @components[klass]
+      end
+
+      def update_component(component)
+        @components[component.class] = component
+        @comp_cache = comp_cache
+      end
+
+      def components
+        @comp_cache ||= comp_cache
+      end
+
+      private
+      def comp_cache
+        @queried_components.map{|qc| @components[qc]}
+      end
+    end
+  end
+
+  class Condition
+    attr_reader :k, :attr_conditions
+    def initialize(k)
+      @attr_conditions = {}
+      @k = k
+    end
+
+    def ==(other)
+      @k == other.k &&
+        @attr_conditions.size == other.attr_conditions.size &&
+        @attr_conditions.all?{|ac,v| other.attr_conditions[ac] == v}
+    end
+    alias eql? ==
+    def hash
+      @_hash ||= @k.hash ^ @attr_conditions.hash
+    end
+
+    def components
+      @k
+    end
+
+    def attrs_match?(id, comps)
+      comp = comps[@k]
+      @attr_conditions.all? do |name, cond|
+        val = comp.send(name) 
+        if cond.respond_to? :call
+          cond.call val
+        else
+          val == cond
+        end
+      end
+    end
+
+    def merge_conditions(attrs)
+      @attr_conditions ||= {}
+      @attr_conditions.merge! attrs
+    end
+  end
+
+  class Must < Condition
+    def matches?(id, comps)
+      comps.keys.include?(@k) && attrs_match?(id, comps)
+    end
+  end
+
+  class Maybe < Condition
+    def matches?(id, comps)
+      attrs_match?(id, comps)
+    end
+
+  end
+
+  class Query
+    attr_reader :components, :musts, :maybes
+    def self.none
+      Query.new
+    end
+    def self.must(*args)
+      Query.new.must(*args)
+    end
+    def self.maybe(*args)
+      Query.new.maybe(*args)
+    end
+
+    def initialize
+      @components = []
+      @musts = []
+    end
+
+    def must(k)
+      @last_condition = Must.new(k)
+      @musts << @last_condition
+      @components << k
+      self
+    end
+
+    def required_components
+      @musts.flat_map(&:components).uniq
+    end
+
+    def with(attr_map)
+      @last_condition.merge_conditions(attr_map)
+      self
+    end
+
+    def maybe(k)
+      @maybes ||= []
+      @last_condition = Maybe.new(k)
+      @maybes << @last_condition
+      @components << k
+      self
+    end
+
+    def matches?(eid, comps)
+      @musts.all?{|m| m.matches?(eid, comps)} # ignore maybes  ;)
+    end
+
+    def ==(other)
+      self.musts == other.musts && self.maybes == other.maybes
+    end
+
+    def cacheable?
+      @cacheable ||= @musts.all?{|m| m.attr_conditions.values.all?{|ac| !ac.respond_to?(:call) } }
+    end
+
+    alias eql? ==
+    def hash
+      @_hash ||= self.musts.hash ^ self.maybes.hash
+    end
+  end
+  Q = Query
+end

data/lib/game_ecs/version.rb

@@ -0,0 +1,3 @@
+module GameEcs
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: game_ecs
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shawn Anderson
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-02-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+description: Entity Component System architecture in Ruby
+email:
+- shawn42@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- contrib/sample_systems_components.rb
+- contrib/simple_system.rb
+- examples/coin.wav
+- examples/coin_getter_game.rb
+- game_ecs.gemspec
+- lib/game_ecs.rb
+- lib/game_ecs/entity_store.rb
+- lib/game_ecs/version.rb
+homepage: https://github.com/shawn42/game_ecs
+licenses:
+- MIT
+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: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Entity Component System architecture in Ruby
+test_files: []