Beispiel #1
0
 def test_worlds_disjoint(self):
     from grease import World, Entity
     world1 = World()
     world2 = World()
     self.assertTrue(world1 is not world2)
     e1 = Entity(world1)
     e2 = Entity(world2)
     self.assertEqual(len(world1.entities), 1)
     self.assertEqual(len(world2.entities), 1)
     self.assertTrue(e1.world is world1)
     self.assertTrue(e2.world is world2)
     self.assertTrue(e1 in world1.entities)
     self.assertFalse(e2 in world1.entities)
     self.assertFalse(e1 in world2.entities)
     self.assertTrue(e2 in world2.entities)
     self.assertNotEqual(e1, e2)
Beispiel #2
0
    def test_set_components(self):
        from grease import World
        comp1 = TestComponent()
        comp2 = TestComponent()
        comp3 = TestComponent()
        world = World()
        self.assertFalse(world.systems)
        self.assertFalse(world.components)
        self.assertRaises(AttributeError, getattr, world, 'foobar')
        world.components.foobar = comp1
        self.assertTrue(world.components.foobar is comp1)
        self.assertTrue(comp1.world is world)
        self.assertEqual(len(world.components), 1)

        self.assertRaises(AttributeError, getattr, world, 'spam')
        world.components.spam = comp2
        self.assertTrue(world.components.spam is comp2)
        self.assertTrue(comp2.world is world)
        self.assertEqual(len(world.components), 2)

        self.assertRaises(AttributeError, getattr, world, 'foobar')
        world.components.foobar = comp3
        self.assertTrue(world.components.foobar is comp3)
        self.assertTrue(comp3.world is world)
        self.assertEqual(len(world.components), 2)
        self.assertEqual(list(world.components), [comp3, comp2])
Beispiel #3
0
    def test_union_extent(self):
        from grease import World, Entity

        class Entity1(Entity):
            pass

        class Entity2(Entity1):
            pass

        class Entity3(Entity):
            pass

        world = World()
        entities = [
            Entity1(world),
            Entity2(world),
            Entity2(world),
            Entity3(world)
        ]
        union_extent_1_2 = world[Entity1, Entity2]
        self.assertEqual(union_extent_1_2.entities, set(entities[:-1]))
        union_extent_2_3 = world[Entity2, Entity3]
        self.assertEqual(union_extent_2_3.entities, set(entities[1:]))
        union_extent_1_3 = world[Entity1, Entity3]
        self.assertEqual(union_extent_1_3.entities, set(entities))
Beispiel #4
0
 def test_step_max_dt(self):
     from grease import World
     world = World()
     sys1 = world.systems.sys = TestSystem()
     comp1 = world.components.foo = TestComponent()
     world.step(10000)
     self.assertEqual(comp1.runtime, 10.0 / world.step_rate)
     self.assertEqual(sys1.runtime, 10.0 / world.step_rate)
Beispiel #5
0
 def test_defaults(self):
     from grease import World
     world = World(clock_factory=TestClock)
     self.assertEqual(world.step_rate, 60)
     self.assertFalse(world.active)
     self.assertTrue(world.running)
     self.assertEqual(world.time, 0)
     self.assertTrue((world.step, 1.0 / 60) in world.clock.scheduled)
Beispiel #6
0
 def test_del_component(self):
     from grease import World
     world = World()
     comp1 = world.components.one = TestComponent()
     comp2 = world.components.two = TestComponent()
     comp3 = world.components.three = TestComponent()
     self.assertEqual(list(world.components), [comp1, comp2, comp3])
     del world.components.two
     self.assertEqual(list(world.components), [comp1, comp3])
     del world.components.one
     self.assertEqual(list(world.components), [comp3])
     self.assertRaises(AttributeError, delattr, world, 'one')
