convert: Refactor AoCUpgradeAbilitySubprocessor into separate files.

Author: heinezen

openage/convert/processor/conversion/aoc/CMakeLists.txt

@@ -29,3 +29,6 @@ add_subdirectory(nyan)
 add_subdirectory(pregen)
 add_subdirectory(resistance)
 add_subdirectory(tech)
+add_subdirectory(upgrade_ability)
+add_subdirectory(upgrade_effect)
+add_subdirectory(upgrade_resistance)

openage/convert/processor/conversion/aoc/ability/util.py

@@ -17,7 +17,6 @@
 if typing.TYPE_CHECKING:
     from .....entity_object.conversion.aoc.genie_civ import GenieCivilizationGroup
     from .....entity_object.conversion.aoc.genie_unit import GenieGameEntityGroup
-    from .....value_object.conversion.forward_ref import ForwardRef
 
 
 def create_animation(

openage/convert/processor/conversion/aoc/upgrade_ability/CMakeLists.txt

@@ -0,0 +1,18 @@
+add_py_modules(
+    __init__.py
+    apply_continuous_effect.py
+    apply_discrete_effect.py
+    attribute_change_tracker.py
+    death.py
+    despawn.py
+    idle.py
+    line_of_sight.py
+    live.py
+    move.py
+    named.py
+    resistance.py
+    selectable.py
+    shoot_projectile.py
+    turn.py
+    util.py
+)

openage/convert/processor/conversion/aoc/upgrade_ability/__init__.py

@@ -0,0 +1,5 @@
+# Copyright 2025-2025 the openage authors. See copying.md for legal info.
+
+"""
+Create nyan patches for upgrading abilities of AoC entities.
+"""

openage/convert/processor/conversion/aoc/upgrade_ability/apply_continuous_effect.py

@@ -0,0 +1,243 @@
+# Copyright 2025-2025 the openage authors. See copying.md for legal info.
+
+"""
+Create patches for upgrading the ApplyContinuousEffect ability.
+"""
+from __future__ import annotations
+import typing
+
+from ......nyan.nyan_structs import MemberOperator
+from .....entity_object.conversion.aoc.genie_unit import GenieBuildingLineGroup
+from .....entity_object.conversion.converter_object import RawAPIObject
+from .....service.conversion import internal_name_lookups
+from .....value_object.conversion.forward_ref import ForwardRef
+from .....value_object.read.value_members import NoDiffMember
+from .util import create_animation_patch, create_command_sound_patch
+
+if typing.TYPE_CHECKING:
+    from .....entity_object.conversion.converter_object import ConverterObject, \
+        ConverterObjectGroup
+    from .....entity_object.conversion.aoc.genie_unit import GenieGameEntityGroup
+
+
+def apply_continuous_effect_ability(
+    converter_group: ConverterObjectGroup,
+    line: GenieGameEntityGroup,
+    container_obj_ref: str,
+    command_id: int,
+    ranged: bool = False,
+    diff: ConverterObject = None
+) -> list[ForwardRef]:
+    """
+    Creates a patch for the ApplyContinuousEffect ability of a line.
+
+    :param converter_group: Group that gets the patch.
+    :param line: Unit/Building line that has the ability.
+    :param container_obj_ref: Reference of the raw API object the patch is nested in.
+    :param command_id: The command ID of the AoC command.
+    :param ranged: Whether the ability is a ranged attack.
+    :param diff: A diff between two ConvertObject instances.
+    :returns: The forward references for the generated patches.
+    """
+    head_unit_id = line.get_head_unit_id()
+    tech_id = converter_group.get_id()
+    dataset = line.data
+
+    patches = []
+
+    name_lookup_dict = internal_name_lookups.get_entity_lookups(dataset.game_version)
+    tech_lookup_dict = internal_name_lookups.get_tech_lookups(dataset.game_version)
+    command_lookup_dict = internal_name_lookups.get_command_lookups(dataset.game_version)
+
+    game_entity_name = name_lookup_dict[head_unit_id][0]
+    ability_name = command_lookup_dict[command_id][0]
+
+    data_changed = False
+    diff_animation = diff["attack_sprite_id"]
+    diff_comm_sound = diff["command_sound_id"]
+    diff_frame_delay = diff["frame_delay"]
+    if any(not isinstance(value, NoDiffMember) for value in (diff_frame_delay)):
+        data_changed = True
+
+    # Command types Heal, Construct, Repair are not upgraded by lines
+
+    if ranged:
+        diff_min_range = diff["weapon_range_min"]
+        diff_max_range = diff["weapon_range_max"]
+
+        if any(not isinstance(value, NoDiffMember) for value in (
+            diff_min_range,
+            diff_max_range
+        )):
+            patch_target_ref = f"{game_entity_name}.{ability_name}.Ranged"
+            patch_target_forward_ref = ForwardRef(line, patch_target_ref)
+
+            # Wrapper
+            wrapper_name = f"Change{game_entity_name}{ability_name}RangedWrapper"
+            wrapper_ref = f"{container_obj_ref}.{wrapper_name}"
+            wrapper_raw_api_object = RawAPIObject(wrapper_ref,
+                                                  wrapper_name,
+                                                  dataset.nyan_api_objects)
+            wrapper_raw_api_object.add_raw_parent("engine.util.patch.Patch")
+
+            if isinstance(line, GenieBuildingLineGroup):
+                wrapper_raw_api_object.set_location(("data/game_entity/generic/"
+                                                    f"{name_lookup_dict[head_unit_id][1]}/"))
+                wrapper_raw_api_object.set_filename(f"{tech_lookup_dict[tech_id][1]}_upgrade")
+
+            else:
+                wrapper_raw_api_object.set_location(ForwardRef(converter_group,
+                                                               container_obj_ref))
+
+            # Nyan patch
+            nyan_patch_name = f"Change{game_entity_name}{ability_name}Ranged"
+            nyan_patch_ref = ForwardRef(line, nyan_patch_name)
+            nyan_patch_location = ForwardRef(converter_group, wrapper_ref)
+            nyan_patch_raw_api_object = RawAPIObject(nyan_patch_ref,
+                                                     nyan_patch_name,
+                                                     dataset.nyan_api_objects,
+                                                     nyan_patch_location)
+            nyan_patch_raw_api_object.add_raw_parent("engine.util.patch.NyanPatch")
+            nyan_patch_raw_api_object.set_patch_target(patch_target_forward_ref)
+
+            if not isinstance(diff_min_range, NoDiffMember):
+                min_range = diff_min_range.value
+                nyan_patch_raw_api_object.add_raw_patch_member(
+                    "min_range",
+                    min_range,
+                    "engine.ability.property.type.Ranged",
+                    MemberOperator.ADD)
+
+            if not isinstance(diff_max_range, NoDiffMember):
+                max_range = diff_max_range.value
+                nyan_patch_raw_api_object.add_raw_patch_member(
+                    "max_range",
+                    max_range,
+                    "engine.ability.property.type.Ranged",
+                    MemberOperator.ADD)
+
+            patch_forward_ref = ForwardRef(converter_group, nyan_patch_ref)
+            wrapper_raw_api_object.add_raw_member("patch",
+                                                  patch_forward_ref,
+                                                  "engine.util.patch.Patch")
+
+            converter_group.add_raw_api_object(wrapper_raw_api_object)
+            converter_group.add_raw_api_object(nyan_patch_raw_api_object)
+
+            wrapper_forward_ref = ForwardRef(converter_group, wrapper_ref)
+            patches.append(wrapper_forward_ref)
+
+    if not isinstance(diff_animation, NoDiffMember):
+        diff_animation_id = diff_animation.value
+
+        # Nyan patch
+        patch_target_ref = f"{game_entity_name}.{ability_name}"
+        nyan_patch_name = f"Change{game_entity_name}{ability_name}"
+        wrapper, anim_patch_forward_ref = create_animation_patch(
+            converter_group,
+            line,
+            patch_target_ref,
+            nyan_patch_name,
+            container_obj_ref,
+            ability_name,
+            f"{command_lookup_dict[command_id][1]}_",
+            [diff_animation_id]
+        )
+        patches.append(anim_patch_forward_ref)
+
+        if isinstance(line, GenieBuildingLineGroup):
+            # Store building upgrades next to their game entity definition,
+            # not in the Age up techs.
+            wrapper.set_location(("data/game_entity/generic/"
+                                  f"{name_lookup_dict[head_unit_id][1]}/"))
+            wrapper.set_filename(f"{tech_lookup_dict[tech_id][1]}_upgrade")
+
+    if not isinstance(diff_comm_sound, NoDiffMember):
+        diff_comm_sound_id = diff_comm_sound.value
+
+        # Nyan patch
+        patch_target_ref = f"{game_entity_name}.{ability_name}"
+        nyan_patch_name = f"Change{game_entity_name}{ability_name}"
+        wrapper, sound_patch_forward_ref = create_command_sound_patch(
+            converter_group,
+            line,
+            patch_target_ref,
+            nyan_patch_name,
+            container_obj_ref,
+            ability_name,
+            f"{command_lookup_dict[command_id][1]}_",
+            [diff_comm_sound_id]
+        )
+        patches.append(sound_patch_forward_ref)
+
+        if isinstance(line, GenieBuildingLineGroup):
+            # Store building upgrades next to their game entity definition,
+            # not in the Age up techs.
+            wrapper.set_location(("data/game_entity/generic/"
+                                  f"{name_lookup_dict[head_unit_id][1]}/"))
+            wrapper.set_filename(f"{tech_lookup_dict[tech_id][1]}_upgrade")
+
+    if data_changed:
+        patch_target_ref = f"{game_entity_name}.{ability_name}"
+        patch_target_forward_ref = ForwardRef(line, patch_target_ref)
+
+        # Wrapper
+        wrapper_name = f"Change{game_entity_name}{ability_name}Wrapper"
+        wrapper_ref = f"{container_obj_ref}.{wrapper_name}"
+        wrapper_raw_api_object = RawAPIObject(wrapper_ref,
+                                              wrapper_name,
+                                              dataset.nyan_api_objects)
+        wrapper_raw_api_object.add_raw_parent("engine.util.patch.Patch")
+
+        if isinstance(line, GenieBuildingLineGroup):
+            # Store building upgrades next to their game entity definition,
+            # not in the Age up techs.
+            wrapper_raw_api_object.set_location(("data/game_entity/generic/"
+                                                 f"{name_lookup_dict[head_unit_id][1]}/"))
+            wrapper_raw_api_object.set_filename(f"{tech_lookup_dict[tech_id][1]}_upgrade")
+
+        else:
+            wrapper_raw_api_object.set_location(ForwardRef(converter_group, container_obj_ref))
+
+        # Nyan patch
+        nyan_patch_name = f"Change{game_entity_name}{ability_name}"
+        nyan_patch_ref = f"{container_obj_ref}.{wrapper_name}.{nyan_patch_name}"
+        nyan_patch_location = ForwardRef(converter_group, wrapper_ref)
+        nyan_patch_raw_api_object = RawAPIObject(nyan_patch_ref,
+                                                 nyan_patch_name,
+                                                 dataset.nyan_api_objects,
+                                                 nyan_patch_location)
+        nyan_patch_raw_api_object.add_raw_parent("engine.util.patch.NyanPatch")
+        nyan_patch_raw_api_object.set_patch_target(patch_target_forward_ref)
+
+        if not isinstance(diff_frame_delay, NoDiffMember):
+            if not isinstance(diff_animation, NoDiffMember):
+                attack_graphic_id = diff_animation.value
+
+            else:
+                attack_graphic_id = diff_animation.ref.value
+
+            attack_graphic = dataset.genie_graphics[attack_graphic_id]
+            frame_rate = attack_graphic.get_frame_rate()
+            frame_delay = diff_frame_delay.value
+            application_delay = frame_rate * frame_delay
+
+            nyan_patch_raw_api_object.add_raw_patch_member(
+                "application_delay",
+                application_delay,
+                "engine.ability.type.ApplyContinuousEffect",
+                MemberOperator.ASSIGN
+            )
+
+        patch_forward_ref = ForwardRef(converter_group, nyan_patch_ref)
+        wrapper_raw_api_object.add_raw_member("patch",
+                                              patch_forward_ref,
+                                              "engine.util.patch.Patch")
+
+        converter_group.add_raw_api_object(wrapper_raw_api_object)
+        converter_group.add_raw_api_object(nyan_patch_raw_api_object)
+
+        wrapper_forward_ref = ForwardRef(converter_group, wrapper_ref)
+        patches.append(wrapper_forward_ref)
+
+    return patches