def _parse_object(parsed_data, **kwargs) -> TriggersObject: # Expected {} display_order = parser.listify( find_retriever(parsed_data['TriggerPiece'].retrievers, "Trigger display order array").data) trigger_data = parser.listify( find_retriever(parsed_data['TriggerPiece'].retrievers, "Trigger data").data) var_data = parser.listify( find_retriever(parsed_data['TriggerPiece'].retrievers, "Variables").data) triggers = [] for index, trigger in enumerate(trigger_data): triggers.append( TriggerObject._parse_object(parsed_data, trigger=trigger, trigger_id=index)) variables = [] for var in var_data: variables.append( VariableObject._parse_object(parsed_data, variable=var)) return TriggersObject(triggers=triggers, trigger_display_order=display_order, variables=variables)
def _parse_data_header_object(self): object_piece = self.parsed_data['DataHeaderPiece'] retrievers = object_piece.retrievers return DataHeaderObject(version=find_retriever(retrievers, "Version").data, filename=find_retriever( retrievers, "Filename").data)
def _parse_object(parsed_data, **kwargs) -> VariableObject: # Expected {variable=VariableStruct} variable = kwargs['variable'] return VariableObject( variable_id=find_retriever(variable.retrievers, "variable_id").data, name=find_retriever(variable.retrievers, "name").data )
def _parse_diplomacy_object(self): object_piece = self.parsed_data['DiplomacyPiece'] diplomacy = find_retriever(object_piece.retrievers, "Per-player diplomacy").data diplomacies = [] for player_id in range(0, 8): # 0-7 Players diplomacies.append( find_retriever(diplomacy[player_id].retrievers, "Stance with each player").data) return DiplomacyObject(player_stances=diplomacies)
def _parse_object(parsed_data, **kwargs): # Expected {effect=effectStruct} effect_struct = kwargs['effect'] effect_type = find_retriever(effect_struct.retrievers, "effect_type").data parameters = effects.attributes.get(effect_type) parameter_dict = effects.empty_attributes.copy() for param in parameters: parameter_dict[param] = find_retriever(effect_struct.retrievers, param).data return EffectObject(**parameter_dict)
def _parse_file_header_object(self): object_piece = self.parser_header['FileHeaderPiece'] retrievers = object_piece.retrievers return FileHeaderObject( version=find_retriever(retrievers, "Version").data, timestamp=find_retriever(retrievers, "Timestamp of last save").data, instructions=find_retriever(retrievers, "Scenario instructions").data, player_count=find_retriever(retrievers, "Player count").data, creator_name=find_retriever(retrievers, "Creator name").data, )
def _parse_object( parsed_data, **kwargs ) -> ConditionObject: # Expected {condition=conditionStruct} condition_struct = kwargs['condition'] condition_type = find_retriever(condition_struct.retrievers, "condition_type").data parameters = conditions.attributes.get(condition_type) parameter_dict = conditions.empty_attributes.copy() for param in parameters: parameter_dict[param] = find_retriever(condition_struct.retrievers, param).data return ConditionObject(**parameter_dict)
def _debug_log_effect_dataset(self): """ Used for debugging - Only reads One Trigger. """ trigger_data = find_retriever(self._parsed_data['TriggerPiece'].retrievers, "Trigger data").data effects = parser.listify(find_retriever(trigger_data.retrievers, "Effect data").data) for effect in effects: for retriever in effect.retrievers: if retriever.data != -1 and \ retriever.data != [] and \ retriever.data != "" and \ retriever.data != " " and \ retriever.name != "static_value_46": if retriever.name == "effect_type": print("],\n" + str(retriever.data) + ": [") print("\t\"" + retriever.name + "\",") print("]\n")
def _debug_log_condition_dataset(self): """ Used for debugging - Only reads One Trigger. """ trigger_data = find_retriever(self._parsed_data['TriggerPiece'].retrievers, "Trigger data").data conditions = parser.listify(find_retriever(trigger_data.retrievers, "Condition data").data) for condition in conditions: for retriever in condition.retrievers: if retriever.data != -1 and \ retriever.data != [] and \ retriever.data != "" and \ retriever.data != " " and \ retriever.name != "static_value_21": if retriever.name == "condition_type": print("],\n" + str(retriever.data) + ": [") print("\t\"" + retriever.name + "\",") print("]\n")
def _reconstruct_object(parsed_data, objects, **kwargs) -> None: # Expected {} number_of_triggers_retriever = find_retriever(parsed_data['TriggerPiece'].retrievers, "Number of triggers") trigger_data_retriever = find_retriever(parsed_data['TriggerPiece'].retrievers, "Trigger data") display_order_retriever = find_retriever(parsed_data['TriggerPiece'].retrievers, "Trigger display order array") trigger_data_retriever.data = [] for trigger in objects["TriggersObject"].trigger_data: TriggerObject._reconstruct_object(parsed_data, objects, trigger=trigger) assert len(trigger_data_retriever.data) == len(objects["TriggersObject"].trigger_data) trigger_count = len(trigger_data_retriever.data) number_of_triggers_retriever.data = trigger_count # Currently not necessary due to the parser changing the 'repeated' value equal to the len(list) # trigger_data_retriever.datatype.repeat = trigger_count # display_order_retriever.datatype.repeat = trigger_count helper.update_order_array(parser.listify(display_order_retriever.data), trigger_count)
def _parse_object(parsed_data, **kwargs) -> UnitsObject: object_piece = parsed_data['UnitsPiece'] units_per_player = find_retriever(object_piece.retrievers, "Player Units").data player_units = [] for player_id in range(0, 9): # 0 Gaia & 1-8 Players: player_units.append([]) units = parser.listify( find_retriever(units_per_player[player_id].retrievers, "Units").data) for unit in units: player_units[player_id].append( UnitObject._parse_object(parsed_data, unit=unit, player=Player(player_id))) return UnitsObject(units=player_units)
def _reconstruct_object(parsed_header, parsed_data, objects, **kwargs): # Expected {trigger=triggerStruct} trigger_data_retriever = find_retriever( parsed_data['TriggerPiece'].retrievers, "Trigger data") trigger = kwargs['trigger'] trigger.effect_order = parser.listify(trigger.effect_order) trigger.condition_order = parser.listify(trigger.condition_order) effects_list = [] for effect_obj in trigger.effects: EffectObject._reconstruct_object(parsed_header, parsed_data, objects, effect=effect_obj, effects=effects_list) helper.update_order_array(trigger.effect_order, len(trigger.effects)) conditions_list = [] for condition_obj in trigger.conditions: ConditionObject._reconstruct_object(parsed_header, parsed_data, objects, condition=condition_obj, conditions=conditions_list) helper.update_order_array(trigger.condition_order, len(trigger.conditions)) trigger_data_retriever.data.append( TriggerStruct(data=[ trigger.enabled, trigger.looping, trigger.description_stid, trigger.display_as_objective, trigger.description_order, trigger.header, trigger.short_description_stid, trigger.display_on_screen, b'\x00\x00\x00\x00\x00', # Unknown trigger.mute_objectives, trigger.description, trigger.name, trigger.short_description, len(trigger.effects), effects_list, trigger.effect_order, len(trigger.conditions), conditions_list, trigger.condition_order, ]))
def _parse_object( parsed_data, **kwargs ) -> UnitObject: # Expected {unit=unitStruct, player=Player} unit = kwargs['unit'] return UnitObject( player=kwargs['player'], x=find_retriever(unit.retrievers, "X position").data, y=find_retriever(unit.retrievers, "Y position").data, z=find_retriever(unit.retrievers, "Z position").data, reference_id=find_retriever(unit.retrievers, "ID").data, unit_const=find_retriever(unit.retrievers, "Unit 'constant'").data, status=find_retriever(unit.retrievers, "Status").data, rotation=find_retriever(unit.retrievers, "Rotation, in radians").data, animation_frame=find_retriever(unit.retrievers, "Initial animation frame").data, garrisoned_in_id=find_retriever(unit.retrievers, "Garrisoned in: ID").data, )
def _reconstruct_object(parsed_header, parsed_data, objects, **kwargs) -> None: # Expected {} player_units_retriever = find_retriever( parsed_data['UnitsPiece'].retrievers, "Player Units") # Todo: Move this to DataHeader new_unit_id_retriever = find_retriever( parsed_data['DataHeaderPiece'].retrievers, "Next unit ID to place") new_unit_id_retriever.data = objects[ 'UnitsObject'].get_new_reference_id() player_units_retriever.data = [] for player_units in objects['UnitsObject'].units: units_list = [] for unit in player_units: UnitObject._reconstruct_object(parsed_header, parsed_data, objects, unit=unit, units=units_list) player_units_retriever.data.append( PlayerUnitsStruct(data=[len(units_list), units_list]))
def _reconstruct_object(parsed_data, objects, **kwargs) -> None: # Expected {} player_units_retriever = find_retriever( parsed_data['UnitsPiece'].retrievers, "Player Units") player_units_retriever.data = [] for player_units in objects['UnitsObject'].units: units_list = [] for unit in player_units: UnitObject._reconstruct_object(parsed_data, objects, unit=unit, units=units_list) player_units_retriever.data.append( PlayerUnitsStruct(data=[len(units_list), units_list]))
def _parse_options_object(self): object_piece = self.parsed_data['OptionsPiece'] # ppnd: Per Player Number of Disabled ppnd_techs = find_retriever(object_piece.retrievers, "Per player number of disabled techs").data ppnd_units = find_retriever(object_piece.retrievers, "Per player number of disabled units").data ppnd_buildings = find_retriever( object_piece.retrievers, "Per player number of disabled buildings").data disabled_techs = generator.create_generator( find_retriever(object_piece.retrievers, "Disabled technology IDs in player order").data, 1) disabled_units = generator.create_generator( find_retriever(object_piece.retrievers, "Disabled unit IDs in player order").data, 1) disabled_buildings = generator.create_generator( find_retriever(object_piece.retrievers, "Disabled building IDs in player order").data, 1) disables = list() for player_id in range(0, 8): # 0-7 Players nd_techs = ppnd_techs[player_id] nd_units = ppnd_units[player_id] nd_buildings = ppnd_buildings[player_id] player_disabled_techs = generator.repeat_generator( disabled_techs, nd_techs, return_bytes=False) player_disabled_units = generator.repeat_generator( disabled_units, nd_units, return_bytes=False) player_disabled_buildings = generator.repeat_generator( disabled_buildings, nd_buildings, return_bytes=False) disables.append({ 'techs': player_disabled_techs, 'units': player_disabled_units, 'buildings': player_disabled_buildings, }) return OptionsObject( disables, find_retriever(object_piece.retrievers, "All techs").data)
def _reconstruct_object(parsed_header, parsed_data, objects, **kwargs) -> None: # Expected {} number_of_triggers_retriever = find_retriever( parsed_data['TriggerPiece'].retrievers, "Number of triggers") trigger_data_retriever = find_retriever( parsed_data['TriggerPiece'].retrievers, "Trigger data") display_order_retriever = find_retriever( parsed_data['TriggerPiece'].retrievers, "Trigger display order array") display_order_retriever.data = parser.listify( display_order_retriever.data) file_header_trigger_count_retriever = find_retriever( parsed_header['FileHeaderPiece'].retrievers, "Trigger count") number_of_variable_retriever = find_retriever( parsed_data['TriggerPiece'].retrievers, "Number of variables") variable_data_retriever = find_retriever( parsed_data['TriggerPiece'].retrievers, "Variables") trigger_data_retriever.data = [] for trigger in objects["TriggersObject"].triggers: TriggerObject._reconstruct_object(parsed_header, parsed_data, objects, trigger=trigger) variable_data_retriever.data = [] for variable in objects["TriggersObject"].variables: VariableObject._reconstruct_object( parsed_header, parsed_data, objects, variable=variable, variables=variable_data_retriever.data) assert len(trigger_data_retriever.data) == len( objects["TriggersObject"].triggers) trigger_count = len(trigger_data_retriever.data) number_of_triggers_retriever.data = trigger_count file_header_trigger_count_retriever.data = trigger_count number_of_variable_retriever.data = len(variable_data_retriever.data) # Currently not necessary due to the parser changing the 'repeated' value equal to the len(list) # trigger_data_retriever.datatype.repeat = trigger_count # display_order_retriever.datatype.repeat = trigger_count helper.update_order_array(display_order_retriever.data, trigger_count)
def _parse_object(parsed_data, **kwargs): object_piece = parsed_data['MapPiece'] map_width = find_retriever(object_piece.retrievers, "Map Width").data map_height = find_retriever(object_piece.retrievers, "Map Height").data terrain_list = find_retriever(object_piece.retrievers, "Terrain data").data # AoE2 in Game map: Left to top = X. Left to bottom = Y. Tiny map top = [X:199,Y:0] terrain = [] for i in range(0, map_width * map_height): to = TerrainObject( terrain_id=find_retriever(terrain_list[i].retrievers, "Terrain ID").data, elevation=find_retriever(terrain_list[i].retrievers, "Elevation").data ) terrain.append(to) return MapObject( map_color_mood=find_retriever(object_piece.retrievers, "Map color mood").data, collide_and_correct=find_retriever(object_piece.retrievers, "Collide and Correcting").data, map_width=map_width, map_height=map_height, terrain=terrain, )
def _parse_map_object(self): object_piece = self.parsed_data['MapPiece'] map_width = find_retriever(object_piece.retrievers, "Map Width").data map_height = find_retriever(object_piece.retrievers, "Map Height").data terrain_list = find_retriever(object_piece.retrievers, "Terrain data").data # AoE2 in Game map: Left to top = X. Left to bottom = Y. Tiny map top = [X:199,Y:0] terrain_2d = [] """ Debating to support only Py3.6+. Until then, this'll be a comment. >> terrain_2d: List[List[TerrainObject]] = [] """ for i in range(0, map_width * map_height): to = TerrainObject( terrain_id=find_retriever(terrain_list[i].retrievers, "Terrain ID").data, elevation=find_retriever(terrain_list[i].retrievers, "Elevation").data) map_x = i % map_width try: terrain_2d[map_x].append(to) except IndexError: if len(terrain_2d) <= map_x: terrain_2d.append(list()) terrain_2d[map_x].append(to) return MapObject( map_color_mood=find_retriever(object_piece.retrievers, "Map color mood").data, collide_and_correct=find_retriever(object_piece.retrievers, "Collide and Correcting").data, map_width=map_width, map_height=map_height, terrain=terrain_2d, )
def get_value(self, retriever_key): return find_retriever(self.retrievers, retriever_key).data
def _parse_player_object(self): players = [] data_header_piece = self.parsed_data['DataHeaderPiece'] unit_piece = self.parsed_data['UnitsPiece'] options_piece = self.parsed_data['OptionsPiece'] starting_ages = find_retriever(options_piece.retrievers, "Per player starting age").data # Player Data player_data_one = find_retriever( data_header_piece.retrievers, "Player data#1").data # 0-7 Players & 8 Gaia player_data_two = self.parsed_data[ 'PlayerDataTwoPiece'] # 0-7 Players & 8 Gaia resources = find_retriever(player_data_two.retrievers, "Resources").data # player_data_three = find_retriever(unit_piece.retrievers, "Player data #3").data # 0-7 Players player_data_four = find_retriever(unit_piece.retrievers, "Player data #4").data # 0-7 Players for player_id in range(0, 9): # 0-7 Players & 8 Gaia: try: # If gaia isn't saved. (PlayerDataThree and PlayerDataFour) pop_limit = find_retriever( player_data_four[player_id].retrievers, "Population limit").data except IndexError: pop_limit = -1 players.append( PlayerObject( player_number=player_id, active=find_retriever( player_data_one[player_id].retrievers, "Active").data, human=find_retriever(player_data_one[player_id].retrievers, "Human").data, civilization=find_retriever( player_data_one[player_id].retrievers, "Civilization").data, gold=find_retriever(resources[player_id].retrievers, "Gold").data, wood=find_retriever(resources[player_id].retrievers, "Wood").data, food=find_retriever(resources[player_id].retrievers, "Food").data, stone=find_retriever(resources[player_id].retrievers, "Stone").data, color=find_retriever(resources[player_id].retrievers, "Player color").data, starting_age=starting_ages[player_id], pop_limit=pop_limit)) return players
def _parse_messages_object(self): object_piece = self.parsed_data['MessagesPiece'] retrievers = object_piece.retrievers return MessagesObject( instructions=find_retriever(retrievers, "Instructions").data, hints=find_retriever(retrievers, "Hints").data, victory=find_retriever(retrievers, "Victory").data, loss=find_retriever(retrievers, "Loss").data, history=find_retriever(retrievers, "History").data, scouts=find_retriever(retrievers, "Scouts").data, ascii_instructions=find_retriever(retrievers, "ASCII Instructions").data, ascii_hints=find_retriever(retrievers, "ASCII Hints").data, ascii_victory=find_retriever(retrievers, "ASCII Victory").data, ascii_loss=find_retriever(retrievers, "ASCII Loss").data, ascii_history=find_retriever(retrievers, "ASCII History").data, ascii_scouts=find_retriever(retrievers, "ASCII Scouts").data, )
def _parse_object( parsed_data, **kwargs): # Expected {trigger=triggerStruct, trigger_id=id} trigger = kwargs['trigger'] effects_list = [] effect_structs = parser.listify( find_retriever(trigger.retrievers, "Effect data").data) for effect_struct in effect_structs: effects_list.append( EffectObject._parse_object(parsed_data, effect=effect_struct)) conditions_list = [] condition_structs = parser.listify( find_retriever(trigger.retrievers, "Condition data").data) for condition_struct in condition_structs: conditions_list.append( ConditionObject._parse_object(parsed_data, condition=condition_struct)) return TriggerObject( name=find_retriever(trigger.retrievers, "Trigger name").data, description=find_retriever(trigger.retrievers, "Trigger description").data, description_stid=find_retriever( trigger.retrievers, "Description string Table ID").data, display_as_objective=find_retriever(trigger.retrievers, "Act as objective").data, short_description=find_retriever(trigger.retrievers, "Short description").data, short_description_stid=find_retriever( trigger.retrievers, "Short description string Table ID").data, display_on_screen=find_retriever(trigger.retrievers, "Display on screen").data, description_order=find_retriever( trigger.retrievers, "Description order (in objectives)").data, enabled=find_retriever(trigger.retrievers, "Enabled").data, looping=find_retriever(trigger.retrievers, "Looping").data, header=find_retriever(trigger.retrievers, "Make header").data, mute_objectives=find_retriever(trigger.retrievers, "Mute objectives").data, conditions_list=conditions_list, condition_order=parser.listify( find_retriever(trigger.retrievers, "Condition display order array").data), effects_list=effects_list, effect_order=parser.listify( find_retriever(trigger.retrievers, "Effect display order array").data), trigger_id=kwargs['trigger_id'], )