Beispiel #7
0
 def test_del_systems(self):
     from grease import World
     world = World()
     sys1 = world.systems.one = TestSystem()
     sys2 = world.systems.two = TestSystem()
     sys3 = world.systems.three = TestSystem()
     self.assertEqual(list(world.systems), [sys1, sys2, sys3])
     del world.systems.two
     self.assertEqual(list(world.systems), [sys1, sys3])
     del world.systems.one
     self.assertEqual(list(world.systems), [sys3])
     self.assertRaises(AttributeError, delattr, world, 'one')
Beispiel #8
0
 def test_create_entities_in_world(self):
     from grease import World, Entity
     world = World()
     self.assertFalse(world.entities)
     e1 = Entity(world)
     e2 = Entity(world)
     self.assertEqual(len(world.entities), 2)
     self.assertTrue(e1 in world.entities)
     self.assertTrue(e1.world is world)
     self.assertTrue(e2 in world.entities)
     self.assertTrue(e2.world is world)
     self.assertNotEqual(e1, e2)
Beispiel #9
0
 def test_entity_extent_component_access(self):
     from grease import World, Entity
     from grease.entity import ComponentEntitySet
     world = World()
     comp = world.components.test = TestComponent()
     e1 = Entity(world)
     e2 = Entity(world)
     comp.add(e1)
     comp.add(e2)
     extent = world[Entity]
     comp_set = extent.test
     self.assertEqual(comp_set, set([e1, e2]))
     self.assertRaises(AttributeError, getattr, extent, "hummina")
Beispiel #10
0
 def test_step_components(self):
     from grease import World, Entity
     world = World()
     comp1 = world.components.one = TestComponent()
     comp2 = world.components.two = TestComponent()
     entity = Entity(world)
     self.assertTrue(comp1.runtime == comp2.runtime == 0, comp1.runtime)
     world.step(0.05)
     self.assertEqual(comp1.runtime, 0.05)
     self.assertEqual(comp2.runtime, 0.05)
     world.step(0.06)
     self.assertEqual(comp1.runtime, 0.11)
     self.assertEqual(comp2.runtime, 0.11)
Beispiel #11
0
 def test_set_renderers(self):
     from grease import World
     world = World()
     self.assertEqual(tuple(world.renderers), ())
     renderer1 = world.renderers.one = TestRenderer()
     renderer2 = world.renderers.two = TestRenderer()
     renderer3 = world.renderers.three = object(
     )  # arbitrary objects can be renderers
     self.assertEqual(tuple(world.renderers),
                      (renderer1, renderer2, renderer3))
     # objects with a set_world() method should have it called when set
     self.assertTrue(renderer1.world is world)
     self.assertTrue(renderer2.world is world)
Beispiel #12
0
 def test_configure_components(self):
     from grease import World
     comp1 = TestComponent()
     comp2 = TestComponent()
     comp3 = TestComponent()
     world = World()
     self.assertEqual(len(world.components), 0)
     world.components.one = comp1
     world.components.two = comp2
     world.components.three = comp3
     self.assertEqual(list(world.components), [comp1, comp2, comp3])
     self.assertTrue(comp1.world is world)
     self.assertTrue(comp2.world is world)
     self.assertTrue(comp3.world is world)
Beispiel #13
0
 def test_add_systems(self):
     from grease import World
     world = World()
     self.assertFalse(world.systems)
     sys1 = world.systems.one = TestSystem()
     sys2 = world.systems.two = TestSystem()
     sys3 = world.systems.three = TestSystem()
     self.assertEqual(list(world.systems), [sys1, sys2, sys3])
     self.assertTrue(world.systems.one is sys1)
     self.assertTrue(world.systems.two is sys2)
     self.assertTrue(world.systems.three is sys3)
     self.assertTrue(sys1.world is world)
     self.assertTrue(sys2.world is world)
     self.assertTrue(sys3.world is world)
