refactor: verbessere die Verantwortung der Trefferpunkte-Verarbeitung

MechFabrik/__init__.py

@@ -1,6 +1,7 @@
-from MechFabrik.bauteile import Activator, Joint, Mech, InnerStructure, Gyroskope, Area, AreaNames, Cockpit, Reaktor, \
+from MechFabrik.bauteile import Activator, Joint, Mech, InnerStructure, Gyroskope, Area, AreaNames, Cockpit, OuterAmor, \
+    Reaktor, \
     Sensors, \
-    Sustainment
+    Sustainment, ZoneNames
 from MechFabrik.reader import ComponentReader
 
 
@@ -20,6 +21,19 @@ class MechFabrik(object):
                 AreaNames.LEFT_LEG:     Area(),
                 AreaNames.RIGHT_LEG:    Area(),
                 }
+        self.__zones = {
+                ZoneNames.HEAD:               OuterAmor(self.__areas[AreaNames.HEAD]),
+                ZoneNames.MIDDLE_TORSO_FRONT: OuterAmor(self.__areas[AreaNames.MIDDLE_TORSO]),
+                ZoneNames.MIDDLE_TORSO_REAR:  OuterAmor(self.__areas[AreaNames.MIDDLE_TORSO]),
+                ZoneNames.LEFT_TORSO_FRONT:   OuterAmor(self.__areas[AreaNames.LEFT_TORSO]),
+                ZoneNames.LEFT_TORSO_REAR:    OuterAmor(self.__areas[AreaNames.LEFT_TORSO]),
+                ZoneNames.RIGHT_TORSO_FRONT:  OuterAmor(self.__areas[AreaNames.RIGHT_TORSO]),
+                ZoneNames.RIGHT_TORSO_REAR:   OuterAmor(self.__areas[AreaNames.RIGHT_TORSO]),
+                ZoneNames.LEFT_ARM:           OuterAmor(self.__areas[AreaNames.LEFT_ARM]),
+                ZoneNames.RIGHT_ARM:          OuterAmor(self.__areas[AreaNames.RIGHT_ARM]),
+                ZoneNames.LEFT_LEG:           OuterAmor(self.__areas[AreaNames.LEFT_LEG]),
+                ZoneNames.RIGHT_LEG:          OuterAmor(self.__areas[AreaNames.RIGHT_LEG]),
+                }
         self.__build_inner_structure(tonnage, movement_rate)
         self._mech = Mech(name, tonnage, movement_rate, self._inner_structure)
 
@@ -41,7 +55,8 @@ class MechFabrik(object):
                 (1, 5): Sensors(),
                 (1, 6): Sustainment(),
                 }
-        self.__areas[AreaNames.HEAD].inner_armor = 3
+        self.__areas[AreaNames.HEAD].armor = 3
+        self.__areas[AreaNames.HEAD].parent = self.__areas[AreaNames.MIDDLE_TORSO]
 
     def __build_middle_torso_area(self, gyroscope: Gyroskope) -> None:
         self.__areas[AreaNames.LEFT_TORSO].parent = self.__areas[AreaNames.MIDDLE_TORSO]
@@ -66,13 +81,13 @@ class MechFabrik(object):
                 (2, 5): None,
                 (2, 6): None,
                 }
