def process_DropsEvent(self, event, **kwargs): """Respawn the Entity to be dropped in the respective room, delete it from Engine.rack and pass the PicksUpEvent on. """ fabula.LOGGER.debug("called") room = None for current_room in self.room_by_id.values(): if event.identifier in current_room.entity_dict.keys(): room = current_room # Respawn the Entity to be dropped in room # Delete it from Engine.rack # # TODO: Fails when Entity not in rack. Contracts. # fabula.LOGGER.info( "removing '{}' from Rack and respawning in Room".format( event.entity.identifier)) dropped_entity = self.rack.retrieve(event.entity.identifier) spawn_event = fabula.SpawnEvent(dropped_entity, event.location) room.process_SpawnEvent(spawn_event) # and pass the DropsEvent on # kwargs["message"].event_list.append(event) return
def process_DropsEvent(self, event, **kwargs): """Remove affected Entity from rack, queue SpawnEvent for room and Plugin, and pass on the DropsEvent. """ # TODO: the DropsEvent and PicksUpEvent handling in Client and Plugin are asymmetrical. This is ugly. Unify. # Former default # fabula.LOGGER.debug("called") # Maybe someone drops something which is not in our rack, for example # if the dropping Entity brings the item from a different room. dropped_entity = None if event.entity.identifier in self.rack.entity_dict.keys(): # Respawn the Entity to be dropped in Engine.room # Delete it from Engine.rack # fabula.LOGGER.info("removing '{}' from Rack".format( event.entity.identifier)) dropped_entity = self.rack.retrieve(event.entity.identifier) else: dropped_entity = event.entity fabula.LOGGER.info("Spawning '{}' in Room".format( dropped_entity.identifier)) spawn_event = fabula.SpawnEvent(dropped_entity, event.location) self.room.process_SpawnEvent(spawn_event) # and pass the DropsEvent on # kwargs["message"].event_list.append(event) # Drop confirmed # if event.identifier == self.client_id: self.await_confirmation = False return
def process_DropsEvent(self, event): """Pass the Event to the dropping Entity and spawn the dropped Entity. """ fabula.LOGGER.debug("passing Event to '{}'".format(event.identifier)) self.host.room.entity_dict[event.identifier].process_DropsEvent(event) # Spawn the dropped Entity # fabula.LOGGER.info("spawning '{}' in room".format( event.entity.identifier)) entity = self.host.room.entity_dict[event.entity.identifier] self.process_SpawnEvent(fabula.SpawnEvent(entity, event.location)) return
def _generate_room_rack_events(self, room_identifier): """Generate and return a series of Events that establish an existing Room and the Rack. EnterRoomEvent and RoomCompleteEvent will not be included. """ event_list = [] room = self.room_by_id[room_identifier] for tuple in room.floor_plan: tile = room.floor_plan[tuple].tile change_map_element_event = fabula.ChangeMapElementEvent( tile, tuple + (room.identifier, )) event_list.append(change_map_element_event) for identifier in room.entity_locations: entity = room.entity_dict[identifier] spawn_event = fabula.SpawnEvent( entity, room.entity_locations[identifier] + (room.identifier, )) event_list.append(spawn_event) # Set properties of the Entity if there are any # for property in entity.property_dict.keys(): change_property_event = fabula.ChangePropertyEvent( entity.identifier, property, entity.property_dict[property]) event_list.append(change_property_event) if len(self.rack.entity_dict): for identifier in self.rack.entity_dict: # Only send items that are owned by Entities currently in this # room. # if self.rack.owner_dict[identifier] in self.room_by_id[ room.identifier].entity_dict.keys(): # We must spawn at a valid location. Spawning at the first # coordinate tuple in the room. Doesn't matter, it will be # picked up in an instant anyway. # spawn_event = fabula.SpawnEvent( self.rack.entity_dict[identifier], list(room.floor_plan.keys())[0] + (room.identifier, )) event_list.append(spawn_event) picks_up_event = fabula.PicksUpEvent( self.rack.owner_dict[identifier], identifier) event_list.append(picks_up_event) return event_list
def handle_messages(self, remote_message_buffer): """This background thread method transfers messages between local and remote MessageBuffer. It uses representations of the Events being sent to create new copies of the original ones. """ fabula.LOGGER.info("starting up") # Run thread as long as no shutdown is requested # while not self.shutdown_flag: # Get messages from remote # if remote_message_buffer.messages_for_remote: original_message = remote_message_buffer.messages_for_remote.popleft( ) new_message = fabula.Message([]) for event in original_message.event_list: if isinstance( event, fabula.SpawnEvent ) and event.entity.__class__ is not fabula.Entity: # These need special care. We need to have a canonic # fabula.Entity. Entity.clone() will produce one. # fabula.LOGGER.debug( "cloning canonical Entity from {}".format( event.entity)) event = fabula.SpawnEvent(event.entity.clone(), event.location) # Create new instances from string representations to avoid # concurrent access of client and server to the object # fabula.LOGGER.debug("evaluating: '{}'".format(repr(event))) try: new_message.event_list.append(eval(repr(event))) except SyntaxError: # Well, well, well. Some __repr__ does not return a # string that can be evaluated here! # fabula.LOGGER.error( "error: can not evaluate '{}', skipping".format( repr(event))) # Blindly use the first connection # list(self.connections.values())[0].messages_for_local.append( new_message) # No need to deliver messages to remote since it will grab them - # see above. # No need to run as fast as possible # sleep(1 / self.framerate) # Caught shutdown notification, stopping thread # fabula.LOGGER.info("shutting down") self.shutdown_confirmed = True raise SystemExit