Merge pull request 'weight_watch' (#5) from weight_watch into main

Reviewed-on: https://git.torsten-hettstedt.de:3000/TorstenHettstedt/BattleTech/pulls/5

MechFabrik/__init__.py

@@ -1,161 +0,0 @@
-from Hangar.mech import Mech
-from MechFabrik.bauteile import InnerStructure, Gyroskope, Area, AreaNames, OuterAmor, ZoneNames
-from MechFabrik.bauteile.items import Activator, Cockpit, Joint, Reaktor, Sensors, Sustainment
-from MechFabrik.reader import ComponentReader
-
-
-class MechFabrik(object):
-
-    def __init__(self, name: str, tonnage: float, movement_rate: int):
-        self.__components = ComponentReader()
-        self.__tonnage = tonnage
-        self.__reactor_value = int(movement_rate * tonnage)
-        self.__areas = {
-                AreaNames.HEAD:         Area(),
-                AreaNames.MIDDLE_TORSO: Area(),
-                AreaNames.LEFT_TORSO:   Area(),
-                AreaNames.RIGHT_TORSO:  Area(),
-                AreaNames.LEFT_ARM:     Area(),
-                AreaNames.RIGHT_ARM:    Area(),
-                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)
-
-    def __build_inner_structure(self, tonnage: float, movement_rate: int) -> None:
-        reactor_value = int(movement_rate * tonnage)
-        gyroscope = Gyroskope(float(round(reactor_value / 100)))
-        self._inner_structure = InnerStructure(self.__components.inner_structure_from(tonnage), gyroscope)
-        self.__build_head_area()
-        self.__build_middle_torso_area(gyroscope)
-
-    def __build_head_area(self) -> None:
-        cockpit = Cockpit()
-        self.__areas[AreaNames.HEAD].cockpit = cockpit
-        self.__areas[AreaNames.HEAD].items = {
-                (1, 1): Sustainment(),
-                (1, 2): Sensors(),
-                (1, 3): cockpit,
-                (1, 4): None,
-                (1, 5): Sensors(),
-                (1, 6): Sustainment(),
-                }
-        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]
-        self.__areas[AreaNames.RIGHT_TORSO].parent = self.__areas[AreaNames.MIDDLE_TORSO]
-        reactor = Reaktor(self.__reactor_value, self.__components.reactor_tonnage_from(self.__reactor_value))
-        self.__areas[AreaNames.MIDDLE_TORSO].reactor = reactor
-        self.__areas[AreaNames.MIDDLE_TORSO].children = [
-                self.__areas[AreaNames.RIGHT_TORSO],
-                self.__areas[AreaNames.LEFT_TORSO]
-                ]
-        self.__areas[AreaNames.MIDDLE_TORSO].items = {
-                (1, 1): reactor,
-                (1, 2): reactor,
-                (1, 3): reactor,
-                (1, 4): gyroscope,
-                (1, 5): gyroscope,
-                (1, 6): gyroscope,
-                (2, 1): gyroscope,
-                (2, 2): reactor,
-                (2, 3): reactor,
-                (2, 4): reactor,
-                (2, 5): None,
-                (2, 6): None,
-                }
-        self.__areas[AreaNames.MIDDLE_TORSO].armor = self.__components.inner_amor_for_tonnage_and_area(
-                self.__tonnage,
-                AreaNames.MIDDLE_TORSO
-                )
-        self.__areas[AreaNames.LEFT_TORSO].armor = self.__components.inner_amor_for_tonnage_and_area(
-                self.__tonnage, AreaNames.LEFT_TORSO)
-        self.__areas[AreaNames.RIGHT_TORSO].armor = self.__components.inner_amor_for_tonnage_and_area(
-                self.__tonnage,
-                AreaNames.RIGHT_TORSO
-                )
-        self.__build_arm(self.__areas[AreaNames.RIGHT_TORSO], AreaNames.RIGHT_ARM)
-        self.__build_leg(self.__areas[AreaNames.RIGHT_TORSO], AreaNames.RIGHT_LEG)
-        self.__build_arm(self.__areas[AreaNames.LEFT_TORSO], AreaNames.LEFT_ARM)
-        self.__build_leg(self.__areas[AreaNames.LEFT_TORSO], AreaNames.LEFT_LEG)
-
-    def __build_arm(self, parent: Area, index: AreaNames):
-        self.__areas[index].parent = parent
-        self.__areas[index].items = {
-                (1, 1): Joint(),
-                (1, 2): Activator(),
-                (1, 3): Activator(),
-                (1, 4): Activator(),
-                (1, 5): None,
-                (1, 6): None,
-                (2, 1): None,
-                (2, 2): None,
-                (2, 3): None,
-                (2, 4): None,
-                (2, 5): None,
-                (2, 6): None,
-                }
-        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 = {
-                (1, 1): Joint(),
-                (1, 2): Activator(),
-                (1, 3): Activator(),
-                (1, 4): Activator(),
-                (1, 5): None,
-                (1, 6): None,
-                }
-        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.__set_outer_armor(armor, ZoneNames.HEAD, AreaNames.HEAD)
-
-    def set_middle_torso_armor(self, armor_front: int, amor_rear: int) -> None:
-        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_front: int, amor_rear: int) -> None:
-        self.__set_outer_armor(armor_front, ZoneNames.LEFT_TORSO_FRONT, AreaNames.LEFT_TORSO)
-        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.__set_outer_armor(armor, ZoneNames.LEFT_ARM, AreaNames.LEFT_ARM)
-        self.__set_outer_armor(armor, ZoneNames.RIGHT_ARM, AreaNames.RIGHT_ARM)
-
-    def set_leg_armor(self, armor: int) -> None:
-        self.__set_outer_armor(armor, ZoneNames.LEFT_LEG, AreaNames.LEFT_LEG)
-        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/items.py

