refactor: verbessere die Verantwortung der Trefferpunkte-Verarbeitung

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):
-        self._type = type
+    def __init__(self, item_type: ItemTypes):
+        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):
-        super().__init__(type)
+    def __init__(self, item_type: ItemTypes, tonnage: float):
+        super().__init__(item_type)
         self._tonnage = tonnage
 
     @property
@@ -99,23 +99,68 @@ class Sustainment(Item):
         super().__init__(ItemTypes.SUSTAINMENT)
 
 
-class Area:
-    _content: dict[str, Any]
+class Zone:
 
     def __init__(self):
-        self.__dict__['_content'] = {
-                'children':    [],
-                'items':       {},
-                'armor':       0,
-                'inner_armor': 0,
-                'state':       AreaStatus.FINE,
-                }
+        self.__dict__['_armor'] = 0
+        self.__dict__['_parent']= None
+        self.__dict__['_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):
-        area = self._inner_structure.areas.get(area_name)
-        if area.armor > hits:
-            area.armor -= hits
-            return
-        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
+    def strike(self, zone_name: ZoneNames, hits: int) -> StrikeEvent:
+        zone = self._inner_structure.zones.get(zone_name)
+        if zone is None:
+            raise Exception(f"Zone {zone_name} not found")
+        return StrikeEvent(zone, hits)