MechFabrik/__init__.py

@@ -1,6 +1,6 @@
 from Hangar.mech import Mech
-from MechFabrik.bauteile import InnerStructure, Gyroskope, Area, AreaNames, OuterAmor, ZoneNames
+from MechFabrik.bauteile import InnerStructure, Area, AreaNames, OuterAmor, ZoneNames
-from MechFabrik.bauteile.items import Activator, Cockpit, Joint, Reaktor, Sensors, Sustainment
+from MechFabrik.bauteile.items import Activator, Cockpit, Gyroskope, Joint, Reaktor, Sensors, Sustainment
 from MechFabrik.reader import ComponentReader
 
 

MechFabrik/bauteile/__init__.py

@@ -98,15 +98,6 @@ class StrikeEvent:
         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):

MechFabrik/bauteile/items.py

@@ -18,7 +18,7 @@ class ItemStatus(enum.Flag):
 
 
 class Item(object):
-    def __init__(self, item_type: ItemTypes):
+    def __init__(self, item_type: ItemTypes, **another: dict):
         self._type = item_type
         self._state = ItemStatus.FINE
 
@@ -37,8 +37,8 @@ class Item(object):
 
 class BigItem(Item):
 
-    def __init__(self, item_type: ItemTypes, tonnage: float):
+    def __init__(self, item_type: ItemTypes, tonnage: float, **another: dict):
-        super().__init__(item_type)
+        super().__init__(item_type, **another)
         self._tonnage = tonnage
 
     @property
@@ -46,15 +46,27 @@ class BigItem(Item):
         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
+
+
+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):
+class Reaktor(BigItem, DurableItem):
 
     def __init__(self, value: int, tonnage: float):
-        super().__init__(ItemTypes.REAKTOR, tonnage)
+        super().__init__(item_type = ItemTypes.REAKTOR, tonnage=tonnage, max_strike=3)
         self._value = value
 
     @property
@@ -72,9 +84,9 @@ class Joint(Item):
         super().__init__(ItemTypes.JOINT)
 
 
-class Sensors(Item):
+class Sensors(DurableItem):
     def __init__(self):
-        super().__init__(ItemTypes.SENSORS)
+        super().__init__(ItemTypes.SENSORS, 2)
 
 
 class Sustainment(Item):

tests/test_mech_bau.py

@@ -2,8 +2,8 @@ import unittest
 
 from Hangar.mech import Mech
 from MechFabrik import MechFabrik
-from MechFabrik.bauteile import Gyroskope, InnerStructure, AreaNames, Area, OuterAmor, Zone, ZoneNames
+from MechFabrik.bauteile import InnerStructure, AreaNames, Area, OuterAmor, Zone, ZoneNames
-from MechFabrik.bauteile.items import Cockpit, Item, ItemTypes, Reaktor
+from MechFabrik.bauteile.items import Cockpit, Gyroskope, Item, ItemTypes, Reaktor
 from test_mech import AbstractTestMechAmor, INNER_ARMOR, OUTER_ARMOR
 
 

tests/test_mech_process.py

@@ -1,5 +1,4 @@
-from MechFabrik import Cockpit, Sensors, Sustainment
+from MechFabrik.bauteile.items import BigItem, DurableItem, Item, ItemStatus, ItemTypes
-from MechFabrik.bauteile.items import ItemStatus
 from test_mech import AbstractTestMechAmor, INNER_ARMOR, NEXT_OUTER_ZONE, OUTER_ARMOR
 from MechFabrik.bauteile import Area, AreaStatus, OuterAmor, StrikeEvent, CriticalStrikeEvent, ZoneNames
 
@@ -99,32 +98,55 @@ class TestMechAmor(AbstractTestMechAmor):
         parent = Area()
         area = Area()
         area.parent = parent
-        cockpit = Cockpit()
+        big_item_01 = BigItem(ItemTypes.SUSTAINMENT, 5.0)
-        area.cockpit = cockpit
+        item_01 = Item(ItemTypes.SUSTAINMENT)
+        durable_item_01 = DurableItem(ItemTypes.SUSTAINMENT, 3)
         area.items = {
-                (1, 1): Sustainment(),
+                (1, 1): big_item_01,
-                (1, 2): Sensors(),
+                (1, 2): durable_item_01,
-                (1, 3): cockpit,
+                (1, 3): durable_item_01,
                 (1, 4): None,
-                (1, 5): cockpit,
+                (1, 5): item_01,
-                (1, 6): Sustainment(),
+                (1, 6): None,
                 }
 
         zone = OuterAmor(area)
 
-        event = CriticalStrikeEvent(zone, (1, 2)).process_event()
+        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, 2)].state)
+        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.DESTROYED, area.items[(1, 3)].state)
+        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()