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

@@ -1,13 +1,12 @@
-from Hangar.mech import Mech
+from hangar.mech import Mech
-from MechFabrik.bauteile import InnerStructure, Gyroskope, Area, AreaNames, OuterAmor, ZoneNames
+from mech_factory.component_storage import InnerStructure, Area, AreaNames, OuterAmor, ZoneNames
-from MechFabrik.bauteile.items import Activator, Cockpit, Joint, Reaktor, Sensors, Sustainment
+from mech_factory.component_storage.items import Activator, Cockpit, Gyroskope, Joint, Reaktor, Sensors, Sustainment
-from MechFabrik.reader import ComponentReader
+from mech_factory.store import ItemStore, ComponentStore, InnerAmorStore
 
 
 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 = {
@@ -33,26 +32,24 @@ class MechFabrik(object):
                 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._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()
+        self.__build_head_area()
+        self.__build_middle_torso_area(self._inner_structure.gyroskope)
         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()
+        cockpit = self._item_store.get_cockpit()
         self.__areas[AreaNames.HEAD].cockpit = cockpit
         self.__areas[AreaNames.HEAD].items = {
-                (1, 1): Sustainment(),
+                (1, 1): self._item_store.get_sustainment(),
-                (1, 2): Sensors(),
+                (1, 2): self._item_store.get_sensors(),
                 (1, 3): cockpit,
                 (1, 4): None,
-                (1, 5): Sensors(),
+                (1, 5): self._item_store.get_sensors(),
-                (1, 6): Sustainment(),
+                (1, 6): self._item_store.get_sustainment(),
                 }
         self.__areas[AreaNames.HEAD].armor = 3
         self.__areas[AreaNames.HEAD].parent = self.__areas[AreaNames.MIDDLE_TORSO]
@@ -60,7 +57,7 @@ class MechFabrik(object):
     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))
+        reactor = self._component_store.get_reaktor()
         self.__areas[AreaNames.MIDDLE_TORSO].reactor = reactor
         self.__areas[AreaNames.MIDDLE_TORSO].children = [
                 self.__areas[AreaNames.RIGHT_TORSO],
@@ -80,16 +77,9 @@ class MechFabrik(object):
                 (2, 5): None,
                 (2, 6): None,
                 }
-        self.__areas[AreaNames.MIDDLE_TORSO].armor = self.__components.inner_amor_for_tonnage_and_area(
+        self.__areas[AreaNames.MIDDLE_TORSO].armor = self._inner_amor_store.get_middle_torso_amor()
-                self.__tonnage,
+        self.__areas[AreaNames.LEFT_TORSO].armor = self._inner_amor_store.get_side_torso_amor()
-                AreaNames.MIDDLE_TORSO
+        self.__areas[AreaNames.RIGHT_TORSO].armor = self._inner_amor_store.get_side_torso_amor()
-                )
-        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)
@@ -98,10 +88,10 @@ class MechFabrik(object):
     def __build_arm(self, parent: Area, index: AreaNames):
         self.__areas[index].parent = parent
         self.__areas[index].items = {
-                (1, 1): Joint(),
+                (1, 1): self._item_store.get_joint(),
-                (1, 2): Activator(),
+                (1, 2): self._item_store.get_activator(),
-                (1, 3): Activator(),
+                (1, 3): self._item_store.get_activator(),
-                (1, 4): Activator(),
+                (1, 4): self._item_store.get_activator(),
                 (1, 5): None,
                 (1, 6): None,
                 (2, 1): None,
@@ -111,20 +101,20 @@ class MechFabrik(object):
                 (2, 5): None,
                 (2, 6): None,
                 }
-        self.__areas[index].armor = self.__components.inner_amor_for_tonnage_and_area(self.__tonnage, index)
+        self.__areas[index].armor = self._inner_amor_store.get_arm_amore()
         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, 1): self._item_store.get_joint(),
-                (1, 2): Activator(),
+                (1, 2): self._item_store.get_activator(),
-                (1, 3): Activator(),
+                (1, 3): self._item_store.get_activator(),
-                (1, 4): Activator(),
+                (1, 4): self._item_store.get_activator(),
                 (1, 5): None,
                 (1, 6): None,
                 }
-        self.__areas[index].armor = self.__components.inner_amor_for_tonnage_and_area(self.__tonnage, index)
+        self.__areas[index].armor = self._inner_amor_store.get_leg_amore()
         parent.children.append(self.__areas[index])
 
     def auslieferung(self) -> Mech:

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']

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,

tests/test_mech_bau.py

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

tests/test_mech_process.py

@@ -1,5 +1,7 @@
+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):
@@ -28,6 +30,17 @@ class TestMechAmor(AbstractTestMechAmor):
                 self.assertEqual(10, event.hits)
                 self.assertEqual(area, event.zone.parent)
 
+    def test_critical_process(self):
+        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 +94,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)
+