Beispiel #14
0
 def test_activate(self):
     from grease import World
     world = World(master_clock=TestClock())
     sys1 = world.systems.one = TestSystem()
     sys2 = world.systems.two = TestSystem()
     manager = TestModeManager()
     self.assertFalse(world.active)
     world.activate(manager)
     self.assertTrue(world.manager is manager, world.manager)
     self.assertTrue(world.active)
     self.assertTrue((world.tick, None) in world.master_clock.scheduled)
     self.assertTrue(sys1 in manager.handlers)
     self.assertTrue(sys2 in manager.handlers)
     return world, manager
Beispiel #15
0
 def test_tick_increments_world_time(self):
     from grease import World
     world = World(clock_factory=TestClock)
     self.assertEqual(world.time, 0)
     self.assertEqual(world.clock.ticks, 0)
     self.assertEqual(world.clock.time_func(), world.time)
     dt = 1.0 / 30.0
     world.tick(dt)
     self.assertAlmostEqual(world.time, dt)
     self.assertEqual(world.clock.time_func(), world.time)
     self.assertEqual(world.clock.ticks, 1)
     world.tick(dt)
     self.assertAlmostEqual(world.time, dt * 2)
     self.assertEqual(world.clock.time_func(), world.time)
     self.assertEqual(world.clock.ticks, 2)
Beispiel #16
0
 def test_running(self):
     from grease import World
     world = World()
     self.assertTrue(world.running)
     self.assertEqual(world.time, 0)
     dt = 1.0 / 30.0
     world.tick(dt)
     self.assertAlmostEqual(world.time, dt)
     world.running = False
     world.tick(dt)
     world.tick(dt)
     self.assertAlmostEqual(world.time, dt)
     world.running = True
     world.tick(dt)
     self.assertAlmostEqual(world.time, dt * 2)
Beispiel #17
0
 def test_system_step_order(self):
     from grease import World
     world = World()
     sys1 = world.systems.one = TestSystem()
     sys3 = world.systems.three = TestSystem()
     sys2 = TestSystem()
     world.systems.insert('two', sys2, index=1)
     self.assertEqual(len(world.systems), 3)
     self.assertTrue(sys1.runtime == sys2.runtime == sys3.runtime == 0)
     self.assertTrue(
         sys1.order == sys2.order == sys3.order == TestSystem.order)
     world.step(0.13)
     self.assertTrue(sys1.runtime == sys2.runtime == sys3.runtime == 0.13)
     start = sys1.order
     self.assertEqual(sys2.order, start + 1)
     self.assertEqual(sys3.order, start + 2)
Beispiel #18
0
 def test_on_draw(self):
     from grease import World
     world = World()
     renderer1 = world.renderers.one = TestRenderer()
     renderer2 = world.renderers.two = TestRenderer()
     gl = TestGL()
     self.assertFalse(gl.cleared)
     self.assertFalse(gl.matrix_reset)
     self.assertFalse(renderer1.drawn)
     self.assertFalse(renderer2.drawn)
     world.on_draw(gl=gl)
     self.assertTrue(gl.cleared)
     self.assertTrue(gl.matrix_reset)
     self.assertTrue(renderer1.drawn)
     self.assertTrue(renderer2.drawn)
     start = renderer1.order
     self.assertEqual(renderer2.order, start + 1)
Beispiel #19
0
    def test_entity_superclass_extents(self):
        from grease import World, Entity

        class Superentity(Entity):
            pass

        class Subentity(Superentity):
            pass

        class SubSubentity(Subentity):
            pass

        class Another(Entity):
            pass

        world = World()
        super_extent = world[Superentity]
        super = Superentity(world)
        sub = Subentity(world)
        subsub = SubSubentity(world)
        another = Another(world)
        self.assertTrue(super in super_extent.entities)
        self.assertTrue(sub in super_extent.entities)
        self.assertTrue(subsub in super_extent.entities)
        self.assertFalse(another in super_extent.entities)
        sub_extent = world[Subentity]
        self.assertFalse(super in sub_extent.entities)
        self.assertTrue(sub in sub_extent.entities)
        self.assertTrue(subsub in sub_extent.entities)
        self.assertFalse(another in sub_extent.entities)
        subsub_extent = world[SubSubentity]
        self.assertFalse(super in subsub_extent.entities)
        self.assertFalse(sub in subsub_extent.entities)
        self.assertTrue(subsub in subsub_extent.entities)
        self.assertFalse(another in subsub_extent.entities)
        another_extent = world[Another]
        self.assertFalse(super in another_extent.entities)
        self.assertFalse(sub in another_extent.entities)
        self.assertFalse(subsub in another_extent.entities)
        self.assertTrue(another in another_extent.entities)
        world.entities.remove(subsub)
        self.assertFalse(subsub in super_extent.entities)
        self.assertFalse(subsub in sub_extent.entities)
        self.assertFalse(subsub in subsub_extent.entities)
        self.assertFalse(subsub in another_extent.entities)
