chione 0.3.0 → 0.4.0

data/spec/chione/archetype_spec.rb

@@ -3,6 +3,7 @@
 require_relative '../spec_helper'
 
 require 'chione/archetype'
+require 'chione/aspect'
 require 'chione/component'
 require 'chione/entity'
 require 'chione/world'
@@ -57,6 +58,19 @@ describe Chione::Archetype do
 	end
 
 
+	it "can be constructed from the Components specified in an Aspect" do
+		aspect = Chione::Aspect.with_all_of( location_component, tags_component )
+		archetype = described_class.from_aspect( aspect )
+
+		expect( archetype ).to be_a( Module )
+		expect( archetype.from_aspect ).to eq( aspect )
+
+		entity = archetype.construct_for( world )
+
+		expect( aspect ).to match( entity )
+	end
+
+
 	it "is still loadable as an `Assemblage`" do
 		expect {
 			expect( Chione::Assemblage ).to equal( described_class )

data/spec/chione/aspect_spec.rb

@@ -4,20 +4,28 @@ require_relative '../spec_helper'
 
 require 'chione/aspect'
 require 'chione/component'
+require 'chione/fixtures'
 
 
 describe Chione::Aspect do
 
+	before( :all ) do
+		Chione::Fixtures.load( :entities )
+	end
+
+
 	let( :location ) do
 		Class.new( Chione::Component ) do
 			field :x, default: 0
 			field :y, default: 0
+			def self::name; "Location"; end
 		end
 	end
 
 	let( :tags ) do
 		Class.new( Chione::Component ) do
 			field :tags, default: []
+			def self::name; "Tags"; end
 		end
 	end
 
@@ -27,9 +35,29 @@ describe Chione::Aspect do
 			field :shade, default: 0
 			field :value, default: 0
 			field :opacity, default: 0
+			def self::name; "Color"; end
 		end
 	end
 
+	let( :world ) { Chione::World.new }
+
+	let( :entity ) { Chione::Fixtures.entity(world) }
+	let( :entity1 ) do
+		entity.with_components( location ).instance
+	end
+	let( :entity2 ) do
+		entity.with_components( location, color ).instance
+	end
+	let( :entity3 ) do
+		entity.with_components( location, color, tags ).instance
+	end
+	let( :entity4 ) do
+		entity.with_components( color, tags ).instance
+	end
+	let( :entity5 ) do
+		entity.with_components( tags ).instance
+	end
+
 
 	it "doesn't have any default criteria" do
 		aspect = described_class.new
@@ -139,5 +167,67 @@ describe Chione::Aspect do
 		expect( aspect.none_of ).to include( tags, location )
 	end
 
+
+	it "can be inverted"
+
+
+	describe "entity-matching" do
+
+		let( :all_entities ) {[ entity1, entity2, entity3, entity4, entity5 ]}
+
+
+		it "can find the matching subset of values given a Hash keyed by Components" do
+			entities = all_entities()
+
+			aspect = described_class.with_all_of( color, location ).and_none_of( tags )
+			result = aspect.matching_entities( world.entities_by_component )
+
+			expect( result ).to contain_exactly( entity2.id )
+		end
+
+
+		it "always matches an individual entity if it's empty" do
+			aspect = described_class.new
+
+			expect( aspect ).to match( entity1 )
+			expect( aspect ).to match( entity2 )
+			expect( aspect ).to match( entity3 )
+			expect( aspect ).to match( entity4 )
+			expect( aspect ).to match( entity5 )
+		end
+
+
+		it "matches an individual entity if its components meet the criteria" do
+			aspect = described_class.with_all_of( color, location ).and_none_of( tags )
+
+			expect( aspect ).to_not match( entity1 )
+			expect( aspect ).to match( entity2 )
+			expect( aspect ).to_not match( entity3 )
+			expect( aspect ).to_not match( entity4 )
+			expect( aspect ).to_not match( entity5 )
+
+			aspect = described_class.with_one_of( tags, color )
+
+			expect( aspect ).to_not match( entity1 )
+			expect( aspect ).to match( entity2 )
+			expect( aspect ).to match( entity3 )
+			expect( aspect ).to match( entity4 )
+			expect( aspect ).to match( entity5 )
+		end
+
+
+		it "matches a component hash if it meets the criteria" do
+			aspect = described_class.with_all_of( color, location ).and_none_of( tags )
+
+			expect( aspect ).to_not match( entity1.components )
+			expect( aspect ).to match( entity2.components )
+			expect( aspect ).to_not match( entity3.components )
+			expect( aspect ).to_not match( entity4.components )
+			expect( aspect ).to_not match( entity5.components )
+		end
+
+	end
+
+
 end
 

data/spec/chione/component_spec.rb

@@ -12,6 +12,7 @@ describe Chione::Component do
 		let( :component_subclass ) do
 			Class.new( described_class )
 		end
+		let( :entity_id ) { '73BA6CB5-50CB-4EA4-9941-5EBF17D5D379' }
 
 
 		it "can declare fields" do
@@ -27,6 +28,19 @@ describe Chione::Component do
 		end
 
 
+		it "includes a description of its fields in its inspection output" do
+			component_subclass.field( :name )
+			component_subclass.field( :x )
+			component_subclass.field( :y )
+
+			instance = component_subclass.new
+
+			expect( instance.inspect ).to match( /\bname:/ )
+			expect( instance.inspect ).to match( /\bx:/ )
+			expect( instance.inspect ).to match( /\by:/ )
+		end
+
+
 		it "can declare fields with default values" do
 			component_subclass.field( :x, default: 0 )
 			component_subclass.field( :y, default: 18 )
@@ -37,6 +51,17 @@ describe Chione::Component do
 		end
 
 
+		it "can declare fields with a block for validation or pre-processing" do
+			component_subclass.field( :coordinates, default: [0, 0] ) do |vals|
+				{ x: Integer(vals[0]), y: Integer(vals[1]) }
+			end
+
+			instance = component_subclass.new( coordinates: [88, 19] )
+			expect( instance.coordinates[:x] ).to eq( 88 )
+			expect( instance.coordinates[:y] ).to eq( 19 )
+		end
+
+
 		it "uses a dup of the default if it's not an immediate object" do
 			component_subclass.field( :things, default: [] )
 
@@ -59,6 +84,18 @@ describe Chione::Component do
 			expect( instance2.oid ).to eq( 121212 )
 		end
 
+
+		it "can be created with an entity ID" do
+			component_subclass.field( :x )
+			component_subclass.field( :y )
+
+			instance = component_subclass.new( entity_id, x: 1, y: 18 )
+
+			expect( instance.entity_id ).to eq( entity_id )
+			expect( instance.x ).to eq( 1 )
+			expect( instance.y ).to eq( 18 )
+		end
+
 	end
 
 end

data/spec/chione/entity_spec.rb

@@ -98,51 +98,44 @@ describe Chione::Entity do
 		end
 
 
-		it "lets components be fetched from it" do
-			entity.add_component( location_component )
-			entity.add_component( tags_component )
+		it "can have components with init arguments added to it" do
+			entity.add_component( location_component, x: 18, y: 51 )
+			entity.add_component( tags_component, tags: ['trace', 'volatile'] )
 
-			expect(
-				entity.find_component( location_component )
-			).to eq( entity.components[location_component] )
+			expect( entity.get_component(location_component).x ).to eq( 18 )
+			expect( entity.get_component(location_component).y ).to eq( 51 )
+			expect( entity.get_component(tags_component).tags ).to contain_exactly('trace', 'volatile')
 		end
 
 
-		it "supports backward-compatible component-fetcher method" do
+		it "lets components be fetched for it" do
 			entity.add_component( location_component )
 			entity.add_component( tags_component )
 
 			expect(
 				entity.get_component( location_component )
-			).to eq( entity.components[location_component] )
+			).to be_an_instance_of( location_component )
 		end
 
 
