def reconstruct_object(parsed_data, objects, **kwargs): # 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"].data_dict['trigger_data']:
TriggerObject.reconstruct_object(parsed_data,
objects,
trigger=trigger)
assert len(trigger_data_retriever.data) == len(
objects["TriggersObject"].data_dict['trigger_data'])
trigger_count = len(trigger_data_retriever.data)
number_of_triggers_retriever.data = trigger_count
# Currently not necessary due to the parser setting repeated equal to list length
# trigger_data_retriever.datatype.repeat = trigger_count
# display_order_retriever.datatype.repeat = trigger_count
display_order_retriever.data = parser.listify(
display_order_retriever.data)
helper.update_order_array(display_order_retriever.data, trigger_count)
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_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_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): # 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)
triggers = []
for trigger in trigger_data:
triggers.append(
TriggerObject.parse_object(parsed_data, trigger=trigger))
return TriggersObject(trigger_data=triggers,
trigger_display_order=display_order)
def parse_object(parsed_data, **kwargs):
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 = 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))
return UnitsObject(units=player_units)
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 = []
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 _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 != "Check, (21)":
if retriever.name == "Condition Type":
print("],\n" + str(retriever.data) + ": [")
print("\t\"" + str(retriever.name) + "\",")
print("]\n")
def _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 != "Check, (46)":
if retriever.name == "Effect type":
print("],\n" + str(retriever.data) + ": [")
print("\t\"" + str(retriever.name) + "\",")
print("]\n")
def parse_object(parsed_data, **kwargs): # Expected {unit=unitStruct}
unit = kwargs['unit']
return UnitObject(
x=find_retriever(unit.retrievers, "X position").data,
y=find_retriever(unit.retrievers, "Y position").data,
z=find_retriever(unit.retrievers, "Z position").data,
id_on_map=find_retriever(unit.retrievers, "ID").data,
unit_id=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_data, objects,
**kwargs): # Expected {trigger=triggerStruct}
trigger_data_retriever = find_retriever(
parsed_data['TriggerPiece'].retrievers, "Trigger data")
trigger = kwargs['trigger']
effects = []
for effect_obj in trigger.data_dict['effects']:
data_list = list(effect_obj.data_dict.values())
data_list.insert(1, 46) # Check, (46)
data_list.insert(9, 0) # Unknown
data_list.insert(15, 0) # Unknown2
data_list.insert(43, 0) # Unknown3
data_list.insert(48, 0) # Unknown4
effects.append(EffectStruct(data=data_list))
conditions = []
for condition_obj in trigger.data_dict['conditions']:
data_list = list(condition_obj.data_dict.values())
data_list.insert(1, 21) # Check, (21)
data_list.insert(10, 0) # Unknown
data_list.insert(19, 0) # Unknown (3)
conditions.append(ConditionStruct(data=data_list))
trigger_data_retriever.data.append(
TriggerStruct(data=[
trigger.data_dict['enabled'],
trigger.data_dict['looping'],
trigger.data_dict['description_stid'],
trigger.data_dict['display_as_objective'],
trigger.data_dict['description_order'],
trigger.data_dict['header'],
trigger.data_dict['short_description_stid'],
trigger.data_dict['display_on_screen'],
b'\x00\x00\x00\x00\x00', # Unknown
trigger.data_dict['mute_objectives'],
trigger.data_dict['description'],
trigger.data_dict['name'],
trigger.data_dict['short_description'],
len(trigger.data_dict['effects']),
effects,
trigger.data_dict['effect_order'],
len(trigger.data_dict['conditions']),
conditions,
trigger.data_dict['condition_order'],
]))
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 get_value(self, retriever_key):
return find_retriever(self.retrievers, retriever_key).data
def parse_object(parsed_data,
**kwargs): # Expected {trigger=triggerStruct}
trigger = kwargs['trigger']
effects = []
effect_structs = parser.listify(
find_retriever(trigger.retrievers, "Effect data").data)
for effect_struct in effect_structs:
effect_type = find_retriever(effect_struct.retrievers,
"Effect type").data
parameters = effect.parameters.get(effect_type)
parameter_dict = copy.copy(effect.empty_parameters)
for param in parameters:
inverted_name = effect.naming_conversion.get(param)
parameter_dict[inverted_name] = find_retriever(
effect_struct.retrievers, param).data
effects.append(EffectObject(**parameter_dict))
conditions = []
condition_structs = parser.listify(
find_retriever(trigger.retrievers, "Condition data").data)
for condition_struct in condition_structs:
condition_type = find_retriever(condition_struct.retrievers,
"Condition type").data
parameters = condition.parameters.get(condition_type)
parameter_dict = copy.copy(condition.empty_parameters)
for param in parameters:
inverted_name = condition.naming_conversion.get(param)
parameter_dict[inverted_name] = find_retriever(
condition_struct.retrievers, param).data
conditions.append(ConditionObject(**parameter_dict))
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=conditions,
condition_order=find_retriever(
trigger.retrievers, "Condition display order array").data,
effects=effects,
effect_order=find_retriever(trigger.retrievers,
"Effect display order array").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 as e:
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,
)