@@ -1,67 +0,0 @@
-import enum
-
-
-class ItemTypes(enum.Enum):
-    COCKPIT = 1
-    REAKTOR = 2
-    GYROSKOPE = 3
-    ACTIVATOR = 4
-    JOINT = 5
-    SENSORS = 6
-    SUSTAINMENT = 7
-
-
-class Item(object):
-    def __init__(self, item_type: ItemTypes):
-        self._type = item_type
-
-    @property
-    def type(self):
-        return self._type
-
-
-class BigItem(Item):
-
-    def __init__(self, item_type: ItemTypes, tonnage: float):
-        super().__init__(item_type)
-        self._tonnage = tonnage
-
-    @property
-    def tonnage(self) -> float:
-        return self._tonnage
-
-
-class Cockpit(BigItem):
-    def __init__(self):
-        super().__init__(ItemTypes.COCKPIT, 3.0)
-
-
-class Reaktor(BigItem):
-
-    def __init__(self, value: int, tonnage: float):
-        super().__init__(ItemTypes.REAKTOR, tonnage)
-        self._value = value
-
-    @property
-    def value(self):
-        return self._value
-
-
-class Activator(Item):
-    def __init__(self):
-        super().__init__(ItemTypes.ACTIVATOR)
-
-
-class Joint(Item):
-    def __init__(self):
-        super().__init__(ItemTypes.JOINT)
-
-
-class Sensors(Item):
-    def __init__(self):
-        super().__init__(ItemTypes.SENSORS)
-
-
-class Sustainment(Item):
-    def __init__(self):
-        super().__init__(ItemTypes.SUSTAINMENT)

events/__init__.py

@@ -0,0 +1,60 @@
+from mech_factory.component_storage import Area, AreaStatus, ItemStatus, OuterAmor, Zone
+
+
+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 CriticalStrikeEvent:
+    def __init__(self, zone: OuterAmor, index: tuple[int, int]):
+        self.__dict__['_zone'] = zone
+        self.__dict__['_area'] = zone.area
+        self.__dict__['_index'] = index
+        self.__dict__['_item_is_empty'] = None
+
+    @property
+    def area(self) -> Area:
+        return self.__dict__['_area']
+
+    def process_event(self) -> CriticalStrikeEvent:
+        self.__dict__['_zone'].state = AreaStatus.DAMAGED
+        self.__dict__['_area'].state = AreaStatus.DAMAGED
+        item = self.__dict__['_area'].items[self.__dict__['_index']]
+        if item is None or item.state == ItemStatus.DESTROYED:
+            self.__dict__['_item_is_empty'] = True
+        else:
+            self.__dict__['_item_is_empty'] = False
+            item.process_strike()
+        return self
+
+    def is_empty(self):
+        return self.__dict__['_item_is_empty']

hangar/mech.py

@@ -1,4 +1,5 @@
-from MechFabrik.bauteile import InnerStructure, Item, StrikeEvent, ZoneNames
+from events import CriticalStrikeEvent, StrikeEvent
+from mech_factory.component_storage import InnerStructure, Item, ZoneNames
 
 
 class Mech(object):
@@ -33,3 +34,9 @@ class Mech(object):
         if zone is None:
             raise Exception(f"Zone {zone_name} not found")
         return StrikeEvent(zone, hits)
+
+    def critical_strike(self, zone_name: ZoneNames, index: tuple[int, int]) -> CriticalStrikeEvent:
+        zone = self._inner_structure.zones.get(zone_name)
+        if zone is None:
+            raise Exception(f"Zone {zone_name} not found")
+        return CriticalStrikeEvent(zone, index)

mech_factory/__init__.py

