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."
)
