mech_factory/__init__.py

@@ -1,7 +1,9 @@
 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, Joint, Reaktor, Sensors, Sustainment
+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):
@@ -9,6 +11,7 @@ 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(),
@@ -36,21 +39,26 @@ class MechFabrik(object):
         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.__areas[AreaNames.HEAD].items = {
+        self.__add_item_to_areas(AreaNames.HEAD, (1, 1), self._item_store.get_sustainment(), )
-                (1, 1): self._item_store.get_sustainment(),
+        self.__add_item_to_areas(AreaNames.HEAD, (1, 2), self._item_store.get_sensors(), )
-                (1, 2): self._item_store.get_sensors(),
+        self.__add_item_to_areas(AreaNames.HEAD, (1, 3), cockpit, )
-                (1, 3): cockpit,
+        self.__add_item_to_areas(AreaNames.HEAD, (1, 4), None, )
-                (1, 4): None,
+        self.__add_item_to_areas(AreaNames.HEAD, (1, 5), self._item_store.get_sensors(), )
-                (1, 5): self._item_store.get_sensors(),
+        self.__add_item_to_areas(AreaNames.HEAD, (1, 6), self._item_store.get_sustainment(), )
-                (1, 6): self._item_store.get_sustainment(),
-                }
         self.__areas[AreaNames.HEAD].armor = 3
         self.__areas[AreaNames.HEAD].parent = self.__areas[AreaNames.MIDDLE_TORSO]
 
@@ -63,85 +71,77 @@ class MechFabrik(object):
                 self.__areas[AreaNames.RIGHT_TORSO],
                 self.__areas[AreaNames.LEFT_TORSO]
                 ]
-        self.__areas[AreaNames.MIDDLE_TORSO].items = {
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (1, 1), reactor, )
-                (1, 1): reactor,
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (1, 2), reactor, )
-                (1, 2): reactor,
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (1, 3), reactor, )
-                (1, 3): reactor,
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (1, 4), gyroscope, )
-                (1, 4): gyroscope,
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (1, 5), gyroscope, )
-                (1, 5): gyroscope,
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (1, 6), gyroscope, )
-                (1, 6): gyroscope,
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (2, 1), gyroscope, )
-                (2, 1): gyroscope,
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (2, 2), reactor, )
-                (2, 2): reactor,
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (2, 3), reactor, )
-                (2, 3): reactor,
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (2, 4), reactor, )
-                (2, 4): reactor,
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (2, 5), None, )
-                (2, 5): None,
+        self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (2, 6), None)
-                (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(self.__areas[AreaNames.RIGHT_TORSO], AreaNames.RIGHT_ARM)
+        self.__build_arm_leg(self.__areas[AreaNames.RIGHT_TORSO], AreaNames.RIGHT_ARM, True)
-        self.__build_leg(self.__areas[AreaNames.RIGHT_TORSO], AreaNames.RIGHT_LEG)
+        self.__build_arm_leg(self.__areas[AreaNames.RIGHT_TORSO], AreaNames.RIGHT_LEG, False)
-        self.__build_arm(self.__areas[AreaNames.LEFT_TORSO], AreaNames.LEFT_ARM)
+        self.__build_arm_leg(self.__areas[AreaNames.LEFT_TORSO], AreaNames.LEFT_ARM, True)
-        self.__build_leg(self.__areas[AreaNames.LEFT_TORSO], AreaNames.LEFT_LEG)
+        self.__build_arm_leg(self.__areas[AreaNames.LEFT_TORSO], AreaNames.LEFT_LEG, False)
 
-    def __build_arm(self, parent: Area, index: AreaNames):
+    def __build_arm_leg(self, parent: Area, index: AreaNames, is_arm: bool) -> None:
         self.__areas[index].parent = parent
-        self.__areas[index].items = {
+        self.__add_item_to_areas(index, (1, 1), self._item_store.get_joint(), )
-                (1, 1): self._item_store.get_joint(),
+        self.__add_item_to_areas(index, (1, 2), self._item_store.get_activator(), )
-                (1, 2): self._item_store.get_activator(),
+        self.__add_item_to_areas(index, (1, 3), self._item_store.get_activator(), )
-                (1, 3): self._item_store.get_activator(),
+        self.__add_item_to_areas(index, (1, 4), self._item_store.get_activator(), )
-                (1, 4): self._item_store.get_activator(),
+        self.__add_item_to_areas(index, (1, 5), None, )
-                (1, 5): None,
+        self.__add_item_to_areas(index, (1, 6), None, )
-                (1, 6): None,
+        if is_arm:
-                (2, 1): None,
+            self.__add_item_to_areas(index, (2, 1), None, )
-                (2, 2): None,
+            self.__add_item_to_areas(index, (2, 2), None, )
-                (2, 3): None,
+            self.__add_item_to_areas(index, (2, 3), None, )
-                (2, 4): None,
+            self.__add_item_to_areas(index, (2, 4), None, )
-                (2, 5): None,
+            self.__add_item_to_areas(index, (2, 5), None, )
-                (2, 6): None,
+            self.__add_item_to_areas(index, (2, 6), None, )
-                }
             self.__areas[index].armor = self._inner_amor_store.get_arm_amore()
-        parent.children.append(self.__areas[index])
+        else:
-
-    def __build_leg(self, parent: Area, index: AreaNames):
-        self.__areas[index].parent = parent
-        self.__areas[index].items = {
-                (1, 1): self._item_store.get_joint(),
-                (1, 2): self._item_store.get_activator(),
-                (1, 3): self._item_store.get_activator(),
-                (1, 4): self._item_store.get_activator(),
-                (1, 5): None,
-                (1, 6): None,
-                }
             self.__areas[index].armor = self._inner_amor_store.get_leg_amore()
         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._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)
 
@@ -149,3 +149,8 @@ class MechFabrik(object):
         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/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

@@ -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 import MechFabrik
 from mech_factory.component_storage import InnerStructure, AreaNames, Area, OuterAmor, Zone, ZoneNames
 from mech_factory.component_storage.items import Cockpit, Gyroskope, Item, ItemTypes, Reaktor
-from test_mech import AbstractTestMechAmor, INNER_ARMOR, OUTER_ARMOR
+from test_mech import AbstractTestMech, 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

@@ -7,6 +7,7 @@ from mech_factory.component_storage import Area, AreaStatus, OuterAmor, ZoneName
 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)
@@ -31,6 +32,7 @@ class TestMechAmor(AbstractTestMechAmor):
                 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)