-        self.__areas[AreaNames.MIDDLE_TORSO].inner_armor = self.__components.inner_amor_for_tonnage_and_area(
+        self.__areas[AreaNames.MIDDLE_TORSO].armor = self.__components.inner_amor_for_tonnage_and_area(
                 self.__tonnage,
                 AreaNames.MIDDLE_TORSO
                 )
-        self.__areas[AreaNames.LEFT_TORSO].inner_armor = self.__components.inner_amor_for_tonnage_and_area(
+        self.__areas[AreaNames.LEFT_TORSO].armor = self.__components.inner_amor_for_tonnage_and_area(
                 self.__tonnage, AreaNames.LEFT_TORSO)
-        self.__areas[AreaNames.RIGHT_TORSO].inner_armor = self.__components.inner_amor_for_tonnage_and_area(
+        self.__areas[AreaNames.RIGHT_TORSO].armor = self.__components.inner_amor_for_tonnage_and_area(
                 self.__tonnage,
                 AreaNames.RIGHT_TORSO
                 )
@@ -97,10 +112,9 @@ class MechFabrik(object):
                 (2, 5): None,
                 (2, 6): None,
                 }
-        self.__areas[index].inner_armor = self.__components.inner_amor_for_tonnage_and_area(self.__tonnage, index)
+        self.__areas[index].armor = self.__components.inner_amor_for_tonnage_and_area(self.__tonnage, index)
         parent.children.append(self.__areas[index])
 
-
     def __build_leg(self, parent: Area, index: AreaNames):
         self.__areas[index].parent = parent
         self.__areas[index].items = {
@@ -111,28 +125,38 @@ class MechFabrik(object):
                 (1, 5): None,
                 (1, 6): None,
                 }
-        self.__areas[index].inner_armor = self.__components.inner_amor_for_tonnage_and_area(self.__tonnage, index)
+        self.__areas[index].armor = self.__components.inner_amor_for_tonnage_and_area(self.__tonnage, index)
         parent.children.append(self.__areas[index])
 
     def auslieferung(self) -> Mech:
         for (index, area) in self.__areas.items():
             self._inner_structure.add_area(index, area)
+        for (index, outer_amor) in self.__zones.items():
+            self._inner_structure.add_zone(index, outer_amor)
         return self._mech
 
     def set_head_armor(self, armor: int) -> None:
-        self.__areas[AreaNames.HEAD].armor = armor
+        self.__set_outer_armor(armor, ZoneNames.HEAD, AreaNames.HEAD)
 
-    def set_middle_torso_armor(self, armor: int) -> None:
+    def set_middle_torso_armor(self, armor_front: int, amor_rear: int) -> None:
-        self.__areas[AreaNames.MIDDLE_TORSO].armor = armor
+        self.__set_outer_armor(armor_front, ZoneNames.MIDDLE_TORSO_FRONT, AreaNames.MIDDLE_TORSO)
+        self.__set_outer_armor(amor_rear, ZoneNames.MIDDLE_TORSO_REAR, AreaNames.MIDDLE_TORSO)
 
-    def set_side_torso_armor(self, armor: int) -> None:
+    def set_side_torso_armor(self, armor_front: int, amor_rear: int) -> None:
-        self.__areas[AreaNames.RIGHT_TORSO].armor = armor
+        self.__set_outer_armor(armor_front, ZoneNames.LEFT_TORSO_FRONT, AreaNames.LEFT_TORSO)
-        self.__areas[AreaNames.LEFT_TORSO].armor = armor
+        self.__set_outer_armor(amor_rear, ZoneNames.LEFT_TORSO_REAR, AreaNames.LEFT_TORSO)
+        self.__set_outer_armor(armor_front, ZoneNames.RIGHT_TORSO_FRONT, AreaNames.RIGHT_TORSO)
+        self.__set_outer_armor(amor_rear, ZoneNames.RIGHT_TORSO_REAR, AreaNames.RIGHT_TORSO)
 
     def set_arm_armor(self, armor: int) -> None:
-        self.__areas[AreaNames.RIGHT_ARM].armor = armor
+        self.__set_outer_armor(armor, ZoneNames.LEFT_ARM, AreaNames.LEFT_ARM)
-        self.__areas[AreaNames.LEFT_ARM].armor = armor
+        self.__set_outer_armor(armor, ZoneNames.RIGHT_ARM, AreaNames.RIGHT_ARM)
 
     def set_leg_armor(self, armor: int) -> None:
-        self.__areas[AreaNames.RIGHT_LEG].armor = armor
+        self.__set_outer_armor(armor, ZoneNames.LEFT_LEG, AreaNames.LEFT_LEG)
-        self.__areas[AreaNames.LEFT_LEG].armor = armor
+        self.__set_outer_armor(armor, ZoneNames.RIGHT_LEG, AreaNames.RIGHT_LEG)
+
+    def __set_outer_armor(self, armor: int, zone_name: ZoneNames, parent_name: AreaNames) -> None:
+        self.__zones[zone_name].armor = armor
+        self.__zones[zone_name].parent = self.__areas[parent_name]
+        self.__areas[parent_name].outer_amor.append(self.__zones[zone_name])

MechFabrik/bauteile/__init__.py

@@ -29,7 +29,7 @@ class AreaNames(enum.Enum):
 
 class AreaStatus(enum.Flag):
     FINE = 0
-    CRITICAL_STRIKE = 1
+    DAMAGED = 1
     DESTROYED = 2
 
 
@@ -44,8 +44,8 @@ class ItemTypes(enum.Enum):
 
 
 class Item(object):
-    def __init__(self, type: ItemTypes):
+    def __init__(self, item_type: ItemTypes):
-        self._type = type
+        self._type = item_type
 
     @property
     def type(self):
@@ -54,8 +54,8 @@ class Item(object):
 
 class BigItem(Item):
 
-    def __init__(self, type: ItemTypes, tonnage: float):
+    def __init__(self, item_type: ItemTypes, tonnage: float):
-        super().__init__(type)
+        super().__init__(item_type)
         self._tonnage = tonnage
 
     @property
@@ -99,23 +99,68 @@ class Sustainment(Item):
         super().__init__(ItemTypes.SUSTAINMENT)
 
 
-class Area:
+class Zone:
-    _content: dict[str, Any]
 
     def __init__(self):
-        self.__dict__['_content'] = {
+        self.__dict__['_armor'] = 0
-                'children':    [],
+        self.__dict__['_parent']= None
-                'items':       {},
+        self.__dict__['_state']= AreaStatus.FINE
-                'armor':       0,
-                'inner_armor': 0,
-                'state':       AreaStatus.FINE,
-                }
 
     def __setattr__(self, key, value):
-        self.__dict__['_content'][key] = value
+        self.__dict__['_' + key] = value
 
     def __getattr__(self, item):
-        return self.__dict__['_content'].get(item)
+        return self.__dict__['_' + item]
+
+
+class Area(Zone):
+
+    def __init__(self):
+        super().__init__()
+        self.__dict__['_outer_amor']= list()
+        self.__dict__['_children']= list()
+        self.__dict__['_items']= dict()
+
+
+class OuterAmor(Zone):
+
+    def __init__(self, area: Area):
+        super().__init__()
+        self.__dict__['_parent']= area
+        self.__dict__['_area']= area
+
+
+class StrikeEvent:
+    def __init__(self, zone: Zone, hits: int):
+        self._zone = zone
+        self._hits = hits
+
+    @property
+    def zone(self) -> Zone:
+        return self._zone
+
+    @property
+    def hits(self) -> int:
+        return self._hits
+
+    @hits.setter
+    def hits(self, hits: int):
+        self._hits = hits
+
+    def process_event(self) -> StrikeEvent:
+        while self.hits > 0:
+            if self.hits >= self.zone.armor:
+                self.hits -= self.zone.armor
+                self.zone.armor = 0
+                self.zone.state = AreaStatus.DESTROYED
+                if self.hits > 0:
+                    self._zone = self.zone.parent
+            else:
+                self.zone.armor -= self.hits
+                self.zone.state = AreaStatus.DAMAGED
+                self.hits = 0
+                break
+        return self
 
 
 class Gyroskope:
@@ -133,6 +178,7 @@ class InnerStructure:
         self._gyroskope = gyroskope
         self._tonnage = tonnage
         self._areas = dict()
+        self._zones = dict()
 
     @property
     def tonnage(self) -> float:
@@ -143,12 +189,19 @@ class InnerStructure:
         return self._gyroskope
 
     @property
-    def areas(self) -> dict:
+    def areas(self) -> dict[AreaNames, Area]:
         return self._areas
 
     def add_area(self, index: AreaNames, area: Area):
         self._areas[index] = area
 
+    @property
+    def zones(self) -> dict[ZoneNames, Zone]:
+        return self._zones
+
+    def add_zone(self, index: ZoneNames, zone: Zone):
+        self._zones[index] = zone
+
 
 class Mech(object):
 
@@ -177,16 +230,8 @@ class Mech(object):
     def set_item(self, key: tuple, item: Item):
         pass
 
-    def strike(self, area_name, hits: int):
+    def strike(self, zone_name: ZoneNames, hits: int) -> StrikeEvent:
-        area = self._inner_structure.areas.get(area_name)
+        zone = self._inner_structure.zones.get(zone_name)
-        if area.armor > hits:
+        if zone is None:
-            area.armor -= hits
+            raise Exception(f"Zone {zone_name} not found")
-            return
+        return StrikeEvent(zone, hits)
-        hits_rest = hits - area.armor
-        if area.inner_armor > hits_rest:
-            area.inner_armor -= hits_rest
-            area.armor = 0
-            area.state = AreaStatus.CRITICAL_STRIKE
-        else:
-            area.state = AreaStatus.DESTROYED
-            area.inner_armor = 0