def test_creation(world): world.add_system(PerceiveRoom(), 0) room = world.create_entity(Room(), ) actor = world.create_entity(RoomPresence(room=room._uid, ), ) world.update() room_cmpt = room.get_component(Room) assert len(room_cmpt.presences) == 1 assert room_cmpt.presences[0] == actor._uid assert len(room_cmpt.arrived) == 1 assert room_cmpt.arrived[0] == actor._uid assert len(room_cmpt.continued) == 0 assert len(room_cmpt.gone) == 0 presence_cmpt = actor.get_component(RoomPresence) assert len(presence_cmpt.presences) == 1 assert presence_cmpt.presences[0] == actor._uid world.update() room_cmpt = room.get_component(Room) assert len(room_cmpt.presences) == 1 assert room_cmpt.presences[0] == actor._uid assert len(room_cmpt.arrived) == 0 assert len(room_cmpt.continued) == 1 assert room_cmpt.continued[0] == actor._uid assert len(room_cmpt.gone) == 0 presence_cmpt = actor.get_component(RoomPresence) assert len(presence_cmpt.presences) == 1 assert presence_cmpt.presences[0] == actor._uid
def test_is_in_room(world): world.add_system(PerceiveRoom(), 0) # A room, and an actor and an item in the roomless void. room = world.create_entity(Room(), ) actor = world.create_entity() item = world.create_entity() assert not is_in_room(item, actor) with pytest.raises(EntityNotInARoom): is_in_room(item, actor, throw_exc=True) # Now the actor is in the room. actor.add_component(RoomPresence(room=room._uid, ), ) world.update() assert not is_in_room(item, actor) with pytest.raises(ItemNotInARoom): is_in_room(item, actor, throw_exc=True) # And now the item is there, too. item.add_component(RoomPresence(room=room._uid, ), ) world.update() assert is_in_room(item, actor)
def test_resolving_reference(world): to_entity = world.create_entity() from_entity = world.create_entity() from_entity.add_component(Reference(uid=to_entity._uid)) world._flush_component_updates() reference = world.get_entity(from_entity.get_component(Reference).uid) assert reference is to_entity
def test_change_room(world): world.add_system(ChangeRoom(), 0) world.add_system(PerceiveRoom(), 1) room = world.create_entity() other_room = world.create_entity() room.add_component(Room(adjacent=[other_room._uid]), ) other_room.add_component(Room(adjacent=[room._uid]), ) actor = world.create_entity(RoomPresence(room=room._uid, ), ) world.update() actor.add_component(ChangeRoomAction(room=other_room._uid, ), ) world.update() room_cmpt = room.get_component(Room) assert len(room_cmpt.presences) == 0 assert len(room_cmpt.arrived) == 0 assert len(room_cmpt.continued) == 0 assert len(room_cmpt.gone) == 1 assert room_cmpt.gone[0] == actor._uid other_room_cmpt = other_room.get_component(Room) assert len(other_room_cmpt.presences) == 1 assert other_room_cmpt.presences[0] == actor._uid assert len(other_room_cmpt.arrived) == 1 assert other_room_cmpt.arrived[0] == actor._uid assert len(other_room_cmpt.continued) == 0 assert len(other_room_cmpt.gone) == 0 presence_cmpt = actor.get_component(RoomPresence) assert presence_cmpt.room == other_room._uid assert len(presence_cmpt.presences) == 1 assert presence_cmpt.presences[0] == actor._uid
def test_mutual_perception(world): world.add_system(ChangeRoom(), 0) world.add_system(PerceiveRoom(), 1) # Two connected rooms, an actor in each room = world.create_entity() other_room = world.create_entity() room.add_component(Room(adjacent=[other_room._uid], ), ) other_room.add_component(Room(adjacent=[room._uid], ), ) actor = world.create_entity(RoomPresence(room=room._uid, ), ) other_actor = world.create_entity(RoomPresence(room=other_room._uid, ), ) world.update() # They only see themselves presence_cmpt = actor.get_component(RoomPresence) assert len(presence_cmpt.presences) == 1 assert presence_cmpt.presences[0] == actor._uid other_presence_cmpt = actor.get_component(RoomPresence) assert len(other_presence_cmpt.presences) == 1 assert other_presence_cmpt.presences[0] == actor._uid # Now let one actor change rooms actor.add_component(ChangeRoomAction(room=other_room._uid, ), ) world.update() # Now they see each other. presence_cmpt = actor.get_component(RoomPresence) assert len(presence_cmpt.presences) == 2 assert actor._uid in presence_cmpt.presences assert other_actor._uid in presence_cmpt.presences other_presence_cmpt = actor.get_component(RoomPresence) assert len(other_presence_cmpt.presences) == 2 assert actor._uid in other_presence_cmpt.presences assert other_actor._uid in other_presence_cmpt.presences
def test_resolving_dangling_reference(world): to_entity = world.create_entity() from_entity = world.create_entity() from_entity.add_component(Reference(uid=to_entity._uid)) world.destroy_entity(to_entity) world._flush_component_updates() with pytest.raises(NoSuchUID): world.get_entity(from_entity.get_component(Reference).uid)
def test_remembers_entities(world): entities = set() assert set(world.entities) == entities entities.add(world.create_entity()) assert set(world.entities) == entities entities.add(world.create_entity()) assert set(world.entities) == entities entities.add(world.create_entity()) assert set(world.entities) == entities
def test_can_get_entities_with_component(world): a = world.create_entity() b = world.create_entity() c = world.create_entity() d = world.create_entity() a.add(SomeComponent()) b.add(AnotherComponent()) c.add(SomeComponent()) c.add(AnotherComponent()) assert list(world.entities_with(SomeComponent)) == [a, c] assert list(world.entities_with(AnotherComponent)) == [b, c]
def test_is_in_inventory(world, room): item = world.create_entity( Takeable(), ) actor = world.create_entity( RoomPresence(room=room._uid), Inventory(contents=[item._uid]), ) world._flush_component_updates() assert is_in_inventory(item, actor)
def can_not_drop_untakeable_item_exception(world, room): world.add_system(PerceiveRoom(), 0) world.add_system(TakeOrDrop(throw_exc=True), 1) item = world.create_entity() actor = world.create_entity( RoomPresence(room=room._uid), Inventory(contents=[item._uid]), DropAction(item=item._uid), ) with pytest.raises(NotTakeable): world.update()
def test_can_not_take_from_the_void_exception(world): world.add_system(PerceiveRoom(), 0) world.add_system(TakeOrDrop(throw_exc=True), 1) item = world.create_entity( Takeable(), ) actor = world.create_entity( Inventory(contents=[item._uid]), DropAction(item=item._uid), ) with pytest.raises(ActorNotInRoom): world.update()
def test_cant_change_to_non_adjacent_room(world): world.add_system(ChangeRoom(throw_exc=True), 0) world.add_system(PerceiveRoom(), 1) # Two connected rooms, an actor in each room = world.create_entity(Room(), ) other_room = world.create_entity(Room(), ) actor = world.create_entity( RoomPresence(room=room._uid, ), ChangeRoomAction(room=other_room._uid, ), ) with pytest.raises(RoomsNotAdjacent): world.update()
def test_can_not_take_item_from_other_room_exception(world, room, item): world.add_system(PerceiveRoom(), 0) world.add_system(TakeOrDrop(throw_exc=True), 1) world.add_system(PerceiveRoom(), 2, add_duplicates=True) other_room = world.create_entity( Room(), ) actor = world.create_entity( RoomPresence(room=other_room._uid), Inventory(), TakeAction(item=item._uid), ) with pytest.raises(ItemNotInRoom): world.update()
def test_cant_change_to_current_room(world): # This test and the next are more of an informative nature. Since # a room is usually not adjacent to itself, you can't change from # it to it. world.add_system(ChangeRoom(throw_exc=True), 0) world.add_system(PerceiveRoom(), 1) room = world.create_entity(Room(), ) actor = world.create_entity( RoomPresence(room=room._uid, ), ChangeRoomAction(room=room._uid, ), ) with pytest.raises(RoomsNotAdjacent): world.update()
def test_can_not_take_from_the_void(world): world.add_system(PerceiveRoom(), 0) world.add_system(TakeOrDrop(), 1) world.add_system(PerceiveRoom(), 2, add_duplicates=True) item = world.create_entity( Takeable(), ) actor = world.create_entity( Inventory(), TakeAction(item=item._uid), ) world.update() assert actor.get_component(Inventory).contents == [] assert not actor.has_component(TakeAction)
def can_not_drop_untakeable_item(world, room): world.add_system(PerceiveRoom(), 0) world.add_system(TakeOrDrop(), 1) world.add_system(PerceiveRoom(), 2, add_duplicates=True) item = world.create_entity() actor = world.create_entity( RoomPresence(room=room._uid), Inventory(contents=[item._uid]), DropAction(item=item._uid), ) world.update() assert actor.get_component(Inventory).contents == [item._uid] assert not actor.has_component(DropAction) assert not item.has_component(RoomPresence)
def test_proxying_system__field_lookup(world): token = '123' global token_out token_out = None @Component() class TestComponent: foo: str = None class BareTypeProxy(System): entity_filters = { 'test': Proxy('proxy'), } proxies = { 'proxy': ProxyType(TestComponent, 'foo'), } def update(self, entity_by_filters): for entity in entity_by_filters['test']: proxy = self.proxies['proxy'] # test = entity[proxy.component_type] token = proxy.field(entity) global token_out token_out = token system = BareTypeProxy() world.add_system(system, 0) entity = world.create_entity(TestComponent(foo=token)) world.update() assert token == token_out
def test_can_add_components_to_entities(world): entity = world.create_entity() component = Component() assert not world.has_component(entity, Component) world.add_component(entity, component) assert world.has_component(entity, Component) assert world.get_component(entity, Component) is component
def test_addition_to_system__entity_first(world, null_system): entity = world.create_entity(NullComponent()) world._flush_component_updates() world.add_system(null_system, 0) assert entity in null_system.entities['null'] assert len(null_system.entries) == 1 assert null_system.entries[0] == (['null'], entity)
def test_can_remove_components(world): entity = world.create_entity() component = Component() world.add_component(entity, component) assert world.has_component(entity, Component) world.remove_component(entity, Component) assert not world.has_component(entity, Component)
def test_can_not_take_item_from_other_room(world, room, item): world.add_system(PerceiveRoom(), 0) world.add_system(TakeOrDrop(), 1) world.add_system(PerceiveRoom(), 2, add_duplicates=True) other_room = world.create_entity( Room(), ) actor = world.create_entity( RoomPresence(room=other_room._uid), Inventory(), TakeAction(item=item._uid), ) world.update() assert actor.get_component(Inventory).contents == [] assert not actor.has_component(TakeAction) assert item.has_component(RoomPresence)
def test_is_not_in_inventory(world, room, item): actor = world.create_entity( RoomPresence(room=room._uid), Inventory(), ) world._flush_component_updates() assert not is_in_inventory(item, actor)
def test_destroyed_entities_are_forgotten(world): entity = world.create_entity() component = Component() entity.add(component) world.destroy_entitiy(entity) assert entity not in world.entities assert entity not in world.entities_with(Component) assert entity.get(Component, None) is None
def test_basic_clock(world): world.add_system(DetermineTimestep(), sort=0) dt = 0.01 clock = SettableClock(dt) entity = world.create_entity(Clock(clock=clock)) assert dt < entity[Clock].max_timestep world.update() assert entity[Clock].timestep == dt
def test_can_not_take_nonexistant_item_exception(world, room): world.add_system(PerceiveRoom(), 0) world.add_system(TakeOrDrop(throw_exc=True), 1) actor = world.create_entity( RoomPresence(room=room._uid), Inventory(), TakeAction(item=UID()), ) with pytest.raises(NoSuchUID): world.update()
def test_can_not_take_without_an_inventory_exception(world, room, item): world.add_system(PerceiveRoom(), 0) world.add_system(TakeOrDrop(throw_exc=True), 1) world.add_system(PerceiveRoom(), 2, add_duplicates=True) actor = world.create_entity( RoomPresence(room=room._uid), TakeAction(item=item._uid), ) with pytest.raises(ActorHasNoInventory): world.update()
def test_can_not_drop_item_that_actor_does_not_have_exception(world, room, item): world.add_system(PerceiveRoom(), 0) world.add_system(TakeOrDrop(throw_exc=True), 1) actor = world.create_entity( RoomPresence(room=room._uid), Inventory(), DropAction(item=item._uid), ) with pytest.raises(ItemNotInInventory): world.update()
def test_remove_system(world, null_system): entity = world.create_entity(NullComponent()) world._flush_component_updates() world.add_system(null_system, 0) world.remove_system(NullSystem) assert null_system.entities['null'] == set() assert len(null_system.exits) == 1 assert null_system.entries[0] == (['null'], entity) assert world.systems == {} assert not world.has_system(NullSystem)
def test_remove_aspect_from_entity(world): aspect = Aspect([Component_A]) entity = world.create_entity(*aspect()) world._flush_component_updates() assert aspect.in_entity(entity) components = aspect.remove(entity) world._flush_component_updates() assert not aspect.in_entity(entity) assert Component_A not in entity assert len(components) == 1 assert isinstance(components[0], Component_A)
def test_can_change_to_current_room(world): # But we *can* make rooms circular in nature. # I don't know what the point of this is supposed to be. Maybe # someone in the future will have a use case for this. world.add_system(ChangeRoom(throw_exc=True), 0) world.add_system(PerceiveRoom(), 1) room = world.create_entity() room.add_component(Room(adjacent=[room._uid], ), ) actor = world.create_entity(RoomPresence(room=room._uid, ), ) # Let's update to have a clean room state. world.update() actor.add_component(ChangeRoomAction(room=room._uid, ), ) world.update() room_cmpt = room.get_component(Room) assert len(room_cmpt.presences) == 1 assert actor._uid in room_cmpt.presences assert len(room_cmpt.arrived) == 0 assert len(room_cmpt.continued) == 1 assert actor._uid in room_cmpt.continued assert len(room_cmpt.gone) == 0
def test_entity_shorthand(world): entity = world.create_entity() assert not entity.has(Component) assert entity.get(Component, None) is None component = Component() entity.add(component) assert entity.has(Component) assert entity.get(Component) is component entity.remove(Component) assert not entity.has(Component) assert entity.get(Component, None) is None entity.destroy() assert entity not in world.entities
def test_can_create_entity(world): entity = world.create_entity() entity.uid
def test_entities_ids_are_unique(world): a = world.create_entity() b = world.create_entity() assert a.uid != b.uid
def test_adding_a_duplicate_component_is_an_error(world): entity = world.create_entity() world.add_component(entity, Component()) with pytest.raises(DuplicateComponentError): world.add_component(entity, Component())
def test_getting_a_non_existent_component_is_an_error(world): entity = world.create_entity() with pytest.raises(NoSuchComponentError): world.get_component(entity, Component)
def test_can_pass_a_default_when_getting_a_component(world): entity = world.create_entity() assert world.get_component(entity, Component, missing="foo") == "foo"
def test_fails_on_unregistered_components(world): e = world.create_entity() with pytest.raises(UnregisteredComponentError): e.component
def test_shortcut_for_registered_components(world): world.register('component', Component) c = Component() e = world.create_entity() e.add(c) assert e.component == c