Feature: Füge Bauteile in die Zonen hinzu

MechFabrik/__init__.py

@@ -1,4 +1,6 @@
-from MechFabrik.bauteile import Mech, InnerStructure, Gyroskope, Area, AreaNames, Cockpit, Reaktor
+from MechFabrik.bauteile import Activator, Joint, Mech, InnerStructure, Gyroskope, Area, AreaNames, Cockpit, Reaktor, \
+    Sensors, \
+    Sustainment
 from MechFabrik.reader import ComponentReader
 
 
@@ -15,15 +17,23 @@ class MechFabrik(object):
         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()
+        self.__build_middle_torso_area(gyroscope)
 
     def __build_head_area(self) -> None:
         area = Area()
         cockpit = Cockpit()
         area.cockpit = cockpit
+        area.items = {
+                (1, 1): Sustainment(),
+                (1, 2): Sensors(),
+                (1, 3): area.cockpit,
+                (1, 4): None,
+                (1, 5): Sensors(),
+                (1, 6): Sustainment(),
+                }
         self._inner_structure.add_area(AreaNames.HEAD, area)
 
-    def __build_middle_torso_area(self) -> Area:
+    def __build_middle_torso_area(self, gyroscope: Gyroskope) -> Area:
         area_middle = Area()
         area_left = Area()
         area_right = Area()
@@ -32,6 +42,20 @@ class MechFabrik(object):
         reactor = Reaktor(self.__reactor_value, self.__components.reactor_tonnage_from(self.__reactor_value))
         area_middle.reactor = reactor
         area_middle.children = [area_right, area_left]
+        area_middle.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.__build_arm(area_right, AreaNames.RIGHT_ARM)
         self.__build_leg(area_right, AreaNames.RIGHT_LEG)
         self.__build_arm(area_left, AreaNames.LEFT_ARM)
@@ -44,15 +68,36 @@ class MechFabrik(object):
     def __build_arm(self, parent: Area, index: AreaNames):
         arm = Area()
         arm.parent = parent
+        arm.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,
+                }
         parent.children.append(arm)
         self._inner_structure.add_area(index, arm)
 
     def __build_leg(self, parent: Area, index: AreaNames):
         leg = Area()
         leg.parent = parent
+        leg.items = {
+                (1, 1): Joint(),
+                (1, 2): Activator(),
+                (1, 3): Activator(),
+                (1, 4): Activator(),
+                (1, 5): None,
+                (1, 6): None,
+                }
         parent.children.append(leg)
         self._inner_structure.add_area(index, leg)
 
-
     def auslieferung(self) -> Mech:
         return self._mech

tests/test_mech_bau.py

@@ -43,13 +43,13 @@ class TestMechBau(unittest.TestCase):
         right_arm = self._test_areas(mech=mech, 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)
         self.assertCountEqual([right_arm, right_leg], right_torso.children)
-        self._test_for_arm_left_items(right_arm)
+        self._test_for_arm_items(right_arm)
-        self._test_for_arm_left_items(right_leg)
+        self._test_for_leg_items(right_leg)
         left_arm = self._test_areas(mech=mech, 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)
         self.assertCountEqual([left_arm, left_leg], left_torso.children)
-        self._test_for_arm_left_items(left_arm)
+        self._test_for_arm_items(left_arm)
-        self._test_for_arm_left_items(left_leg)
+        self._test_for_leg_items(left_leg)
 
     def _test_middle_torso(self, mech) -> Area:
         middle_torso = mech.inner_structure.areas.get(AreaNames.MIDDLE_TORSO)
@@ -74,6 +74,7 @@ class TestMechBau(unittest.TestCase):
         return area
 
     def _test_for_head_items(self, area: Area):
+        self.assertEqual(6, len(area.items))
         self.__test_for_items(area, [
                 ((1, 1), ItemTypes.SUSTAINMENT),
                 ((1, 2), ItemTypes.SENSORS),
@@ -85,6 +86,7 @@ class TestMechBau(unittest.TestCase):
         self.assertIsNone(area.items[(1, 4)])
 
     def _test_for_middle_torso_items(self, area: Area):
+        self.assertEqual(12, len(area.items))
         self.__test_for_items(area, [
                 ((1, 1), ItemTypes.REAKTOR),
                 ((1, 2), ItemTypes.REAKTOR),
@@ -103,10 +105,23 @@ class TestMechBau(unittest.TestCase):
         self.assertIsNone(area.items[(2, 6)])
 
     def _test_for_side_torso_items(self, area: Area):
+        self.assertEqual(12, len(area.items))
         for (group, key) in ((group, key + 1) for group in [1,2] for key in range(6)):
             self.assertIsNone(area.items[key])
 
-    def _test_for_arm_left_items(self, area: Area):
+    def _test_for_arm_items(self, area: Area):
+        self.assertEqual(12, len(area.items))
+        self._test_for_arm_leg_items(area)
+        for key in (key + 1 for key in range(6)):
+            self.assertIsNone(area.items[(2, key)])
+        pass
+
+    def _test_for_leg_items(self, area: Area):
+        self.assertEqual(6, len(area.items))
+        self._test_for_arm_leg_items(area)
+        pass
+
+    def _test_for_arm_leg_items(self, area: Area):
         self.__test_for_items(area, [
                 ((1, 1), ItemTypes.JOINT),
                 ((1, 2), ItemTypes.ACTIVATOR),