@@ -0,0 +1,156 @@
+from hangar.mech import Mech
+from mech_factory.component_storage import InnerStructure, Area, AreaNames, OuterAmor, ZoneNames
+from mech_factory.component_storage.items import Activator, Cockpit, Gyroskope, Item, Joint, Reaktor, Sensors, \
+    Sustainment
+from mech_factory.store import ItemStore, ComponentStore, InnerAmorStore
+from mech_factory.watcher import Watcher
+
+
+class MechFabrik(object):
+
+    def __init__(self, name: str, tonnage: float, movement_rate: int):
+        self.__tonnage = tonnage
+        self.__reactor_value = int(movement_rate * tonnage)
+        self._watcher = Watcher(tonnage)
+        self.__areas = {
+                AreaNames.HEAD:         Area(),
+                AreaNames.MIDDLE_TORSO: Area(),
+                AreaNames.LEFT_TORSO:   Area(),
+                AreaNames.RIGHT_TORSO:  Area(),
+                AreaNames.LEFT_ARM:     Area(),
+                AreaNames.RIGHT_ARM:    Area(),
+                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._item_store = ItemStore()
+        self._component_store = ComponentStore(tonnage, movement_rate)
+        self._inner_amor_store = InnerAmorStore(tonnage)
+        self._inner_structure = self._component_store.get_inner_structure()
+        for (index, area) in self.__areas.items():
+            self._inner_structure.add_area(index, area)
+        self._watcher.add_item(self._inner_structure)
+        self.__build_head_area()
+        self.__build_middle_torso_area(self._inner_structure.gyroskope)
+        self._mech = Mech(name, tonnage, movement_rate, self._inner_structure)
+
+    @property
+    def watcher(self):
+        return self._watcher
+
+    def __build_head_area(self) -> None:
+        cockpit = self._item_store.get_cockpit()
+        self.__areas[AreaNames.HEAD].cockpit = cockpit
+        self.__add_item_to_areas(AreaNames.HEAD, (1, 1), self._item_store.get_sustainment(), )
+        self.__add_item_to_areas(AreaNames.HEAD, (1, 2), self._item_store.get_sensors(), )
+        self.__add_item_to_areas(AreaNames.HEAD, (1, 3), cockpit, )
+        self.__add_item_to_areas(AreaNames.HEAD, (1, 4), None, )
+        self.__add_item_to_areas(AreaNames.HEAD, (1, 5), self._item_store.get_sensors(), )
+        self.__add_item_to_areas(AreaNames.HEAD, (1, 6), self._item_store.get_sustainment(), )
+        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]
+        self.__areas[AreaNames.RIGHT_TORSO].parent = self.__areas[AreaNames.MIDDLE_TORSO]
+        reactor = self._component_store.get_reaktor()
+        self.__areas[AreaNames.MIDDLE_TORSO].reactor = reactor
+        self.__areas[AreaNames.MIDDLE_TORSO].children = [
+                self.__areas[AreaNames.RIGHT_TORSO],
+                self.__areas[AreaNames.LEFT_TORSO]
+                ]
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (1, 1), reactor, )
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (1, 2), reactor, )
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (1, 3), reactor, )
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (1, 4), gyroscope, )
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (1, 5), gyroscope, )
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (1, 6), gyroscope, )
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (2, 1), gyroscope, )
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (2, 2), reactor, )
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (2, 3), reactor, )
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (2, 4), reactor, )
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (2, 5), None, )
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (2, 6), None)
+        self.__areas[AreaNames.MIDDLE_TORSO].armor = self._inner_amor_store.get_middle_torso_amor()
+        self.__areas[AreaNames.LEFT_TORSO].armor = self._inner_amor_store.get_side_torso_amor()
+        self.__areas[AreaNames.RIGHT_TORSO].armor = self._inner_amor_store.get_side_torso_amor()
+        self.__build_arm_leg(self.__areas[AreaNames.RIGHT_TORSO], AreaNames.RIGHT_ARM, True)
+        self.__build_arm_leg(self.__areas[AreaNames.RIGHT_TORSO], AreaNames.RIGHT_LEG, False)
+        self.__build_arm_leg(self.__areas[AreaNames.LEFT_TORSO], AreaNames.LEFT_ARM, True)
+        self.__build_arm_leg(self.__areas[AreaNames.LEFT_TORSO], AreaNames.LEFT_LEG, False)
+
+    def __build_arm_leg(self, parent: Area, index: AreaNames, is_arm: bool) -> None:
+        self.__areas[index].parent = parent
+        self.__add_item_to_areas(index, (1, 1), self._item_store.get_joint(), )
+        self.__add_item_to_areas(index, (1, 2), self._item_store.get_activator(), )
+        self.__add_item_to_areas(index, (1, 3), self._item_store.get_activator(), )
+        self.__add_item_to_areas(index, (1, 4), self._item_store.get_activator(), )
+        self.__add_item_to_areas(index, (1, 5), None, )
+        self.__add_item_to_areas(index, (1, 6), None, )
+        if is_arm:
+            self.__add_item_to_areas(index, (2, 1), None, )
+            self.__add_item_to_areas(index, (2, 2), None, )
+            self.__add_item_to_areas(index, (2, 3), None, )
+            self.__add_item_to_areas(index, (2, 4), None, )
+            self.__add_item_to_areas(index, (2, 5), None, )
+            self.__add_item_to_areas(index, (2, 6), None, )
+            self.__areas[index].armor = self._inner_amor_store.get_arm_amore()
+        else:
+            self.__areas[index].armor = self._inner_amor_store.get_leg_amore()
+        parent.children.append(self.__areas[index])
+
+    def auslieferung(self) -> Mech:
+        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._watcher.add_armor(AreaNames.HEAD, armor)
+        self.__set_outer_armor(armor, ZoneNames.HEAD, AreaNames.HEAD)
+
+    def set_middle_torso_armor(self, armor_front: int, amor_rear: int) -> None:
+        self._watcher.add_armor(AreaNames.MIDDLE_TORSO, armor_front + amor_rear)
+        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_front: int, amor_rear: int) -> None:
+        self._watcher.add_armor(AreaNames.LEFT_TORSO, armor_front + amor_rear)
+        self.__set_outer_armor(armor_front, ZoneNames.LEFT_TORSO_FRONT, AreaNames.LEFT_TORSO)
+        self.__set_outer_armor(amor_rear, ZoneNames.LEFT_TORSO_REAR, AreaNames.LEFT_TORSO)
+        self._watcher.add_armor(AreaNames.RIGHT_TORSO, armor_front + amor_rear)
+        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._watcher.add_armor(AreaNames.LEFT_ARM, armor)
+        self._watcher.add_armor(AreaNames.RIGHT_ARM, armor)
+        self.__set_outer_armor(armor, ZoneNames.LEFT_ARM, AreaNames.LEFT_ARM)
+        self.__set_outer_armor(armor, ZoneNames.RIGHT_ARM, AreaNames.RIGHT_ARM)
+
+    def set_leg_armor(self, armor: int) -> None:
+        self._watcher.add_armor(AreaNames.LEFT_LEG, armor)
+        self._watcher.add_armor(AreaNames.RIGHT_LEG, armor)
+        self.__set_outer_armor(armor, ZoneNames.LEFT_LEG, AreaNames.LEFT_LEG)
+        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])
+
+    def __add_item_to_areas(self, area_name: AreaNames, index: tuple, item: Item | None) -> None:
+        self.__areas[area_name].items[index] = item
+        # noinspection PyTypeChecker
+        self._watcher.add_item(item)

mech_factory/component_storage/__init__.py

@@ -1,6 +1,6 @@
 import enum
 
-from MechFabrik.bauteile.items import Item
+from mech_factory.component_storage.items import Gyroskope, Item, ItemStatus
 
 
 class ZoneNames(enum.Enum):
@@ -65,48 +65,6 @@ class OuterAmor(Zone):
         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:
-    def __init__(self, tonnage: float):
-        self._tonnage = tonnage
-
-    @property
-    def tonnage(self) -> float:
-        return self._tonnage
-
-
 class InnerStructure:
 
     def __init__(self, tonnage: float, gyroskope: Gyroskope):
@@ -131,9 +89,8 @@ class InnerStructure:
         self._areas[index] = area
 
     @property
-    def zones(self) -> dict[ZoneNames, Zone]:
+    def zones(self) -> dict[ZoneNames, OuterAmor]:
         return self._zones
 
-    def add_zone(self, index: ZoneNames, zone: Zone):
+    def add_zone(self, index: ZoneNames, zone: OuterAmor):
         self._zones[index] = zone
-

mech_factory/component_storage/items.py

