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'],
)