Beispiel #20
0
 def test_remove_entity(self):
     from grease import World, Entity
     world = World()
     comp1 = world.components.one = TestComponent()
     comp2 = world.components.two = TestComponent()
     comp3 = world.components.three = TestComponent()
     entity = Entity(world)
     comp1.add(entity)
     comp2.add(entity)
     self.assertTrue(entity in world.entities)
     self.assertTrue(entity in comp1)
     self.assertTrue(entity in comp2)
     self.assertFalse(entity in comp3)
     world.entities.remove(entity)
     self.assertFalse(entity in world.entities)
     self.assertFalse(entity in comp1)
     self.assertFalse(entity in comp2)
     self.assertFalse(entity in comp3)
     self.assertRaises(KeyError, world.entities.remove, entity)
Beispiel #21
0
 def test_join_components(self):
     from grease import World, Entity
     world = World()
     comp1 = world.components.foo = TestComponent()
     comp2 = world.components.bar = TestComponent()
     comp3 = world.components.baz = TestComponent()
     entity = Entity(world)
     for i in range(20):
         entity = object()
         comp1.add(entity, i)
         if i < 5:
             comp2.add(entity, i * 10)
         if i < 3:
             comp3.add(entity, i * 100)
     self.assertEqual(sorted(world.components.join('baz', 'bar', 'foo')),
                      [(0, 0, 0), (100, 10, 1), (200, 20, 2)])
     self.assertEqual(sorted(world.components.join('foo', 'bar')),
                      [(0, 0), (1, 10), (2, 20), (3, 30), (4, 40)])
     self.assertEqual(sorted(world.components.join('baz')), [(0, ), (100, ),
                                                             (200, )])
Beispiel #22
0
 def test_insert_system(self):
     from grease import World
     world = World()
     sys1 = world.systems.sys1 = TestSystem()
     sys2 = world.systems.sys2 = TestSystem()
     sys3 = world.systems.sys3 = TestSystem()
     inserted = TestSystem()
     world.systems.insert('inserted', inserted, before='sys2')
     self.assertEqual(list(world.systems), [sys1, inserted, sys2, sys3])
     self.assertTrue(world.systems.inserted is inserted)
     another = TestSystem()
     world.systems.insert('another', another, before=world.systems.sys3)
     self.assertTrue(world.systems.another is another)
     self.assertEqual(list(world.systems),
                      [sys1, inserted, sys2, another, sys3])
     onemore = TestSystem()
     world.systems.insert('onemore', onemore, index=1)
     self.assertEqual(list(world.systems),
                      [sys1, onemore, inserted, sys2, another, sys3])
     self.assertTrue(world.systems.onemore is onemore)
Beispiel #23
0
 def test_illegal_part_name(self):
     from grease import World
     from grease.component import ComponentError
     world = World()
     self.assertRaises(ComponentError, setattr, world.components,
                       'entities', TestComponent())
     self.assertRaises(ComponentError, setattr, world.systems, 'entities',
                       TestSystem())
     self.assertRaises(ComponentError, setattr, world.renderers, 'entities',
                       TestRenderer())
     self.assertRaises(ComponentError, setattr, world.components,
                       '_reserved', TestComponent())
     self.assertRaises(ComponentError, setattr, world.systems, '_reserved',
                       TestSystem())
     self.assertRaises(ComponentError, setattr, world.renderers,
                       '_reserved', TestRenderer())
     self.assertRaises(AttributeError, setattr, world.components, 'insert',
                       TestComponent())
     self.assertRaises(AttributeError, setattr, world.systems, 'insert',
                       TestSystem())
     self.assertRaises(AttributeError, setattr, world.renderers, 'insert',
                       TestRenderer())