@@ -0,0 +1,105 @@
+import enum
+
+
+class ItemTypes(enum.Enum):
+    COCKPIT = 1
+    REAKTOR = 2
+    GYROSKOPE = 3
+    ACTIVATOR = 4
+    JOINT = 5
+    SENSORS = 6
+    SUSTAINMENT = 7
+
+
+class ItemStatus(enum.Flag):
+    FINE = 0
+    DAMAGED = 1
+    DESTROYED = 2
+
+
+class Item(object):
+    def __init__(self, item_type: ItemTypes, **another: dict):
+        self._type = item_type
+        self._state = ItemStatus.FINE
+
+    @property
+    def type(self):
+        return self._type
+
+    @property
+    def state(self):
+        return self._state
+
+    @state.setter
+    def state(self, new_state: ItemStatus):
+        self._state = new_state
+
+    def process_strike(self):
+        self._state = ItemStatus.DESTROYED
+
+
+class BigItem(Item):
+
+    def __init__(self, item_type: ItemTypes, tonnage: float, **another: dict):
+        super().__init__(item_type, **another)
+        self._tonnage = tonnage
+
+    @property
+    def tonnage(self) -> float:
+        return self._tonnage
+
+
+class DurableItem(Item):
+
+    def __init__(self, item_type: ItemTypes, max_strike: int, **another):
+        super().__init__(item_type)
+        self._max_strike = max_strike
+
+    @property
+    def max_strike(self):
+        return self._max_strike
+
+    def process_strike(self):
+        self._max_strike -= 1
+        self._state = ItemStatus.DAMAGED if self._max_strike > 0 else ItemStatus.DESTROYED
+
+
+class Gyroskope(BigItem, DurableItem):
+    def __init__(self, tonnage: float):
+        super().__init__(item_type = ItemTypes.GYROSKOPE, tonnage=tonnage, max_strike=2)
+
+
+class Cockpit(BigItem):
+    def __init__(self):
+        super().__init__(ItemTypes.COCKPIT, 3.0)
+
+
+class Reaktor(BigItem, DurableItem):
+
+    def __init__(self, value: int, tonnage: float):
+        super().__init__(item_type = ItemTypes.REAKTOR, tonnage=tonnage, max_strike=3)
+        self._value = value
+
+    @property
+    def value(self):
+        return self._value
+
+
+class Activator(Item):
+    def __init__(self):
+        super().__init__(ItemTypes.ACTIVATOR)
+
+
+class Joint(Item):
+    def __init__(self):
+        super().__init__(ItemTypes.JOINT)
+
+
+class Sensors(DurableItem):
+    def __init__(self):
+        super().__init__(ItemTypes.SENSORS, 2)
+
+
+class Sustainment(Item):
+    def __init__(self):
+        super().__init__(ItemTypes.SUSTAINMENT)

mech_factory/reader.py

@@ -1,15 +1,13 @@
 import csv
 import os.path
 
-from MechFabrik import AreaNames
-
 
 # noinspection SpellCheckingInspection
-class CsvDialect (csv.Dialect):
+class CsvDialect(csv.Dialect):
-    lineterminator='\r\n'
+    lineterminator = '\r\n'
     delimiter = ','
     quotechar = '"'
-    quoting=csv.QUOTE_NONNUMERIC
+    quoting = csv.QUOTE_NONNUMERIC
 
 
 class ComponentReader:
@@ -38,15 +36,11 @@ class ComponentReader:
     def reactor_tonnage_from(self, reactor_value: int) -> float:
         return float(self._reactor_data.get(reactor_value, {}).get('Tonnage', 0.0))
 
-    def inner_amor_for_tonnage_and_area(self, tonnage: float, area: AreaNames) -> int:
+    def inner_amor_for_tonnage(self, tonnage: float) -> dict[str, int]:
-        match area:
+        return {
-            case AreaNames.HEAD:
+                'head':         3,
-                return 3
+                'middle_torso': int(self._inner_structure_data.get(tonnage, {}).get('TorsoMitte', 0)),
-            case AreaNames.MIDDLE_TORSO:
+                'side_torso':   int(self._inner_structure_data.get(tonnage, {}).get('TorsoSeite', 0)),
-                return int(self._inner_structure_data.get(tonnage, {}).get('TorsoMitte', 0))
+                'arm':          int(self._inner_structure_data.get(tonnage, {}).get('Arm', 0)),
-            case AreaNames.RIGHT_TORSO | AreaNames.LEFT_TORSO:
+                'leg':          int(self._inner_structure_data.get(tonnage, {}).get('Bein', 0)),
-                return int(self._inner_structure_data.get(tonnage, {}).get('TorsoSeite', 0))
+                }
-            case AreaNames.RIGHT_ARM | AreaNames.LEFT_ARM:
-                return int(self._inner_structure_data.get(tonnage, {}).get('Arm', 0))
-            case AreaNames.RIGHT_LEG | AreaNames.LEFT_LEG:
-                return int(self._inner_structure_data.get(tonnage, {}).get('Bein', 0))

mech_factory/store.py

@@ -0,0 +1,91 @@
+from mech_factory import InnerStructure, Joint, Sustainment
+from mech_factory.component_storage.items import Activator, Cockpit, Gyroskope, Reaktor, Sensors
+from mech_factory.reader import ComponentReader
+
+
+class ComponentStore(object):
+    def __init__(self, tonnage: float, movement_rate: int):
+        self.__components_reader = ComponentReader()
+        self.__tonnage = tonnage
+        self.__reactor_value = int(movement_rate * tonnage)
+    '''
+    Erstellt den erforderlichen Reaktor
+    '''
+    def get_reaktor(self) -> Reaktor:
+        return Reaktor(self.__reactor_value, self.__components_reader.reactor_tonnage_from(self.__reactor_value))
+    '''
+    Erstellt den Bewegungs-Aparat
+    '''
+    def get_gyroskope(self) -> Gyroskope:
+        return Gyroskope(float(round(self.__reactor_value / 100)))
+    '''
+    Erstellt die innere Struktur
+    '''
+    def get_inner_structure(self) -> InnerStructure:
+        gyroscope = self.get_gyroskope()
+        return InnerStructure(self.__components_reader.inner_structure_from(self.__tonnage), gyroscope)
+
+
+# noinspection PyMethodMayBeStatic
+class ItemStore(object):
+
+    def __init__(self):
+        pass
+    '''
+    Erstellt das Cockpit
+    '''
+    def get_cockpit(self) -> Cockpit:
+        return Cockpit()
+
+    '''
+    Erstellt die Lebenserhaltung
+    '''
+    def get_sustainment(self) -> Sustainment:
+        return Sustainment()
+
+    '''
+    Erstellt die Sensoren
+    '''
+    def get_sensors(self) -> Sensors:
+        return Sensors()
+
+    '''
+    Erstellt die Gelenke
+    * Hüftgelenk
+    * Schultergelenk
+    '''
+    def get_joint(self) -> Joint:
+        return Joint()
+
+    '''
+    Erstellt die Aktivatoren
+    * Oberschenkel-Aktivator
+    * Unterschenkel-Aktivator
+    * Fuß-Aktivator
+    * Oberarm-Aktivator
+    * Unterarm-Aktivator
+    * Hand-Aktivator
+    '''
+    def get_activator(self) -> Activator:
+        return Activator()
+
+
+class InnerAmorStore:
+
+    def __init__(self, tonnage: float):
+        self.__inner_structure_data = ComponentReader().inner_amor_for_tonnage(tonnage)
+
+    def get_head_amor(self) -> int:
+        return self.__inner_structure_data['head']
+
+    def get_middle_torso_amor(self) -> int:
+        return self.__inner_structure_data['middle_torso']
+
+    def get_side_torso_amor(self) -> int:
+        return self.__inner_structure_data['side_torso']
+
+    def get_arm_amore(self) -> int:
+        return self.__inner_structure_data['arm']
+
+    def get_leg_amore(self) -> int:
+        return self.__inner_structure_data['leg']

