diff --git a/MechFabrik/bauteile/items.py b/MechFabrik/bauteile/items.py deleted file mode 100644 index 354130b..0000000 --- a/MechFabrik/bauteile/items.py +++ /dev/null @@ -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) diff --git a/events/__init__.py b/events/__init__.py new file mode 100644 index 0000000..ffd5749 --- /dev/null +++ b/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'] diff --git a/Hangar/__init__.py b/hangar/__init__.py similarity index 100% rename from Hangar/__init__.py rename to hangar/__init__.py diff --git a/Hangar/mech.py b/hangar/mech.py similarity index 68% rename from Hangar/mech.py rename to hangar/mech.py index ccab62f..f9c6e8e 100644 --- a/Hangar/mech.py +++ b/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) \ No newline at end of file diff --git a/MechFabrik/Uml/Mech.puml b/mech_factory/Uml/Mech.puml similarity index 100% rename from MechFabrik/Uml/Mech.puml rename to mech_factory/Uml/Mech.puml diff --git a/MechFabrik/Uml/MechStructure.puml b/mech_factory/Uml/MechStructure.puml similarity index 100% rename from MechFabrik/Uml/MechStructure.puml rename to mech_factory/Uml/MechStructure.puml diff --git a/MechFabrik/Uml/StrikeProcess.puml b/mech_factory/Uml/StrikeProcess.puml similarity index 100% rename from MechFabrik/Uml/StrikeProcess.puml rename to mech_factory/Uml/StrikeProcess.puml diff --git a/MechFabrik/Uml/StrikeProcessSequence.puml b/mech_factory/Uml/StrikeProcessSequence.puml similarity index 100% rename from MechFabrik/Uml/StrikeProcessSequence.puml rename to mech_factory/Uml/StrikeProcessSequence.puml diff --git a/MechFabrik/__init__.py b/mech_factory/__init__.py similarity index 74% rename from MechFabrik/__init__.py rename to mech_factory/__init__.py index 6d43725..a5154fb 100755 --- a/MechFabrik/__init__.py +++ b/mech_factory/__init__.py @@ -1,13 +1,12 @@ -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 +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.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, 2): Sensors(), + (1, 1): self._item_store.get_sustainment(), + (1, 2): self._item_store.get_sensors(), (1, 3): cockpit, (1, 4): None, - (1, 5): Sensors(), - (1, 6): Sustainment(), + (1, 5): self._item_store.get_sensors(), + (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.__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.__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_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, 2): Activator(), - (1, 3): Activator(), - (1, 4): Activator(), + (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, (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, 2): Activator(), - (1, 3): Activator(), - (1, 4): Activator(), + (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.__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: diff --git a/MechFabrik/bauteile/__init__.py b/mech_factory/component_storage/__init__.py similarity index 64% rename from MechFabrik/bauteile/__init__.py rename to mech_factory/component_storage/__init__.py index c88d5fc..1b214fd 100755 --- a/MechFabrik/bauteile/__init__.py +++ b/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 - diff --git a/mech_factory/component_storage/items.py b/mech_factory/component_storage/items.py new file mode 100644 index 0000000..9313704 --- /dev/null +++ b/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) diff --git a/MechFabrik/reader.py b/mech_factory/reader.py similarity index 61% rename from MechFabrik/reader.py rename to mech_factory/reader.py index 46f7f60..e8205cf 100755 --- a/MechFabrik/reader.py +++ b/mech_factory/reader.py @@ -1,15 +1,13 @@ import csv import os.path -from MechFabrik import AreaNames - # noinspection SpellCheckingInspection -class CsvDialect (csv.Dialect): - lineterminator='\r\n' +class CsvDialect(csv.Dialect): + 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: - match area: - case AreaNames.HEAD: - return 3 - case AreaNames.MIDDLE_TORSO: - return int(self._inner_structure_data.get(tonnage, {}).get('TorsoMitte', 0)) - case AreaNames.RIGHT_TORSO | AreaNames.LEFT_TORSO: - 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)) + def inner_amor_for_tonnage(self, tonnage: float) -> dict[str, int]: + return { + 'head': 3, + 'middle_torso': int(self._inner_structure_data.get(tonnage, {}).get('TorsoMitte', 0)), + 'side_torso': int(self._inner_structure_data.get(tonnage, {}).get('TorsoSeite', 0)), + 'arm': int(self._inner_structure_data.get(tonnage, {}).get('Arm', 0)), + 'leg': int(self._inner_structure_data.get(tonnage, {}).get('Bein', 0)), + } diff --git a/mech_factory/store.py b/mech_factory/store.py new file mode 100644 index 0000000..17ebb74 --- /dev/null +++ b/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'] diff --git a/MechFabrik/tabellen/bauteile.csv b/mech_factory/tabellen/bauteile.csv similarity index 100% rename from MechFabrik/tabellen/bauteile.csv rename to mech_factory/tabellen/bauteile.csv diff --git a/MechFabrik/tabellen/reaktoren.csv b/mech_factory/tabellen/reaktoren.csv similarity index 100% rename from MechFabrik/tabellen/reaktoren.csv rename to mech_factory/tabellen/reaktoren.csv diff --git a/MechFabrik/tabellen/waffen.csv b/mech_factory/tabellen/waffen.csv similarity index 100% rename from MechFabrik/tabellen/waffen.csv rename to mech_factory/tabellen/waffen.csv diff --git a/tests/test_mech/__init__.py b/tests/test_mech/__init__.py index 9072332..5e89f07 100644 --- a/tests/test_mech/__init__.py +++ b/tests/test_mech/__init__.py @@ -1,7 +1,7 @@ import unittest -from MechFabrik import MechFabrik -from MechFabrik.bauteile import AreaNames, ZoneNames +from mech_factory import MechFabrik +from mech_factory.component_storage import AreaNames, ZoneNames INNER_ARMOR = { AreaNames.HEAD: 3, diff --git a/tests/test_mech_bau.py b/tests/test_mech_bau.py index a202bda..e1fe1d5 100755 --- a/tests/test_mech_bau.py +++ b/tests/test_mech_bau.py @@ -1,9 +1,9 @@ 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.items import Cockpit, Item, ItemTypes, Reaktor +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 diff --git a/tests/test_mech_process.py b/tests/test_mech_process.py index 3a6ee50..92a61a1 100755 --- a/tests/test_mech_process.py +++ b/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) diff --git a/tests/test_store.py b/tests/test_store.py new file mode 100644 index 0000000..04315bd --- /dev/null +++ b/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) +