def add_condition(self,
condition_type: Condition,
amount_or_quantity=None,
resource_type_or_tribute_list=None,
unit_object=None,
next_object=None,
object_list=None,
source_player=None,
technology=None,
timer=None,
area_1_x=None,
area_1_y=None,
area_2_x=None,
area_2_y=None,
object_group=None,
object_type=None,
ai_signal=None,
inverted=None,
variable=None,
comparison=None,
target_player=None) -> ConditionObject:
condition_defaults = conditions.default_attributes[condition_type]
condition_attr = {}
for key, value in condition_defaults.items():
condition_attr[key] = (locals()[key]
if locals()[key] is not None else value)
new_cond = ConditionObject(
**conditions.default_attributes[condition_type.value])
self.conditions.append(new_cond)
helper.update_order_array(self.condition_order, len(self.conditions))
return new_cond
def add_effect(self,
effect_type: Effect,
ai_script_goal=None,
aa_quantity=None,
aa_armor_or_attack_type=None,
quantity=None,
tribute_list=None,
diplomacy=None,
number_of_units_selected=None,
object_list_unit_id=None,
source_player=None,
target_player=None,
technology=None,
string_id=None,
display_time=None,
trigger_id=None,
location_x=None,
location_y=None,
location_object_reference=None,
area_1_x=None,
area_1_y=None,
area_2_x=None,
area_2_y=None,
object_group=None,
object_type=None,
instruction_panel_position=None,
attack_stance=None,
time_unit=None,
enabled_or_victory=None,
food=None,
wood=None,
stone=None,
gold=None,
item_id=None,
flash_object=None,
force_research_technology=None,
visibility_state=None,
scroll=None,
operation=None,
object_list_unit_id_2=None,
button_location=None,
ai_signal_value=None,
object_attributes=None,
from_variable=None,
variable_or_timer=None,
facet=None,
play_sound=None,
message=None,
sound_name=None,
selected_object_ids=None) -> EffectObject:
effect_defaults = effects.default_attributes[effect_type]
effect_attr = {}
for key, value in effect_defaults.items():
effect_attr[key] = (locals()[key]
if locals()[key] is not None else value)
new_effect = EffectObject(**{**effect_defaults, **effect_attr})
self.effects.append(new_effect)
helper.update_order_array(self.effect_order, len(self.effects))
return new_effect
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 _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 _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 effect_order(self):
if helper.list_changed(self.effects, self._effect_hash):
helper.update_order_array(self._effect_order, len(self.effects))
self._effect_hash = helper.hash_list(self.effects)
return self._effect_order
def condition_order(self):
if helper.list_changed(self.conditions, self._condition_hash):
helper.update_order_array(self._condition_order,
len(self.conditions))
self._condition_hash = helper.hash_list(self.conditions)
return self._condition_order
def add_trigger(self, name) -> TriggerObject:
new_trigger = TriggerObject(name=name, trigger_id=len(self.trigger_data))
self.trigger_data.append(new_trigger)
helper.update_order_array(self.trigger_display_order, len(self.trigger_data))
return new_trigger
def trigger_display_order(self):
if helper.list_changed(self.triggers, self._trigger_hash):
helper.update_order_array(self._trigger_display_order,
len(self.triggers))
self._trigger_hash = helper.hash_list(self.triggers)
return self._trigger_display_order
def add_condition(self, condition_type: Condition):
new_cond = ConditionObject(
**conditions.default_attributes[condition_type.value])
self.conditions.append(new_cond)
helper.update_order_array(self.condition_order, len(self.conditions))
return new_cond
def add_effect(self, effect_type: Effect):
new_effect = EffectObject(
**effects.default_attributes[effect_type.value])
self.effects.append(new_effect)
helper.update_order_array(self.effect_order, len(self.effects))
return new_effect
def add_condition(self, condition_type):
new_cond = ConditionObject(condition_type)
self.conditions.append(new_cond)
helper.update_order_array(self.condition_order, len(self.conditions))
return new_cond
def add_effect(self, effect_type):
new_effect = EffectObject(effect_type)
self.effects.append(new_effect)
helper.update_order_array(self.effect_order, len(self.effects))
return new_effect