mech_factory/watcher/__init__.py

@@ -0,0 +1,70 @@
+from typing import Any
+
+from mech_factory.component_storage import AreaNames, InnerStructure
+from mech_factory.component_storage.items import BigItem
+
+class Watcher:
+    def __init__(self, tonnage: float):
+        self._tonnage = tonnage
+        self._weight_watcher = WeightWatcher(tonnage)
+        self._amor_watcher = ArmorWatcher()
+
+    def add_item(self, item: Any) -> Any:
+        if isinstance(item, InnerStructure):
+            self._amor_watcher.set_inner_structure(item)
+        return self._weight_watcher.add_item(item)
+
+    @property
+    def actual_weight(self):
+        return self._weight_watcher.actual_weight + self._amor_watcher.actual_armor_tonnage
+
+    @property
+    def rest_weight(self):
+        return self._tonnage - self.actual_weight
+
+    def add_armor(self, area: AreaNames, armor: int):
+        self._amor_watcher.add_armor(area, armor)
+
+
+class ArmorWatcher:
+    def __init__(self):
+        self._inner_structure = None
+        self._areas = {}
+
+    @property
+    def actual_armor_tonnage(self):
+        actual_armor = sum(self._areas.values())
+        if actual_armor % 8 > 0:
+            raise ValueError('Armor is not valid')
+        return actual_armor / 16
+
+    def set_inner_structure(self, inner_structure: InnerStructure):
+        self._inner_structure = inner_structure
+
+    def add_armor(self, area: AreaNames, armor: int):
+        max_armor = self._inner_structure.areas[area].armor * 2
+        if area is AreaNames.HEAD and armor > 9:
+            raise ValueError(AreaNames.HEAD.name + 'Armor cannot be greater than 9')
+        elif armor > max_armor:
+            raise ValueError(AreaNames.HEAD.name + 'Armor cannot be greater than ' + str(max_armor))
+        self._areas[area] = armor
+
+class WeightWatcher:
+    def __init__(self, max_weight: float):
+        self._max_weight = max_weight
+        self._items = {}
+        self._armor = 0
+
+    @property
+    def actual_weight(self):
+        return sum(self._items.values())
+
+    def add_item(self, item: Any) -> Any:
+        if isinstance(item, BigItem):
+            self._items[item] = item.tonnage
+        if isinstance(item, InnerStructure):
+            self._items[item] = item.tonnage
+        return item
+
+    def set_armor(self, armor: int):
+        self._armor = armor

tests/test_mech/__init__.py

@@ -1,7 +1,7 @@
 import unittest
 
