def execute(self): thread = Thread(target=self.countdown) thread.start() logger.info(f"Executing KnockDownEvent for player at ({self.player.row},{self.player.column})") self.game: GameStateModel = GameStateModel.instance() # if the player was carrying/leading a victim, # that victim is lost. disassociate the # victim from the player and increment the # number of victims lost. if isinstance(self.player.carrying_victim, VictimModel): self.player.carrying_victim.state = VictimStateEnum.LOST logger.info(f"{self.player.carrying_victim} being carried was lost.") self.game.game_board.remove_poi_or_victim(self.player.carrying_victim) self.player.carrying_victim = NullModel() self.game.victims_lost = self.game.victims_lost + 1 if isinstance(self.player.leading_victim, VictimModel): self.player.leading_victim.state = VictimStateEnum.LOST logger.info(f"{self.player.leading_victim} being led was lost.") self.game.game_board.remove_poi_or_victim(self.player.leading_victim) self.player.leading_victim = NullModel() self.game.victims_lost = self.game.victims_lost + 1 # Family mode: # get the closest ambulance spots to the player. # if there is only one closest spot, set the # player's location to that of the closest spot. # else, assign a random closest spot to the player. if self.game.rules == GameKindEnum.FAMILY: player_tile = self.game.game_board.get_tile_at(self.player.row, self.player.column) closest_ambulance_spots = self.game.game_board.find_closest_parking_spots("Ambulance", player_tile) if len(closest_ambulance_spots) == 1: amb_spot = closest_ambulance_spots[0] self.player.set_pos(amb_spot.row, amb_spot.column) else: rand_index = random.randint(0, len(closest_ambulance_spots)-1) amb_spot = closest_ambulance_spots[rand_index] self.player.set_pos(amb_spot.row, amb_spot.column) # Experienced mode: # Player's location is set to that of the # ambulance's current location. else: ambulance = self.game.game_board.ambulance self.player.set_pos(ambulance.row, ambulance.column)
def __init__(self, row: int, column: int, space_kind: SpaceKindEnum): super().__init__() self._row = row self._column = column self._space_kind = space_kind self._space_status = SpaceStatusEnum.SAFE self._is_hotspot = False self._associated_models = [] self._visit_count = 0 self._adjacent_tiles = { "North": NullModel(), "East": NullModel(), "West": NullModel(), "South": NullModel(), } self._adjacent_edge_objects = { "North": NullModel(), "East": NullModel(), "West": NullModel(), "South": NullModel(), } self._arrow_dirn = ArrowDirectionEnum.NO_DIRECTION
def set_adjacencies(self, tiles: List[List[TileModel]]): extended_grid = [] for row in tiles: extended_grid.append([NullModel()] + row + [NullModel()]) row_length = len(tiles[0]) extra_top_row = [NullModel() for x in range(row_length + 2)] extra_bottom_row = [NullModel() for x in range(row_length + 2)] extended_grid = [extra_top_row] + extended_grid + [extra_bottom_row] for i in range(1, len(extended_grid) - 1): for j in range(1, len(extended_grid[0]) - 1): extended_grid[i][j].set_adjacent_tile("North", extended_grid[i - 1][j]) extended_grid[i][j].set_adjacent_tile("East", extended_grid[i][j + 1]) extended_grid[i][j].set_adjacent_tile("West", extended_grid[i][j - 1]) extended_grid[i][j].set_adjacent_tile("South", extended_grid[i + 1][j])
def send_pickup_event(self, tile_model: TileModel, menu_to_close: Interactable): victims = [ model for model in tile_model.associated_models if isinstance(model, VictimModel) ] logger.info( f"Player has a victim: {isinstance(self._current_player.carrying_victim, VictimModel)}" ) victim = NullModel() if victims: victim = victims[0] if not victim: return if not self.check_pickup(tile_model): return event = PickupVictimEvent(victim.row, victim.column) if Networking.get_instance().is_host: Networking.get_instance().send_to_all_client(event) else: Networking.get_instance().client.send(event) menu_to_close.disable()
def get_obstacle_in_direction( self, direction: str) -> Optional['EdgeObstacleModel']: """ Get the EdgeObstacle model :return: EdgeObstacleModel in the direction specified, or NullModel. """ return self._adjacent_edge_objects.get(direction, NullModel())
def __init__(self, seed: int = 0, row: int = -1, column: int = -1): super().__init__() if seed == 0: self.seed = random.randint(1, 6969) else: self.seed = seed self.row = row self.col = column # Pick random location: roll dice random.seed(self.seed) game: GameStateModel = GameStateModel.instance() self.player = game.players_turn self.engine = game.game_board.engine if row > -1 and column > -1: self.target_tile: TileModel = game.game_board.get_tile_at( self.row, self.col) else: self.target_tile = NullModel()
def __init__(self, ip: str, nickname: str): super().__init__() self._ip = ip self._row = -1 self._column = -1 self._nickname = nickname self._color = Color.WHITE self._status = PlayerStatusEnum.NOT_READY self._ap = 0 self._special_ap = 0 self._wins = 0 self._losses = 0 self._carrying_victim = NullModel() self._leading_victim = NullModel() self._carrying_hazmat = NullModel() self.has_moved = False self._role: PlayerRoleEnum = PlayerRoleEnum.FAMILY self._has_AP_from_veteran = False self._allowed_to_dodge = False
def resolve_hazmat_while_traveling(self, target_tile: TileModel): """ If player goes out of the building carrying a hazmat, dispose of that hazmat. :param target_tile: tile player is heading to :return: """ if target_tile.space_kind == SpaceKindEnum.INDOOR: return if isinstance(self.fireman.carrying_hazmat, HazmatModel): self.fireman.carrying_hazmat.set_pos(-7, -7) self.fireman.carrying_hazmat = NullModel()
def set_single_tile_adjacencies(self, tile: TileModel): # set north tile if tile.row == 0: tile.set_adjacent_tile("North", NullModel()) else: tile.set_adjacent_tile("North", self.get_tile_at(tile.row - 1, tile.column)) # set east tile if tile.column == BOARD_DIMENSIONS[1] - 1: tile.set_adjacent_tile("East", NullModel()) else: tile.set_adjacent_tile("East", self.get_tile_at(tile.row, tile.column + 1)) # set west tile if tile.column == 0: tile.set_adjacent_tile("West", NullModel()) else: tile.set_adjacent_tile("West", self.get_tile_at(tile.row, tile.column - 1)) # set south tile if tile.row == BOARD_DIMENSIONS[0] - 1: tile.set_adjacent_tile("South", NullModel()) else: tile.set_adjacent_tile("South", self.get_tile_at(tile.row + 1, tile.column))
def update_profiles(self): if not os.path.exists(self.profiles): with open(self.profiles, mode="w+", encoding='utf-8') as myFile: myFile.write("[]") with open(self.profiles, mode='r', encoding='utf-8') as myFile: temp = json.load(myFile) for i, user in enumerate(temp): player: PlayerModel = JSONSerializer.deserialize(user) player.ip = Networking.get_instance().get_ip() player.set_pos(-1, -1) player.ap = 0 player.special_ap = 0 player.carrying_victim = NullModel() self.profile.set_profile( i, player.nickname, player.wins, player.losses, EventQueue.post, CustomEvent(ChangeSceneEnum.HOSTJOINSCENE, player=player) ) self.profile.remove_profile_callback(i, self.remove_profile, player.nickname)
def resolve_hazmat_explosions(self): """ For all the fire tiles, if any of them contain a hazmat, cause an explosion in that space. After the explosion, remove the hazmat from the tile and put a hotspot marker on that tile. :return: """ for tile in self.game_state.game_board.tiles: if tile.space_status == SpaceStatusEnum.FIRE: # If the tile contains a Hazmat, trigger # an explosion. for assoc_model in tile.associated_models: if isinstance(assoc_model, HazmatModel): logger.info( "Hazmat explosion occured on {t}".format(t=tile)) self.explosion(tile) assoc_model.set_pos(-7, -7) tile.remove_associated_model(assoc_model) if self.board.hotspot_bank > 0: tile.is_hotspot = True self.board.hotspot_bank = self.board.hotspot_bank - 1 # If there are any players on the tile and # if they are carrying a Hazmat, knock down # the player, trigger an explosion and disassociate # the Hazmat from the player. players_on_tile = self.game_state.get_players_on_tile( tile.row, tile.column) for player in players_on_tile: if isinstance(player.carrying_hazmat, HazmatModel): logger.info( "Hazmat explosion occured on {t}".format(t=tile)) self.explosion(tile) if not self.dodge(player): KnockDownEvent(player.ip).execute() player.carrying_hazmat.set_pos(-7, -7) player.carrying_hazmat = NullModel() if self.board.hotspot_bank > 0: tile.is_hotspot = True self.board.hotspot_bank = self.board.hotspot_bank - 1
def resolve_victim_while_traveling(self, target_tile: TileModel): """ Family mode: If victim carried outside of building, victim has been saved. Experienced mode: If victim carried/led to ambulance, victim has been saved. Both cases: Increment number of victims saved in game state and dissociate victim from player. :param target_tile: Tile to which player travels with the victim :return: """ if self.game.rules == GameKindEnum.EXPERIENCED: if target_tile.space_kind != SpaceKindEnum.AMBULANCE_PARKING: return # Target space is an Ambulance Parking spot. # If the target space does not match either # of the ambulance's current location tiles, # then the victim has not been brought to the # ambulance. game_board = self.game.game_board amb_first_tile = game_board.get_tile_at( game_board.ambulance.row, game_board.ambulance.column) amb_second_tile = game_board.get_other_parking_tile(amb_first_tile) eq_to_first = target_tile.row == amb_first_tile.row and target_tile.column == amb_first_tile.column eq_to_second = target_tile.row == amb_second_tile.row and target_tile.column == amb_second_tile.column if not eq_to_first and not eq_to_second: return # Family mode: # If the target tile is indoors, # we don't have to resolve the victim. else: if target_tile.space_kind == SpaceKindEnum.INDOOR: return # For Experienced mode, we only reach here # if the target space is equal to one of # the ambulance's current location tiles. if isinstance(self.fireman.carrying_victim, VictimModel): self.fireman.carrying_victim.state = VictimStateEnum.RESCUED thread = Thread(target=self.countdown) thread.start() self.game.victims_saved = self.game.victims_saved + 1 # remove the victim from the list of active POIs on the board # and disassociate the victim from the player self.game.game_board.remove_poi_or_victim( self.fireman.carrying_victim) self.fireman.carrying_victim = NullModel() if isinstance(self.fireman.leading_victim, VictimModel): thread = Thread(target=self.countdown) thread.start() self.fireman.leading_victim.state = VictimStateEnum.RESCUED self.game.victims_saved = self.game.victims_saved + 1 self.game.game_board.remove_poi_or_victim( self.fireman.leading_victim) self.fireman.leading_victim = NullModel()
class FireDeckGunEvent(TurnEvent): def __init__(self, seed: int = 0, row: int = -1, column: int = -1): super().__init__() if seed == 0: self.seed = random.randint(1, 6969) else: self.seed = seed self.row = row self.col = column # Pick random location: roll dice random.seed(self.seed) game: GameStateModel = GameStateModel.instance() self.player = game.players_turn self.engine = game.game_board.engine if row > -1 and column > -1: self.target_tile: TileModel = game.game_board.get_tile_at( self.row, self.col) else: self.target_tile = NullModel() def execute(self, *args, **kwargs): logger.info("Executing Fire Deck Gun Event") self.game: GameStateModel = GameStateModel.instance() if isinstance(self.target_tile, NullModel): self._set_target_tile() self.target_tile.space_status = SpaceStatusEnum.SAFE FileImporter.play_music(SPLASH_SOUND, 1) tile_sprite = GameBoard.instance().grid.grid[self.target_tile.column][ self.target_tile.row] tile_sprite.fire_deck_gun = True directions = ["North", "East", "West", "South"] for dirn in directions: has_obstacle = self.target_tile.has_obstacle_in_direction(dirn) obstacle = self.target_tile.get_obstacle_in_direction(dirn) # If there is no obstacle in the given direction or there is an # open door, set the status of the space in that direction to Safe. if not has_obstacle or (isinstance(obstacle, DoorModel) and obstacle.door_status == DoorStatusEnum.OPEN)\ or (isinstance(obstacle, WallModel) and obstacle.wall_status == WallStatusEnum.DESTROYED): nb_tile: TileModel = self.target_tile.get_tile_in_direction( dirn) nb_tile.space_status = SpaceStatusEnum.SAFE tile_sprite = GameBoard.instance().grid.grid[nb_tile.column][ nb_tile.row] tile_sprite.fire_deck_gun = True if self.player.role == PlayerRoleEnum.DRIVER: self.player.ap = self.player.ap - 2 else: self.player.ap = self.player.ap - 4 def _set_target_tile(self): """ Set the tile which will be the target for the firing of the deck gun. :return: """ engine_quadrant = self._determine_quadrant(self.engine.row, self.engine.column) target_row = GameStateModel.instance().roll_red_dice() target_column = GameStateModel.instance().roll_black_dice() target_quadrant = self._determine_quadrant(target_row, target_column) # If the roll gives a tile in the engine's # quadrant, that will become the target tile. if target_quadrant == engine_quadrant: self.target_tile = GameStateModel.instance( ).game_board.get_tile_at(target_row, target_column) return else: # Flipping the red dice involves # subtracting the roll value from 7. flipped_row = 7 - target_row # Try out the following combinations # and see if any of them are in the # engine's quadrant: # 1. flipping the row, same column # 2. same row, flipping the column # 3. flipping the row, flipping the column new_target_quadrant = self._determine_quadrant( flipped_row, target_column) if new_target_quadrant == engine_quadrant: self.target_tile = GameStateModel.instance( ).game_board.get_tile_at(flipped_row, target_column) return flipped_column = GameStateModel.instance( ).determine_black_dice_opposite_face(target_column) new_target_quadrant = self._determine_quadrant( target_row, flipped_column) if new_target_quadrant == engine_quadrant: self.target_tile = GameStateModel.instance( ).game_board.get_tile_at(target_row, flipped_column) return new_target_quadrant = self._determine_quadrant( flipped_row, flipped_column) if new_target_quadrant == engine_quadrant: self.target_tile = GameStateModel.instance( ).game_board.get_tile_at(flipped_row, flipped_column) return # $$$$$$$$$$$$$$$$$ # Shouldn't be able to reach this point!! # One of the cases above should have worked. # $$$$$$$$$$$$$$$$$ logger.error("Possible issue with dice flipping! Stop!!") raise FlippingDiceProblemException() def _determine_quadrant_player(self, row, column) -> QuadrantEnum: """ Determines the quadrant to which the row and column belong to. :param row: :param column: :return: Quadrant in which the row and column are located. """ if 4 > row > 0 and 5 > column > 0: return QuadrantEnum.TOP_LEFT elif 4 > row > 0 and 5 <= column < 9: return QuadrantEnum.TOP_RIGHT elif 4 <= row < 7 and 5 > column > 0: return QuadrantEnum.BOTTOM_LEFT elif 4 <= row < 7 and 5 <= column < 9: return QuadrantEnum.BOTTOM_RIGHT def _determine_quadrant(self, row, column) -> QuadrantEnum: """ Determines the quadrant to which the row and column belong to. :param row: :param column: :return: Quadrant in which the row and column are located. """ if row < 4 and column < 5: return QuadrantEnum.TOP_LEFT elif row < 4 and column >= 5: return QuadrantEnum.TOP_RIGHT elif row >= 4 and column < 5: return QuadrantEnum.BOTTOM_LEFT else: return QuadrantEnum.BOTTOM_RIGHT def _are_players_in_quadrant(self, quadrant: QuadrantEnum) -> bool: """ Determines whether there are any players in the given quadrant. :param quadrant: Quadrant that we are interested in. :return: True if there are players in the quadrant, False otherwise. """ for player in GameStateModel.instance().players: if quadrant == self._determine_quadrant_player( self.player.row, self.player.column): return True return False
def __init__(self, tile_model: TileModel): game: GameStateModel = GameStateModel.instance() self.tile_model = game.game_board.get_tile_at(tile_model.row, tile_model.column) self.least_cost = 10000 self.predecessor: DijkstraTile = NullModel()
def dodge(self, player: PlayerModel) -> bool: """ Determines whether the player can dodge (out of turn) to avoid being knocked down and performs dodge. Returns False otherwise. :param player: player that is attempting to dodge :return: True if the player is able to dodge, False otherwise """ logger.info("Attempting to dodge...") # Doge cannot dodge if player.role == PlayerRoleEnum.DOGE: self._log_player_dodge(1, player) return False if not self._valid_to_dodge(player): self._log_player_dodge(1, player) return False player_tile = self.game_state.game_board.get_tile_at( player.row, player.column) possible_dodge_target = NullModel() for dirn, nb_tile in player_tile.adjacent_tiles.items(): if isinstance(nb_tile, TileModel): has_obstacle = player_tile.has_obstacle_in_direction(dirn) obstacle = player_tile.get_obstacle_in_direction(dirn) is_open_door = isinstance( obstacle, DoorModel) and obstacle.door_status == DoorStatusEnum.OPEN if not has_obstacle or is_open_door: if nb_tile.space_status != SpaceStatusEnum.FIRE: possible_dodge_target = nb_tile break # If we couldn't find a potential space # to dodge, the player cannot avoid being # knocked down. if isinstance(possible_dodge_target, NullModel): self._log_player_dodge(1, player) return False # Pause the current event and ask player to dodge: EventQueue.post(CustomEvent(CustomEventEnum.DODGE_PROMPT, player)) logger.info( f"Thread {threading.current_thread().getName()} going to sleep") # Go to sleep switch.pause_event.clear() switch.pause_event.wait() logger.info(f"Thread {threading.current_thread().getName()} woke up") if not GameStateModel.instance().dodge_reply: logger.info("Reply was no, knocking player down") return False logger.info("Reply was yes, attempting to dodge...") GameStateModel.instance().dodge_reply = False # Disassociate the victim/hazmat that the player # may be carrying since they cannot dodge with them player_victim = player.carrying_victim player_hazmat = player.carrying_hazmat is_carrying_victim = isinstance(player_victim, VictimModel) is_carrying_hazmat = isinstance(player_hazmat, HazmatModel) if is_carrying_victim: self._log_player_dodge(2, player, player_victim, player_tile) player_tile.add_associated_model(player_victim) player.carrying_victim = NullModel() if is_carrying_hazmat: self._log_player_dodge(2, player, player_hazmat, player_tile) player_tile.add_associated_model(player_hazmat) player.carrying_hazmat = NullModel() self._log_player_dodge(3, player) player.set_pos(possible_dodge_target.row, possible_dodge_target.column) # Costs 1 AP for Veteran to dodge # and 2 AP for the rest of the roles if player.role == PlayerRoleEnum.VETERAN: player.ap = player.ap - 1 else: player.ap = player.ap - 2 return True
def execute(self): logger.info("Executing Drop Victim Event") self.victim_tile.add_associated_model(self.player.carrying_victim) self.player.carrying_victim = NullModel()
def execute(self): logger.info("Executing Drop Hazmat Event") self.hazmat_tile.add_associated_model(self.player.carrying_hazmat) self.player.carrying_hazmat = NullModel()
def execute(self): logger.info("Executing Stop Leading Victim Event") self.victim_tile.add_associated_model(self.player.leading_victim) self.player.leading_victim = NullModel()
def deserialize(payload: Dict) -> object: """ Grab an object and deserialize it. Note that the object must be able to take a dict as input. If there are nested objects or enums in the object, it must define its own _deserialize method by implementing the Serializable abstract class. Add to this case statement to be able to deserialize your object type. """ object_type = payload["class"] # --------------MODELS---------------- if object_type == PlayerModel.__name__: return JSONSerializer._deserialize_player(payload) elif object_type == TileModel.__name__: return JSONSerializer._deserialize_tile(payload) elif object_type == GameStateModel.__name__: return JSONSerializer._deserialize_game_state(payload) elif object_type == DoorModel.__name__: return JSONSerializer._deserialize_door(payload) elif object_type == WallModel.__name__: return JSONSerializer._deserialize_wall(payload) elif object_type == VictimModel.__name__: return JSONSerializer._deserialize_victim(payload) elif object_type == HazmatModel.__name__: return JSONSerializer._deserialize_hazmat(payload) elif object_type == POIModel.__name__: return JSONSerializer._deserialize_poi_model(payload) # --------------EVENTS------------------ elif object_type == JoinEvent.__name__: return JSONSerializer._deserialize_join_event(payload) elif object_type == ChatEvent.__name__: return JSONSerializer._deserialize_chat_event(payload) elif object_type == ReadyEvent.__name__: return JSONSerializer._deserialize_ready_event(payload) elif object_type == StartGameEvent.__name__: return StartGameEvent() elif object_type == EndGameEvent.__name__: return JSONSerializer._deserialize_end_game_event(payload) elif object_type == ChooseStartingPositionEvent.__name__: return JSONSerializer._deserialize_choose_position_event(payload) elif object_type == ChopEvent.__name__: return JSONSerializer._deserialize_chop_event(payload) elif object_type == WallModel.__name__: return JSONSerializer._deserialize_wall(payload) elif object_type == DoorModel.__name__: return JSONSerializer._deserialize_door(payload) elif object_type == MoveEvent.__name__: return JSONSerializer._deserialize_move_event(payload) elif object_type == DummyEvent.__name__: return DummyEvent() elif object_type == DisconnectEvent.__name__: return JSONSerializer._deserialize_disconnect_event(payload) elif object_type == HostDisconnectEvent.__name__: return HostDisconnectEvent() elif object_type == ExtinguishEvent.__name__: return JSONSerializer._deserialize_extinguish_event(payload) elif object_type == NullModel.__name__: return NullModel() elif object_type == DropVictimEvent.__name__: return JSONSerializer._deserialize_drop_victim_event(payload) elif object_type == ChooseCharacterEvent.__name__: return JSONSerializer._deserialize_choose_character_event(payload) elif object_type == PickupVictimEvent.__name__: return JSONSerializer._deserialize_pickup_victim_event(payload) elif object_type == LeadVictimEvent.__name__: return JSONSerializer._deserialize_lead_victim_event(payload) elif object_type == StopLeadingVictimEvent.__name__: return JSONSerializer._deserialize_stop_leading_victim_event( payload) elif object_type == DropHazmatEvent.__name__: return JSONSerializer._deserialize_drop_hazmat_event(payload) elif object_type == PickupHazmatEvent.__name__: return JSONSerializer._deserialize_pickup_hazmat_event(payload) elif object_type == OpenDoorEvent.__name__: return JSONSerializer._deserialize_open_door_event(payload) elif object_type == EndTurnAdvanceFireEvent.__name__: return JSONSerializer._deserialize_end_turn_advance_fire_event( payload) elif object_type == CloseDoorEvent.__name__: return JSONSerializer._deserialize_close_door_event(payload) elif object_type == SetInitialPOIFamilyEvent.__name__: return JSONSerializer._deserialize_set_initial_poi_family_event( payload) elif object_type == PlaceHazmatEvent.__name__: return JSONSerializer._deserialize_place_hazmat_event(payload) elif object_type == VehiclePlacedEvent.__name__: return JSONSerializer._deserialize_vehicle_placed_event(payload) elif object_type == DriveVehicleEvent.__name__: return JSONSerializer._deserialize_drive_vehicle_event(payload) elif object_type == IdentifyPOIEvent.__name__: return JSONSerializer._deserialize_identify_poi_event(payload) elif object_type == RideVehicleEvent.__name__: return JSONSerializer._deserialize_ride_vehicle_event(payload) elif object_type == DismountVehicleEvent.__name__: return JSONSerializer._deserialize_dismount_vehicle_event(payload) elif object_type == ChooseCharacterEvent.__name__: return JSONSerializer._deserialize_choose_character_event(payload) elif object_type == RemoveHazmatEvent.__name__: return JSONSerializer._deserialize_remove_hazmat_event(payload) elif object_type == ResuscitateEvent.__name__: return JSONSerializer._deserialize_resuscitate_event(payload) elif object_type == DodgeReplyEvent.__name__: return JSONSerializer._deserialize_dodge_reply(payload) elif object_type == RandomBoardSetupEvent.__name__: return JSONSerializer._deserialize_random_board_event(payload) elif object_type == BoardSetupEvent.__name__: return BoardSetupEvent(payload['seed']) elif object_type == CrewChangeEvent.__name__: return JSONSerializer._deserialize_crew_change_event(payload) elif object_type == TooManyPlayersEvent.__name__: return TooManyPlayersEvent() elif object_type == NullModel.__name__: return NullModel() elif object_type == CommandPermissionEvent.__name__: return JSONSerializer._deserialize_command_permission_event( payload) elif object_type == PermissionReplyEvent.__name__: return JSONSerializer._deserialize_permission_reply(payload) elif object_type == StopCommandEvent.__name__: return JSONSerializer._deserialize_stop_command_event(payload) elif object_type == FireDeckGunEvent.__name__: return JSONSerializer._deserialize_fire_deck_gun_event(payload) elif object_type == VeteranGiveExperienceEvent.__name__: return JSONSerializer._deserialize_veteran_give_experience_event( payload) logger.warning( f"Could not deserialize object {object_type}, not of recognized type." )