-		it "lets one of a list of components be fetched from it" do
+		it "can have components removed from it" do
 			entity.add_component( location_component )
 			entity.add_component( tags_component )
 
-			expect(
-				entity.find_component( bounding_box_component, location_component )
-			).to eq( entity.components[location_component] )
-		end
-
+			entity.remove_component( tags_component )
 
-		it "raises a KeyError if it doesn't have a fetched component" do
-			entity.add_component( tags_component )
-
-			expect {
-				entity.find_component( location_component )
-			}.to raise_error( KeyError, /#{entity.id} doesn't have/i )
+			expect( entity ).to have_component( location_component )
+			expect( entity ).to_not have_component( tags_component )
 		end
 
 
-		it "raises a KeyError if it doesn't have any of several fetched components" do
+		it "returns nil when fetching a component the entity doesn't have" do
+			entity.add_component( location_component )
 			entity.add_component( tags_component )
 
-			expect {
-				entity.find_component( location_component, bounding_box_component )
-			}.to raise_error( KeyError, /#{entity.id} doesn't have any of/i )
+			expect(
+				entity.get_component( bounding_box_component )
+			).to be_nil
 		end
 
 	end

data/spec/chione/iterating_system_spec.rb

@@ -0,0 +1,135 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../spec_helper'
+
+require 'chione/iterating_system'
+require 'chione/fixtures'
+
+
+describe Chione::IteratingSystem do
+
+	before( :all ) do
+		Chione::Fixtures.load( :entities )
+		@component_classes = Chione::Component.derivatives.dup
+	end
+	before( :each ) do
+		Chione::Component.derivatives.clear
+	end
+	after( :all ) do
+		Chione::Component.derivatives.replace( @component_classes )
+	end
+
+
+	let( :subclass ) { Class.new(described_class) }
+	let( :world ) { Chione::World.new }
+	let( :location_component ) do
+		klass = Class.new( Chione::Component ) do
+			def self::name; "Location"; end
+			field :x, default: 0
+			field :y, default: 0
+		end
+		Chione::Component.derivatives['location'] = klass
+		klass
+	end
+
+	let( :tags_component ) do
+		klass = Class.new( Chione::Component ) do
+			def self::name; "Tags"; end
+			field :tags, default: []
+		end
+		Chione::Component.derivatives['tags'] = klass
+		klass
+	end
+
+	let( :bounding_box_component ) do
+		klass = Class.new( Chione::Component ) do
+			def self::name; "BoundingBox"; end
+			field :width, default: 1
+			field :height, default: 1
+			field :depth, default: 1
+		end
+		Chione::Component.derivatives['bounding_box'] = klass
+		klass
+	end
+
+
+	describe "instances" do
+
+		let( :instance ) { subclass.new(world) }
+
+
+		it "requires an override for the #process method" do
+			expect( instance ).to respond_to( :process )
+			expect {
+				instance.process( :default, 'entity-id', {} )
+			}.to raise_error( NotImplementedError, /#process/i )
+		end
+
+
+		describe "with a process method" do
+
+			let( :entity ) { Chione::Fixtures.entity(world) }
+
+
+			let( :subclass ) do
+				cls = super()
+				cls.class_exec(location_component, bounding_box_component) do |location, bbox|
+					aspect :default, all_of: [location, bbox]
+					aspect :emphemeral, all_of: [location], none_of: bbox
+
+					def initialize( * )
+						super
+						@calls = []
+					end
+
+					attr_reader :calls
+
+					def process( aspect_name, entity_id, components )
+						@calls << [ aspect_name, entity_id, components ]
+					end
+				end
+
+				cls
+			end
+
+
+			it "gets called for each entity which matches an aspect on each tick" do
+				entities_with_location = entity.with_components( location_component ).
+					generator.take( 5 ) # :ephemeral
+				entities_with_bb = entity.with_components( bounding_box_component ).
+					generator.take( 5 ) # -
+				entities_with_both = entity.
+					with_components( location_component, bounding_box_component ).
+					generator.take( 5 ) # :default
+
+				sys = world.add_system( subclass )
+				sys.start
+
+				world.publish( 'timing', 0.5, 1 )
+				world.publish_deferred_events
+
+				both_components = a_hash_including( location_component, bounding_box_component )
+				only_location_component = a_hash_including( location_component )
+
+				expect( sys.calls.length ).to eq( 10 )
+				expect( sys.calls ).to contain_exactly(
+					[:default, entities_with_both[0].id, both_components ],
+					[:default, entities_with_both[1].id, both_components ],
+					[:default, entities_with_both[2].id, both_components ],
+					[:default, entities_with_both[3].id, both_components ],
+					[:default, entities_with_both[4].id, both_components ],
+					[:emphemeral, entities_with_location[0].id, only_location_component ],
+					[:emphemeral, entities_with_location[1].id, only_location_component ],
+					[:emphemeral, entities_with_location[2].id, only_location_component ],
+					[:emphemeral, entities_with_location[3].id, only_location_component ],
+					[:emphemeral, entities_with_location[4].id, only_location_component ]
+				)
+			end
+
+		end
+
+	end
+
+
+end
+

data/spec/chione/system_spec.rb

@@ -3,10 +3,16 @@
 require_relative '../spec_helper'
 
 require 'chione/system'
+require 'chione/fixtures'
 
 
 describe Chione::System do
 
+	before( :all ) do
+		Chione::Fixtures.load( :entities )
+	end
+
+
 	let( :location_component ) do
 		Class.new( Chione::Component ) do
 			field :x, default: 0
@@ -30,40 +36,218 @@ describe Chione::System do
 	describe "subclass" do
 
 		let( :subclass ) do
-			Class.new(described_class)
+			Class.new( described_class ) do
+				def initialize( * )
+					super
+					@calls = []
+				end
+				attr_reader :calls
+
+				def inserted( *args )
+					self.calls << [ __method__, args ]
+					super
+				end
+				def removed( *args )
+					self.calls << [ __method__, args ]
+					super
+				end
+			end
 		end
 		let( :world ) { Chione::World.new }
 
 
-		it "has a default Aspect which matches all entities" do
-			expect( subclass.aspect ).to be_empty
-		end
+		describe "aspects" do
+
+			it "has a default Aspect which matches all entities" do
+				expect( subclass.aspects ).to be_empty
+				expect( subclass.aspects[:default] ).to be_empty
+			end
+
+
+			it "can declare components for its default aspect" do
+				subclass.aspect :default,
+					all_of: volition_component,
+					one_of: [ tags_component, location_component ]
+
+				expect( subclass.aspects.keys ).to contain_exactly( :default )
+				expect( subclass.aspects[:default].all_of ).to include( volition_component )
+				expect( subclass.aspects[:default].one_of ).
+					to include( tags_component, location_component )
+			end
+
+
+			it "can declare a named aspect" do
+				subclass.aspect( :with_location, all_of: location_component )
+
+				expect( subclass.aspects.keys ).to contain_exactly( :with_location )
+				expect( subclass.aspects[:with_location].all_of ).
+					to contain_exactly( location_component )
+			end
+
+
+			it "can declare a named aspect using simplified syntax" do
+				subclass.aspect( :with_location, location_component )
+
+				expect( subclass.aspects.keys ).to contain_exactly( :with_location )
+				expect( subclass.aspects[:with_location].all_of ).
+					to contain_exactly( location_component )
+			end
+
+
+			it "can declare more than one named aspect" do
+				subclass.aspect( :with_location, all_of: location_component )
+				subclass.aspect( :self_movable, all_of: [location_component, volition_component] )
+
+				expect( subclass.aspects.keys ).to contain_exactly( :with_location, :self_movable )
+				expect( subclass.aspects[:with_location].all_of ).to contain_exactly( location_component )
+				expect( subclass.aspects[:self_movable].all_of ).
+					to contain_exactly( location_component, volition_component )
+			end
+
+
+			it "keeps an explicitly-defined default aspect event if other named ones are added" do
+				subclass.aspect( :default, all_of: location_component )
+				subclass.aspect( :self_movable, all_of: [location_component, volition_component] )
+
+				expect( subclass.aspects.keys ).to contain_exactly( :default, :self_movable )
+				expect( subclass.aspects[:default].all_of ).to contain_exactly( location_component )
+				expect( subclass.aspects[:self_movable].all_of ).
+					to contain_exactly( location_component, volition_component )
+			end
+
 
+			it "is notified when adding a component causes an entity to start matching one of its aspects" do
+				subclass.aspect( :with_location, all_of: location_component )
+				subclass.aspect( :self_movable, all_of: [location_component, volition_component] )
+
+				entity = world.create_entity
+
+				sys = world.add_system( subclass )
+				sys.start
+
+				world.add_component_to( entity, location_component )
+				world.publish_deferred_events
+
+				expect( sys.calls.length ).to eq( 1 )
+				expect( sys.calls ).to include([
+						:inserted, [
+							:with_location,
+							entity.id,
+							{location_component => an_instance_of(location_component)}
+						]
+					])
+
+				world.add_component_to( entity, volition_component )
+				world.publish_deferred_events
+
+				expect( sys.calls.length ).to eq( 2 )
+				expect( sys.calls ).to include([
+						:inserted, [
+							:self_movable,
+							entity.id,
+							{
+								location_component => an_instance_of(location_component),
+								volition_component => an_instance_of(volition_component)
+							}
+						]
+					])
+			end
 
-		it "can declare components for its aspect" do
-			subclass.aspect all_of: volition_component,
-				one_of: [ tags_component, location_component ]
 
-			expect( subclass.aspect ).to_not be_empty
-			expect( subclass.aspect.all_of ).to include( volition_component )
-			expect( subclass.aspect.one_of ).to include( tags_component, location_component )
+			it "is notified when removing a component causes an entity to no longer match one of its aspects" do
+				subclass.aspect( :with_location, all_of: location_component )
+				subclass.aspect( :self_movable, all_of: [location_component, volition_component] )
+
+				entity = world.create_entity
+				world.add_component_to( entity, location_component )
+				world.add_component_to( entity, volition_component )
+				world.publish_deferred_events
+
+				sys = world.add_system( subclass )
+				sys.start
+
+				world.remove_component_from( entity, volition_component )
+				world.publish_deferred_events
+
+				expect( sys.calls.length ).to eq( 1 )
+				expect( sys.calls ).to include([
+						:removed, [
+							:self_movable,
+							entity.id,
+							{location_component => an_instance_of(location_component)}
+						]
+					])
+
+				world.remove_component_from( entity, location_component )
+				world.publish_deferred_events
+
+				expect( sys.calls.length ).to eq( 2 )
+				expect( sys.calls ).to include([
+						:removed, [
+							:with_location,
+							entity.id,
+							{}
+						]
+					])
+			end
+
 		end
 
 
-		it "can declare required components for its aspect via shorthand syntax" do
-			subclass.for_entities_that_have( volition_component )
+		describe "event handlers" do
+
+			it "has no event handlers by default" do
+				expect( subclass.event_handlers ).to be_empty
+			end
+
+
+			it "can register a handler method for an event" do
+				subclass.on( 'entity/created' ) do |*|
+					# no-op
+				end
+
+				expect( subclass.event_handlers ).
+					to include( ['entity/created', 'on_entity_created_event'] )
+				expect( subclass.instance_methods ).to include( :on_entity_created_event )
+			end
+
+
+			it "provides a convenience declaration for the timing event" do
+				subclass.every_tick do |*|
+					# no-op
+				end
+
+				expect( subclass.event_handlers ).
+					to include( ['timing', 'on_timing_event'] )
+				expect( subclass.instance_methods ).to include( :on_timing_event )
+			end
+
+
+			it "unwraps arguments to `every_tick` callbacks" do
+				received_delta = received_tick = nil
+				subclass.every_tick do |delta, tick|
+					received_delta = delta
+					received_tick = tick
+				end
+
+				instance = subclass.new( world )
+				instance.on_timing_event( 'timing', [0.016666666666666666, 0] )
+
+				expect( received_delta ).to be_within( 0.00001 ).of( 0.016666666666666666 )
+				expect( received_tick ).to eq( 0 )
+			end
 
-			expect( subclass.aspect ).to_not be_empty
-			expect( subclass.aspect.all_of ).to include( volition_component )
 		end
 
 
 		describe "instance" do
 
 			let( :subclass ) do
-				subclass = super()
-				subclass.aspect all_of: volition_component,
-					one_of: [ tags_component, location_component ]
+				subclass = Class.new( described_class )
+				subclass.aspect( :default,
+					all_of: volition_component,
+					one_of: [tags_component, location_component] )
+				subclass.aspect( :tagged, all_of: tags_component )
 				subclass
 			end
 
@@ -72,20 +256,33 @@ describe Chione::System do
 			end
 
 
-			it "can enumerate the entities from the world that match its aspect" do
-				ent1 = world.create_entity
-				ent1.add_component( volition_component )
-				ent1.add_component( tags_component )
+			before( :each ) do
+				@ent1 = world.create_entity
+				@ent1.add_component( volition_component )
+				@ent1.add_component( tags_component )
 
-				ent2 = world.create_entity
-				ent2.add_component( volition_component )
-				ent2.add_component( location_component )
+				@ent2 = world.create_entity
+				@ent2.add_component( volition_component )
+				@ent2.add_component( location_component )
 
-				ent3 = world.create_entity
-				ent3.add_component( volition_component )
+				@ent3 = world.create_entity
+				@ent3.add_component( volition_component )
 
+				@ent4 = world.create_entity
+				@ent4.add_component( location_component )
+				@ent4.add_component( tags_component )
+			end
+
+
+			it "can enumerate the entities from the world that match its default aspect" do
 				expect( instance.entities ).to be_a( Enumerator )
-				expect( instance.entities ).to contain_exactly( ent1, ent2 )
+				expect( instance.entities ).to contain_exactly( @ent1.id, @ent2.id )
+			end
+
+
+			it "can enumerate the entities from the world that match one of its named aspects" do
+				expect( instance.entities(:tagged) ).to be_a( Enumerator )
+				expect( instance.entities(:tagged) ).to contain_exactly( @ent1.id, @ent4.id )
 			end