Beispiel #24
0
 def test_add_system_during_run(self):
     from grease import World
     world = World()
     sys1 = world.systems.sys1 = TestSystem()
     to_inject = TestSystem()
     injector = world.systems.injector = TestSystemInjector(
         'injected', to_inject)
     self.assertEqual(len(world.systems), 2)
     self.assertTrue(
         sys1.runtime == to_inject.runtime == injector.runtime == 0)
     self.assertFalse(injector.injected)
     world.step(0.1)
     self.assertEqual(len(world.systems), 3)
     self.assertEqual(sys1.runtime, 0.1)
     self.assertEqual(injector.runtime, 0.1)
     self.assertEqual(to_inject.runtime, 0)
     self.assertTrue(injector.injected)
     world.step(0.1)
     self.assertEqual(len(world.systems), 3)
     self.assertEqual(sys1.runtime, 0.2)
     self.assertEqual(injector.runtime, 0.2)
     self.assertEqual(to_inject.runtime, 0.1)
Beispiel #25
0
    def test_full_extent(self):
        from grease import World, Entity

        class Entity1(Entity):
            pass

        class Entity2(Entity1):
            pass

        class Entity3(Entity):
            pass

        world = World()
        full_extent = world[...]
        self.assertEqual(world.entities, full_extent.entities)
        entities = set(
            [Entity1(world),
             Entity2(world),
             Entity3(world),
             Entity1(world)])
        self.assertEqual(world.entities, entities)
        self.assertEqual(full_extent.entities, entities)
        self.assertEqual(world[...].entities, entities)
Beispiel #26
0
    def test_entity_extent_membership_simple(self):
        from grease import World, Entity

        class MyEntity(Entity):
            pass

        class Another(Entity):
            pass

        world = World()
        self.assertFalse(world.entities)
        extent = world[MyEntity]
        self.assertFalse(extent.entities)
        entity1 = MyEntity(world)
        self.assertTrue(entity1 in extent.entities)
        entity2 = MyEntity(world)
        self.assertTrue(entity2 in extent.entities)
        world.entities.remove(entity2)
        self.assertTrue(entity1 in extent.entities)
        self.assertFalse(entity2 in extent.entities)
        entity3 = Another(world)
        self.assertFalse(entity3 in extent.entities)
        self.assertTrue(entity3 in world[Another].entities)
Beispiel #27
0
 def test_discard_entity(self):
     from grease import World, Entity
     world = World()
     comp1 = world.components.one = TestComponent()
     comp2 = world.components.two = TestComponent()
     comp3 = world.components.three = TestComponent()
     entity = Entity(world)
     comp1.add(entity)
     comp2.add(entity)
     self.assertTrue(entity in world.entities)
     self.assertTrue(entity in comp1)
     self.assertTrue(entity in comp2)
     self.assertFalse(entity in comp3)
     world.entities.discard(entity)
     self.assertFalse(entity in world.entities)
     self.assertFalse(entity in comp1)
     self.assertFalse(entity in comp2)
     self.assertFalse(entity in comp3)
     world.entities.discard(entity)
     self.assertFalse(entity in world.entities)
     self.assertFalse(entity in comp1)
     self.assertFalse(entity in comp2)
     self.assertFalse(entity in comp3)
Beispiel #28
0
 def test_overrides(self):
     from grease import World
     world = World(step_rate=30, clock_factory=TestClock)
     self.assertEqual(world.step_rate, 30)
     self.assertTrue((world.step, 1.0 / 30) in world.clock.scheduled)