-from MechFabrik import MechFabrik
+from mech_factory import MechFabrik
-from MechFabrik.bauteile import AreaNames, ZoneNames
+from mech_factory.component_storage import AreaNames, ZoneNames
 
 INNER_ARMOR = {
         AreaNames.HEAD:         3,
@@ -13,19 +13,19 @@ INNER_ARMOR = {
         AreaNames.LEFT_LEG:     4,
         AreaNames.RIGHT_LEG:    4,
         }
-
+## entspricht 64 Punkte → 4 t Panzerung
 OUTER_ARMOR = {
         ZoneNames.HEAD:               6,
-        ZoneNames.MIDDLE_TORSO_FRONT: 9,
+        ZoneNames.MIDDLE_TORSO_FRONT: 8,
         ZoneNames.MIDDLE_TORSO_REAR:  4,
         ZoneNames.LEFT_TORSO_FRONT:   8,
-        ZoneNames.LEFT_TORSO_REAR:    3,
+        ZoneNames.LEFT_TORSO_REAR:    2,
         ZoneNames.RIGHT_TORSO_FRONT:  8,
-        ZoneNames.RIGHT_TORSO_REAR:   3,
+        ZoneNames.RIGHT_TORSO_REAR:   2,
         ZoneNames.LEFT_ARM:           5,
         ZoneNames.RIGHT_ARM:          5,
-        ZoneNames.LEFT_LEG:           7,
+        ZoneNames.LEFT_LEG:           8,
-        ZoneNames.RIGHT_LEG:          7,
+        ZoneNames.RIGHT_LEG:          8,
         }
 
 NEXT_OUTER_ZONE = {
@@ -43,15 +43,18 @@ NEXT_OUTER_ZONE = {
 }
 
 
-class AbstractTestMechAmor(unittest.TestCase):
+class AbstractTestMech(unittest.TestCase):
 
     def setUp(self):
-        fabrik = MechFabrik('Heuschrecke', 20.0, 8)
+        self.factory = MechFabrik('Heuschrecke', 20.0, 8)
 
-        fabrik.set_head_armor(OUTER_ARMOR[ZoneNames.HEAD])
-        fabrik.set_middle_torso_armor(OUTER_ARMOR[ZoneNames.MIDDLE_TORSO_FRONT],OUTER_ARMOR[ZoneNames.MIDDLE_TORSO_REAR])
-        fabrik.set_side_torso_armor(OUTER_ARMOR[ZoneNames.LEFT_TORSO_FRONT],OUTER_ARMOR[ZoneNames.LEFT_TORSO_REAR])
-        fabrik.set_arm_armor(OUTER_ARMOR[ZoneNames.LEFT_ARM])
-        fabrik.set_leg_armor(OUTER_ARMOR[ZoneNames.LEFT_LEG])
 
-        self.mech = fabrik.auslieferung()
+class AbstractTestMechAmor(AbstractTestMech):
+
+    def setUp(self):
+        super(AbstractTestMechAmor, self).setUp()
+        self.factory.set_head_armor(OUTER_ARMOR[ZoneNames.HEAD])
+        self.factory.set_middle_torso_armor(OUTER_ARMOR[ZoneNames.MIDDLE_TORSO_FRONT],OUTER_ARMOR[ZoneNames.MIDDLE_TORSO_REAR])
+        self.factory.set_side_torso_armor(OUTER_ARMOR[ZoneNames.LEFT_TORSO_FRONT],OUTER_ARMOR[ZoneNames.LEFT_TORSO_REAR])
+        self.factory.set_arm_armor(OUTER_ARMOR[ZoneNames.LEFT_ARM])
+        self.factory.set_leg_armor(OUTER_ARMOR[ZoneNames.LEFT_LEG])

tests/test_mech_bau.py

@@ -1,48 +1,44 @@
-import unittest
+from hangar.mech import Mech
-
+from mech_factory.component_storage import InnerStructure, AreaNames, Area, OuterAmor, Zone, ZoneNames
-from Hangar.mech import Mech
+from mech_factory.component_storage.items import Cockpit, Gyroskope, Item, ItemTypes, Reaktor
-from MechFabrik import MechFabrik
+from test_mech import AbstractTestMech, AbstractTestMechAmor, INNER_ARMOR, OUTER_ARMOR
-from MechFabrik.bauteile import Gyroskope, InnerStructure, AreaNames, Area, OuterAmor, Zone, ZoneNames
-from MechFabrik.bauteile.items import Cockpit, Item, ItemTypes, Reaktor
-from test_mech import AbstractTestMechAmor, INNER_ARMOR, OUTER_ARMOR
 
 
-class TestMechBau(unittest.TestCase):
+class TestMechBau(AbstractTestMech):
 
     def test_simple(self):
-        fabrik = MechFabrik('Heuschrecke', 20.0, 8)
+        self.mech = self.factory.auslieferung()
-        mech = fabrik.auslieferung()
+        self.assertIsInstance(self.mech, Mech)
-        self.assertIsInstance(mech, Mech)
+        self.assertIsInstance(self.mech.name, str)
-        self.assertIsInstance(mech.name, str)
+        self.assertEqual('Heuschrecke', self.mech.name)
-        self.assertEqual('Heuschrecke', mech.name)
+        self.assertIsInstance(self.mech.tonnage, float)
-        self.assertIsInstance(mech.tonnage, float)
+        self.assertEqual(20.0, self.mech.tonnage)
-        self.assertEqual(20.0, mech.tonnage)
+        self.assertIsInstance(self.mech.movement_rate, int)
-        self.assertIsInstance(mech.movement_rate, int)
+        self.assertEqual(8, self.mech.movement_rate)
-        self.assertEqual(8, mech.movement_rate)
 
         for ara_name in AreaNames:
-            area = mech.inner_structure.areas.get(ara_name)
+            area = self.mech.inner_structure.areas.get(ara_name)
             should_amor = INNER_ARMOR[ara_name]
             self.assertIsInstance(area, Zone)
             self.assertIsInstance(area, Area)
             self.assertEqual(should_amor, area.armor)
 
         for zone_name in ZoneNames:
-            zone = mech.inner_structure.zones.get(zone_name)
+            zone = self.mech.inner_structure.zones.get(zone_name)
             self.assertIsInstance(zone, Zone)
             self.assertIsInstance(zone, OuterAmor)
             self.assertEqual(0, zone.armor)
 
-        self.assertIsInstance(mech.inner_structure, InnerStructure)
+        self.assertIsInstance(self.mech.inner_structure, InnerStructure)
-        self.assertIsInstance(mech.inner_structure.tonnage, float)
+        self.assertIsInstance(self.mech.inner_structure.tonnage, float)
-        self.assertEqual(2.0, mech.inner_structure.tonnage)
+        self.assertEqual(2.0, self.mech.inner_structure.tonnage)
 
-        self.assertIsInstance(mech.inner_structure.gyroskope, Gyroskope)
+        self.assertIsInstance(self.mech.inner_structure.gyroskope, Gyroskope)
-        self.assertIsInstance(mech.inner_structure.gyroskope.tonnage, float)
+        self.assertIsInstance(self.mech.inner_structure.gyroskope.tonnage, float)
-        self.assertEqual(2.0, mech.inner_structure.gyroskope.tonnage)
+        self.assertEqual(2.0, self.mech.inner_structure.gyroskope.tonnage)
-        self.assertIsInstance(mech.inner_structure.areas, dict)
+        self.assertIsInstance(self.mech.inner_structure.areas, dict)
 
-        area_head = mech.inner_structure.areas.get(AreaNames.HEAD)
+        area_head = self.mech.inner_structure.areas.get(AreaNames.HEAD)
         self.assertIsInstance(area_head, Area)
         cockpit = area_head.cockpit
         self.assertIsInstance(cockpit, Cockpit)
@@ -50,26 +46,26 @@ class TestMechBau(unittest.TestCase):
         self.assertEqual(3.0, cockpit.tonnage)
         self._test_for_head_items(area_head)
 
-        middle_torso = self._test_middle_torso(mech)
+        middle_torso = self._test_middle_torso()
-        right_torso = self._test_areas(mech=mech, parent=middle_torso, index=AreaNames.RIGHT_TORSO, children=2)
+        right_torso = self._test_areas(parent=middle_torso, index=AreaNames.RIGHT_TORSO, children=2)
-        left_torso = self._test_areas(mech=mech, parent=middle_torso, index=AreaNames.LEFT_TORSO, children=2)
+        left_torso = self._test_areas(parent=middle_torso, index=AreaNames.LEFT_TORSO, children=2)
         self.assertIsInstance(area_head.parent, Area)
         self.assertEqual(middle_torso, area_head.parent)
         self.assertCountEqual([right_torso, left_torso], middle_torso.children)
 
-        right_arm = self._test_areas(mech=mech, parent=right_torso, index=AreaNames.RIGHT_ARM, children=0)
+        right_arm = self._test_areas(parent=right_torso, index=AreaNames.RIGHT_ARM, children=0)
-        right_leg = self._test_areas(mech=mech, parent=right_torso, index=AreaNames.RIGHT_LEG, children=0)
+        right_leg = self._test_areas(parent=right_torso, index=AreaNames.RIGHT_LEG, children=0)
         self.assertCountEqual([right_arm, right_leg], right_torso.children)
         self._test_for_arm_items(right_arm)
         self._test_for_leg_items(right_leg)
-        left_arm = self._test_areas(mech=mech, parent=left_torso, index=AreaNames.LEFT_ARM, children=0)
+        left_arm = self._test_areas(parent=left_torso, index=AreaNames.LEFT_ARM, children=0)
-        left_leg = self._test_areas(mech=mech, parent=left_torso, index=AreaNames.LEFT_LEG, children=0)
+        left_leg = self._test_areas(parent=left_torso, index=AreaNames.LEFT_LEG, children=0)
         self.assertCountEqual([left_arm, left_leg], left_torso.children)
         self._test_for_arm_items(left_arm)
         self._test_for_leg_items(left_leg)
 
-    def _test_middle_torso(self, mech) -> Area:
+    def _test_middle_torso(self) -> Area:
-        middle_torso = mech.inner_structure.areas.get(AreaNames.MIDDLE_TORSO)
+        middle_torso = self.mech.inner_structure.areas.get(AreaNames.MIDDLE_TORSO)
         self.assertIsInstance(middle_torso, Area)
         reactor = middle_torso.reactor
         self.assertIsInstance(reactor, Reaktor)
@@ -81,8 +77,8 @@ class TestMechBau(unittest.TestCase):
         self.assertIsInstance(middle_torso.children, list)
         return middle_torso
 
-    def _test_areas(self, mech: Mech, parent: Area, index: AreaNames, children: int) -> Area:
+    def _test_areas(self, parent: Area, index: AreaNames, children: int) -> Area:
-        area = mech.inner_structure.areas.get(index)
+        area = self.mech.inner_structure.areas.get(index)
         self.assertIsInstance(area, Area)
         self.assertIsInstance(area.parent, Area)
         self.assertEqual(parent, area.parent)
@@ -159,7 +155,29 @@ class TestMechBau(unittest.TestCase):
 class TestMechAmor(AbstractTestMechAmor):
 
     def test_build(self):
+        mech = self.factory.auslieferung()
+
         for zone_name in ZoneNames:
-            zone = self.mech.inner_structure.zones.get(zone_name)
+            zone = mech.inner_structure.zones.get(zone_name)
             should_outer_armor = OUTER_ARMOR[zone_name]
             self.assertEqual(should_outer_armor, zone.armor)
+
+
+class TestMechWeightWatch(AbstractTestMechAmor):
+
+    def test_watch(self):
+        watcher = self.factory.watcher
+        '''
+        Aufstellung Gewichte:
+        Bauteil          | Gewicht in Tonnen
+        ------------------------------------
+        Reaktor          |  6.0
+        Gyroskope        |  2.0
+        Interne-Struktur |  2.0
+        Cockpit          |  3.0
+        Panzerung        |  4.0
+        ------------------------------------
+                         | 17.0
+        '''
+        self.assertEqual(17.0, watcher.actual_weight)
+        self.assertEqual(3.0, watcher.rest_weight)

tests/test_mech_process.py

@@ -1,10 +1,13 @@
+from events import CriticalStrikeEvent, StrikeEvent
+from mech_factory.component_storage.items import BigItem, DurableItem, Item, ItemStatus, ItemTypes
 from test_mech import AbstractTestMechAmor, INNER_ARMOR, NEXT_OUTER_ZONE, OUTER_ARMOR
-from MechFabrik.bauteile import Area, AreaStatus, OuterAmor, StrikeEvent, ZoneNames
+from mech_factory.component_storage import Area, AreaStatus, OuterAmor, ZoneNames
 
 
 class TestMechAmor(AbstractTestMechAmor):
 
     def test_process(self):
+        self.mech = self.factory.auslieferung()
         for zone_name in ZoneNames:
             with self.subTest(msg=zone_name.value):
                 zone = self.mech.inner_structure.zones.get(zone_name)
@@ -28,6 +31,18 @@ class TestMechAmor(AbstractTestMechAmor):
                 self.assertEqual(10, event.hits)
                 self.assertEqual(area, event.zone.parent)
 
+    def test_critical_process(self):
+        self.mech = self.factory.auslieferung()
+        for zone_name in ZoneNames:
+            with self.subTest(msg=zone_name.value):
+                zone = self.mech.inner_structure.zones.get(zone_name)
+                area = zone.area
+
+                event = self.mech.critical_strike(zone_name, (1, 2))
+                self.assertIsInstance(event, CriticalStrikeEvent)
+                self.assertEqual(area, event.area)
+                self.assertIsNone(event.is_empty())
+
     def test_strike(self):
         start_outer_armor = 11
         start_area_armor = 5
@@ -81,3 +96,64 @@ class TestMechAmor(AbstractTestMechAmor):
         self.assertNotEqual(area, event.zone)
         self.assertEqual(area.parent, event.zone)
         self.assertEqual(0, event.hits)
+
+    # noinspection PyUnresolvedReferences
+    def test_critical_strike(self):
+        parent = Area()
+        area = Area()
+        area.parent = parent
+        big_item_01 = BigItem(ItemTypes.SUSTAINMENT, 5.0)
+        item_01 = Item(ItemTypes.SUSTAINMENT)
+        durable_item_01 = DurableItem(ItemTypes.SUSTAINMENT, 3)
+        area.items = {
+                (1, 1): big_item_01,
+                (1, 2): durable_item_01,
+                (1, 3): durable_item_01,
+                (1, 4): None,
+                (1, 5): item_01,
+                (1, 6): None,
+                }
+
+        zone = OuterAmor(area)
+
+        event = CriticalStrikeEvent(zone, (1, 1)).process_event()
+        self.assertEqual(AreaStatus.DAMAGED, zone.state)
+        self.assertEqual(AreaStatus.DAMAGED, area.state)
+        self.assertIsInstance(event, CriticalStrikeEvent)
+        self.assertFalse(event.is_empty())
+        self.assertEqual(area, event.area)
+        self.assertEqual(ItemStatus.DESTROYED, area.items[(1, 1)].state)
+
+        event = CriticalStrikeEvent(zone, (1, 5)).process_event()
+        self.assertEqual(AreaStatus.DAMAGED, zone.state)
+        self.assertEqual(AreaStatus.DAMAGED, area.state)
+        self.assertIsInstance(event, CriticalStrikeEvent)
+        self.assertFalse(event.is_empty())
+        self.assertEqual(area, event.area)
+        self.assertEqual(ItemStatus.DESTROYED, area.items[(1, 5)].state)
+
+        event = CriticalStrikeEvent(zone, (1, 2)).process_event()
+        self.assertIsInstance(event, CriticalStrikeEvent)
+        self.assertFalse(event.is_empty())
+        self.assertEqual(area, event.area)
+        self.assertEqual(ItemStatus.DAMAGED, area.items[(1, 2)].state)
+        self.assertEqual(ItemStatus.DAMAGED, area.items[(1, 3)].state)
+
+        event = CriticalStrikeEvent(zone, (1, 3)).process_event()
+        self.assertIsInstance(event, CriticalStrikeEvent)
+        self.assertFalse(event.is_empty())
+        self.assertEqual(area, event.area)
+        self.assertEqual(ItemStatus.DAMAGED, area.items[(1, 2)].state)
+        self.assertEqual(ItemStatus.DAMAGED, area.items[(1, 3)].state)
+
+        event = CriticalStrikeEvent(zone, (1, 2)).process_event()
+        self.assertIsInstance(event, CriticalStrikeEvent)
+        self.assertFalse(event.is_empty())
+        self.assertEqual(area, event.area)
+        self.assertEqual(ItemStatus.DESTROYED, area.items[(1, 2)].state)
+        self.assertEqual(ItemStatus.DESTROYED, area.items[(1, 5)].state)
+
+        event = CriticalStrikeEvent(zone, (1, 4)).process_event()
+        self.assertIsInstance(event, CriticalStrikeEvent)
+        self.assertTrue(event.is_empty())
+        self.assertEqual(area, event.area)

tests/test_store.py

@@ -0,0 +1,101 @@
+import unittest
+
+from mech_factory import InnerStructure, Reaktor
+from mech_factory.store import ComponentStore, ItemStore, InnerAmorStore
+from mech_factory.component_storage.items import Gyroskope, Item, BigItem, DurableItem, ItemStatus, ItemTypes
+
+
+class TestComponentStore(unittest.TestCase):
+    def setUp(self):
+        # reactor_value = 165
+        self._store = ComponentStore(tonnage=55.0, movement_rate=3)
+
+    def test_build_inner_structure(self):
+        item = self._store.get_inner_structure()
+
+        self.assertIsInstance(item, InnerStructure)
+        self.assertIsInstance(item.gyroskope, Gyroskope)
+        self.assertEqual(item.tonnage, 5.5)
+        self.assertIsInstance(item.areas, dict)
+        self.assertCountEqual(item.areas, {})
+        self.assertIsInstance(item.zones, dict)
+        self.assertCountEqual(item.zones, {})
+
+    def test_build_gyroscope(self):
+        item = self._store.get_gyroskope()
+
+        self.assertIsInstance(item, Item)
+        self.assertEqual(item.state, ItemStatus.FINE)
+        self.assertIsInstance(item, BigItem)
+        self.assertEqual(item.tonnage, 2.0)
+        self.assertEqual(item.type, ItemTypes.GYROSKOPE)
+        self.assertIsInstance(item, DurableItem)
+        self.assertEqual(item.max_strike, 2)
+
+    def test_build_reaktor(self):
+        item = self._store.get_reaktor()
+
+        self.assertIsInstance(item, Reaktor)
+        self.assertIsInstance(item, Item)
+        self.assertEqual(item.state, ItemStatus.FINE)
+        self.assertIsInstance(item, BigItem)
+        self.assertEqual(item.tonnage, 6.0)
+        self.assertEqual(item.type, ItemTypes.REAKTOR)
+        self.assertIsInstance(item, DurableItem)
+        self.assertEqual(item.max_strike, 3)
+
+class TestItemsStore(unittest.TestCase):
+
+    def setUp(self):
+        self._store = ItemStore()
+
+    def test_build_cockpit(self):
+        item = self._store.get_cockpit()
+
+        self.assertIsInstance(item, Item)
+        self.assertEqual(item.state, ItemStatus.FINE)
+        self.assertIsInstance(item, BigItem)
+        self.assertEqual(item.type, ItemTypes.COCKPIT)
+        self.assertEqual(item.tonnage, 3.0)
+
+    def test_build_sustainment(self):
+        item = self._store.get_sustainment()
+
+        self.assertIsInstance(item, Item)
+        self.assertEqual(item.state, ItemStatus.FINE)
+        self.assertEqual(item.type, ItemTypes.SUSTAINMENT)
+
+    def test_build_sensors(self):
+        item = self._store.get_sensors()
+
+        self.assertIsInstance(item, Item)
+        self.assertEqual(item.state, ItemStatus.FINE)
+        self.assertEqual(item.type, ItemTypes.SENSORS)
+        self.assertIsInstance(item, DurableItem)
+        self.assertEqual(item.max_strike, 2)
+
+    def test_build_joint(self):
+        item = self._store.get_joint()
+
+        self.assertIsInstance(item, Item)
+        self.assertEqual(item.state, ItemStatus.FINE)
+        self.assertEqual(item.type, ItemTypes.JOINT)
+
+    def test_build_activator(self):
+        item = self._store.get_activator()
+
+        self.assertIsInstance(item, Item)
+        self.assertEqual(item.state, ItemStatus.FINE)
+        self.assertEqual(item.type, ItemTypes.ACTIVATOR)
+
+class TestInnerAmorForTonnageAndArea(unittest.TestCase):
+    def setUp(self):
+        self._store = InnerAmorStore(tonnage=55.0)
+
+    def test_build_inner_structure(self):
+        self.assertEqual(self._store.get_head_amor(), 3)
+        self.assertEqual(self._store.get_middle_torso_amor(), 18)
+        self.assertEqual(self._store.get_side_torso_amor(), 13)
+        self.assertEqual(self._store.get_arm_amore(), 9)
+        self.assertEqual(self._store.get_leg_amore(), 13)
+