diff --git a/hangar/mech.py b/hangar/mech.py index f9c6e8e..b81004d 100644 --- a/hangar/mech.py +++ b/hangar/mech.py @@ -1,14 +1,19 @@ +import math + from events import CriticalStrikeEvent, StrikeEvent -from mech_factory.component_storage import InnerStructure, Item, ZoneNames +from mech_factory.component_storage import InnerStructure, ZoneNames +from mech_factory.component_storage.items import ItemTypes, Item, ItemStatus class Mech(object): def __init__(self, name: str, tonnage: float, movement_rate: int, inner_structure: InnerStructure): self._movement_rate = movement_rate + self._jump_jet_list = [] self._tonnage = tonnage self._name = name self._inner_structure = inner_structure + self._actual_heat = 0 @property def name(self) -> str: @@ -26,9 +31,34 @@ class Mech(object): def movement_rate(self) -> int: return self._movement_rate + @property + def actual_heat(self) -> int: + return self._actual_heat + def set_item(self, key: tuple, item: Item): pass + def walk(self, value: int) -> Mech: + if value > math.ceil(self._movement_rate * 1.5): + raise ValueError('maximal movement rate is less than value') + elif value > self._movement_rate: + self._actual_heat += 2 + else: + self._actual_heat += 1 + return self + + def jump(self, value: int) -> Mech: + max_jump = len([ + item for area in self._inner_structure.areas.values() for item in area.items.values() + if item is not None and item.type is ItemTypes.JUMP_JET and item.state is not ItemStatus.DESTROYED + ]) + if value > max_jump: + raise ValueError('maximal jump rate is less than value') + if value < 3: + value = 3 + self._actual_heat += value + return self + def strike(self, zone_name: ZoneNames, hits: int) -> StrikeEvent: zone = self._inner_structure.zones.get(zone_name) if zone is None: @@ -39,4 +69,7 @@ class Mech(object): 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 + return CriticalStrikeEvent(zone, index) + + def exchange_heat(self): + self._actual_heat = 0 \ No newline at end of file diff --git a/mech_factory/__init__.py b/mech_factory/__init__.py index 8f6a5de..8932e11 100755 --- a/mech_factory/__init__.py +++ b/mech_factory/__init__.py @@ -1,156 +1,338 @@ 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, Item, Joint, Reaktor, Sensors, \ - Sustainment +from mech_factory.component_storage import InnerStructure, Area, AreaNames, OuterAmor, Zone, ZoneNames +from mech_factory.component_storage.items import Cockpit, Gyroskope, Item, Reaktor from mech_factory.store import ItemStore, ComponentStore, InnerAmorStore from mech_factory.watcher import Watcher -class MechFabrik(object): +class MechBuilder(object): def __init__(self, name: str, tonnage: float, movement_rate: int): + self.__name = name self.__tonnage = tonnage - self.__reactor_value = int(movement_rate * tonnage) - self._watcher = Watcher(tonnage) - self.__areas = { - AreaNames.HEAD: Area(), - AreaNames.MIDDLE_TORSO: Area(), - AreaNames.LEFT_TORSO: Area(), - AreaNames.RIGHT_TORSO: Area(), - AreaNames.LEFT_ARM: Area(), - AreaNames.RIGHT_ARM: Area(), - AreaNames.LEFT_LEG: Area(), - AreaNames.RIGHT_LEG: Area(), - } - self.__zones = { - ZoneNames.HEAD: OuterAmor(self.__areas[AreaNames.HEAD]), - ZoneNames.MIDDLE_TORSO_FRONT: OuterAmor(self.__areas[AreaNames.MIDDLE_TORSO]), - ZoneNames.MIDDLE_TORSO_REAR: OuterAmor(self.__areas[AreaNames.MIDDLE_TORSO]), - ZoneNames.LEFT_TORSO_FRONT: OuterAmor(self.__areas[AreaNames.LEFT_TORSO]), - ZoneNames.LEFT_TORSO_REAR: OuterAmor(self.__areas[AreaNames.LEFT_TORSO]), - ZoneNames.RIGHT_TORSO_FRONT: OuterAmor(self.__areas[AreaNames.RIGHT_TORSO]), - ZoneNames.RIGHT_TORSO_REAR: OuterAmor(self.__areas[AreaNames.RIGHT_TORSO]), - ZoneNames.LEFT_ARM: OuterAmor(self.__areas[AreaNames.LEFT_ARM]), - ZoneNames.RIGHT_ARM: OuterAmor(self.__areas[AreaNames.RIGHT_ARM]), - ZoneNames.LEFT_LEG: OuterAmor(self.__areas[AreaNames.LEFT_LEG]), - ZoneNames.RIGHT_LEG: OuterAmor(self.__areas[AreaNames.RIGHT_LEG]), - } + self.__movement_rate = movement_rate + inner_armor_store = InnerAmorStore(tonnage) + self._watcher = Watcher(tonnage, inner_armor_store) + self.__areas = AreaDict() self._item_store = ItemStore() self._component_store = ComponentStore(tonnage, movement_rate) - self._inner_amor_store = InnerAmorStore(tonnage) + AbstractMechFactory.set_stores(inner_armor_store, self._component_store, self._item_store) + AbstractMechFactory.set_watcher(self._watcher) + self.__outer_armor_builder = OuterArmorFactory() 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) + self._build_areas() @property def watcher(self): return self._watcher + def _build_areas(self) -> None: + self.__build_torso_areas() + self.__build_head_area() + self.__build_arm_leg(AreaNames.RIGHT_ARM, AreaNames.RIGHT_TORSO) + self.__build_arm_leg(AreaNames.RIGHT_LEG, AreaNames.RIGHT_TORSO) + self.__build_arm_leg(AreaNames.LEFT_ARM, AreaNames.LEFT_TORSO) + self.__build_arm_leg(AreaNames.LEFT_LEG, AreaNames.LEFT_TORSO) + def __build_head_area(self) -> None: - cockpit = self._item_store.get_cockpit() - self.__areas[AreaNames.HEAD].cockpit = cockpit - self.__add_item_to_areas(AreaNames.HEAD, (1, 1), self._item_store.get_sustainment(), ) - self.__add_item_to_areas(AreaNames.HEAD, (1, 2), self._item_store.get_sensors(), ) - self.__add_item_to_areas(AreaNames.HEAD, (1, 3), cockpit, ) - self.__add_item_to_areas(AreaNames.HEAD, (1, 4), None, ) - self.__add_item_to_areas(AreaNames.HEAD, (1, 5), self._item_store.get_sensors(), ) - self.__add_item_to_areas(AreaNames.HEAD, (1, 6), self._item_store.get_sustainment(), ) - self.__areas[AreaNames.HEAD].armor = 3 - self.__areas[AreaNames.HEAD].parent = self.__areas[AreaNames.MIDDLE_TORSO] + area_factory = AreaFactory(AreaNames.HEAD, self.__areas[AreaNames.MIDDLE_TORSO].area) + self.__areas[AreaNames.HEAD] = area_factory + self.__outer_armor_builder.add_area(AreaNames.HEAD, area_factory.area) - 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 = self._component_store.get_reaktor() - self.__areas[AreaNames.MIDDLE_TORSO].reactor = reactor - self.__areas[AreaNames.MIDDLE_TORSO].children = [ - self.__areas[AreaNames.RIGHT_TORSO], - self.__areas[AreaNames.LEFT_TORSO] - ] - self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (1, 1), reactor, ) - self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (1, 2), reactor, ) - self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (1, 3), reactor, ) - self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (1, 4), gyroscope, ) - self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (1, 5), gyroscope, ) - self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (1, 6), gyroscope, ) - self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (2, 1), gyroscope, ) - self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (2, 2), reactor, ) - self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (2, 3), reactor, ) - self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (2, 4), reactor, ) - self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (2, 5), None, ) - self.__add_item_to_areas(AreaNames.MIDDLE_TORSO, (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_leg(self.__areas[AreaNames.RIGHT_TORSO], AreaNames.RIGHT_ARM, True) - self.__build_arm_leg(self.__areas[AreaNames.RIGHT_TORSO], AreaNames.RIGHT_LEG, False) - self.__build_arm_leg(self.__areas[AreaNames.LEFT_TORSO], AreaNames.LEFT_ARM, True) - self.__build_arm_leg(self.__areas[AreaNames.LEFT_TORSO], AreaNames.LEFT_LEG, False) + def __build_torso_areas(self) -> None: + area_factory = AreaFactory(AreaNames.MIDDLE_TORSO, None) + self.__areas[AreaNames.MIDDLE_TORSO] = area_factory + self.__outer_armor_builder.add_area(AreaNames.MIDDLE_TORSO, area_factory.area) - def __build_arm_leg(self, parent: Area, index: AreaNames, is_arm: bool) -> None: - self.__areas[index].parent = parent - self.__add_item_to_areas(index, (1, 1), self._item_store.get_joint(), ) - self.__add_item_to_areas(index, (1, 2), self._item_store.get_activator(), ) - self.__add_item_to_areas(index, (1, 3), self._item_store.get_activator(), ) - self.__add_item_to_areas(index, (1, 4), self._item_store.get_activator(), ) - self.__add_item_to_areas(index, (1, 5), None, ) - self.__add_item_to_areas(index, (1, 6), None, ) - if is_arm: - self.__add_item_to_areas(index, (2, 1), None, ) - self.__add_item_to_areas(index, (2, 2), None, ) - self.__add_item_to_areas(index, (2, 3), None, ) - self.__add_item_to_areas(index, (2, 4), None, ) - self.__add_item_to_areas(index, (2, 5), None, ) - self.__add_item_to_areas(index, (2, 6), None, ) - self.__areas[index].armor = self._inner_amor_store.get_arm_amore() - else: - self.__areas[index].armor = self._inner_amor_store.get_leg_amore() - parent.children.append(self.__areas[index]) + area_factory = AreaFactory(AreaNames.LEFT_TORSO, self.__areas[AreaNames.MIDDLE_TORSO].area) + self.__areas[AreaNames.LEFT_TORSO] = area_factory + self.__outer_armor_builder.add_area(AreaNames.LEFT_TORSO, area_factory.area) + + area_factory = AreaFactory(AreaNames.RIGHT_TORSO, self.__areas[AreaNames.MIDDLE_TORSO].area) + self.__areas[AreaNames.RIGHT_TORSO] = area_factory + self.__outer_armor_builder.add_area(AreaNames.RIGHT_TORSO, area_factory.area) + + def __build_arm_leg(self, index: AreaNames, parent_index: AreaNames) -> None: + area_factory = AreaFactory(index, self.__areas[parent_index].area) + self.__areas[index] = area_factory + self.__outer_armor_builder.add_area(index, area_factory.area) def auslieferung(self) -> Mech: - for (index, outer_amor) in self.__zones.items(): + for (index, area_factory) in self.__areas: + self._inner_structure.add_area(index, area_factory.area) + for (index, outer_amor) in self.__outer_armor_builder: self._inner_structure.add_zone(index, outer_amor) - return self._mech + return Mech(self.__name, self.__tonnage, self.__movement_rate, self._inner_structure) + + def set_head_armor(self, armor: int) -> None: + self.__outer_armor_builder.set_head_armor(armor) + + def set_middle_torso_armor(self, armor_front: int, armor_rear: int) -> None: + self.__outer_armor_builder.set_middle_torso_armor(armor_front, armor_rear) + + def set_side_torso_armor(self, armor_front: int, armor_rear: int) -> None: + self.__outer_armor_builder.set_side_torso_armor(armor_front, armor_rear) + + def set_arm_armor(self, armor: int) -> None: + self.__outer_armor_builder.set_arm_armor(armor) + + def set_leg_armor(self, armor: int) -> None: + self.__outer_armor_builder.set_leg_armor(armor) + + def add_jump_jet(self, area_name: AreaNames, count: int) -> None: + for index in range(count): + self._add_item(area_name, self._component_store.get_jump_jet()) + + def _add_item(self, area_name: AreaNames, area_item: Item) -> None: + self.__areas[area_name].add_item(area_item) + +class AreaDict: + def __init__(self): + self.__areas = {} + + def __setitem__(self, key, value): + if not isinstance(key, AreaNames): + raise TypeError("key must be an AreaNames object") + if not isinstance(value, AreaFactory): + raise TypeError("value must be an AreaFactory object") + self.__areas[key] = value + + def __getitem__(self, key) -> AreaFactory: + if not isinstance(key, AreaNames): + raise TypeError("key must be an AreaNames object") + if key not in self.__areas: + raise KeyError("AreaFactory does not exist") + return self.__areas[key] + + def __iter__(self): + for (index, area_factory) in self.__areas.items(): + yield index, area_factory + + +class AbstractMechFactory: + _inner_amor_store = None + _component_store = None + _item_store = None + _watcher = None + + @classmethod + def set_stores(cls, inner_amor: InnerAmorStore, component: ComponentStore, item: ItemStore) -> None: + cls._inner_amor_store = inner_amor + cls._component_store = component + cls._item_store = item + + @classmethod + def set_inner_amor_store(cls, inner_amor_store: InnerAmorStore) -> None: + cls._inner_amor_store = inner_amor_store + + @classmethod + def set_component_store(cls, component_store: ComponentStore) -> None: + cls._component_store = component_store + + @classmethod + def set_watcher(cls, my_watcher: Watcher) -> None: + cls._watcher = my_watcher + + +class OuterArmorFactory(AbstractMechFactory): + + def __init__(self): + super().__init__() + self._my_zones = {} + + def add_area(self, area_name: AreaNames, area: Area) -> None: + match area_name: + case AreaNames.HEAD: + self._my_zones[ZoneNames.HEAD] = OuterAmor(area) + case AreaNames.MIDDLE_TORSO: + self._my_zones[ZoneNames.MIDDLE_TORSO_FRONT] = OuterAmor(area) + self._my_zones[ZoneNames.MIDDLE_TORSO_REAR] = OuterAmor(area) + case AreaNames.LEFT_TORSO: + self._my_zones[ZoneNames.LEFT_TORSO_FRONT] = OuterAmor(area) + self._my_zones[ZoneNames.LEFT_TORSO_REAR] = OuterAmor(area) + case AreaNames.RIGHT_TORSO: + self._my_zones[ZoneNames.RIGHT_TORSO_FRONT] = OuterAmor(area) + self._my_zones[ZoneNames.RIGHT_TORSO_REAR] = OuterAmor(area) + case AreaNames.LEFT_ARM: + self._my_zones[ZoneNames.LEFT_ARM] = OuterAmor(area) + case AreaNames.RIGHT_ARM: + self._my_zones[ZoneNames.RIGHT_ARM] = OuterAmor(area) + case AreaNames.LEFT_LEG: + self._my_zones[ZoneNames.LEFT_LEG] = OuterAmor(area) + case AreaNames.RIGHT_LEG: + self._my_zones[ZoneNames.RIGHT_LEG] = OuterAmor(area) def set_head_armor(self, armor: int) -> None: self._watcher.add_armor(AreaNames.HEAD, armor) - self.__set_outer_armor(armor, ZoneNames.HEAD, AreaNames.HEAD) + self._my_zones[ZoneNames.HEAD].armor = armor - 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_middle_torso_armor(self, armor_front: int, armor_rear: int) -> None: + self._watcher.add_armor(AreaNames.MIDDLE_TORSO, armor_front + armor_rear) + self._my_zones[ZoneNames.MIDDLE_TORSO_FRONT].armor = armor_front + self._my_zones[ZoneNames.MIDDLE_TORSO_REAR].armor = armor_rear - 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_side_torso_armor(self, armor_front: int, armor_rear: int) -> None: + self._watcher.add_armor(AreaNames.LEFT_TORSO, armor_front + armor_rear) + self._my_zones[ZoneNames.LEFT_TORSO_FRONT].armor = armor_front + self._my_zones[ZoneNames.LEFT_TORSO_REAR].armor = armor_rear + self._watcher.add_armor(AreaNames.RIGHT_TORSO, armor_front + armor_rear) + self._my_zones[ZoneNames.RIGHT_TORSO_FRONT].armor = armor_front + self._my_zones[ZoneNames.RIGHT_TORSO_REAR].armor = armor_rear def set_arm_armor(self, armor: int) -> None: self._watcher.add_armor(AreaNames.LEFT_ARM, armor) + self._my_zones[ZoneNames.LEFT_ARM].armor = 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) + self._my_zones[ZoneNames.RIGHT_ARM].armor = armor def set_leg_armor(self, armor: int) -> None: self._watcher.add_armor(AreaNames.LEFT_LEG, armor) + self._my_zones[ZoneNames.LEFT_LEG].armor = 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) + self._my_zones[ZoneNames.RIGHT_LEG].armor = armor - def __set_outer_armor(self, armor: int, zone_name: ZoneNames, parent_name: AreaNames) -> None: - 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 __iter__(self): + for (index, outer_amor) in self._my_zones.items(): + yield index, outer_amor - 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) + @property + def outer_armors(self) -> dict[ZoneNames, OuterAmor]: + return self._my_zones + + +class AreaFactory(AbstractMechFactory): + + def __init__(self, area_name: AreaNames, parent: Area | None) -> None: + super().__init__() + self.__area_name = area_name + self._my_area = Area() + if parent is not None: + parent.children.append(self._my_area) + self._my_area.parent = parent + self._area_item_factory = AreaItemsFactory(self) + self._set_armor() + + def _set_armor(self) -> None: + match self.__area_name: + case AreaNames.HEAD: + self._my_area.armor = 3 + case AreaNames.MIDDLE_TORSO: + self._my_area.armor = self._inner_amor_store.get_middle_torso_amor() + case AreaNames.LEFT_TORSO | AreaNames.RIGHT_TORSO: + self._my_area.armor = self._inner_amor_store.get_side_torso_amor() + case AreaNames.LEFT_ARM | AreaNames.RIGHT_ARM: + self._my_area.armor = self._inner_amor_store.get_arm_amore() + case AreaNames.LEFT_LEG | AreaNames.RIGHT_LEG: + self._my_area.armor = self._inner_amor_store.get_leg_amore() + + def add_item(self, area_item: Item) -> None: + self._area_item_factory.add_item(area_item) + + def set_item_to(self, index: tuple[int, int], area_item: Item) -> None: + self._area_item_factory.set_item_to(index, area_item) + + @property + def area(self) -> Area: + return self._my_area + + @property + def area_name(self): + return self.__area_name + + @property + def areas(self) -> dict[AreaNames, Area]: + return {self.__area_name: self._my_area} + + +class AreaItemsFactory(AbstractMechFactory): + __reactor = None + __cockpit = None + __gyroskope = None + + def __new__(cls, area_factory: AreaFactory): + if cls.__reactor is None: + cls.__reactor = cls._component_store.get_reaktor() + if cls.__cockpit is None: + cls.__cockpit = cls._item_store.get_cockpit() + if cls.__gyroskope is None: + cls.__gyroskope = cls._component_store.get_gyroskope() + instance = super().__new__(cls) + return instance + + def __init__(self, area_factory: AreaFactory) -> None: + super().__init__() + self.__area_factory = area_factory + area_factory.area.items = dict() + self.__lines = area_factory.area.items + self._set_lines() + match self.__area_factory.area_name: + case AreaNames.HEAD: + self.__build_as_head() + case AreaNames.MIDDLE_TORSO: + self.__build_as_middle_torso() + case AreaNames.LEFT_TORSO | AreaNames.RIGHT_TORSO: + pass + case AreaNames.LEFT_ARM | AreaNames.RIGHT_ARM | AreaNames.LEFT_LEG | AreaNames.RIGHT_LEG: + self.__build_as_arm_leg() + + def _set_lines(self): + for key in range(6): + self.__lines[(1, key + 1)] = None + if self.__area_factory.area_name.is_big(): + self.__lines[(2, key + 1)] = None + + def __build_as_head(self) -> None: + self.set_item_to((1, 1), self._item_store.get_sustainment(), ) + self.set_item_to((1, 2), self._item_store.get_sensors(), ) + self.set_item_to((1, 3), self.__cockpit, ) + self.set_item_to((1, 5), self._item_store.get_sensors(), ) + self.set_item_to((1, 6), self._item_store.get_sustainment(), ) + self.__area_factory.area.cockpit = self.__cockpit + + def __build_as_middle_torso(self) -> None: + self.set_item_to((1, 1), self.__reactor, ) + self.set_item_to((1, 2), self.__reactor, ) + self.set_item_to((1, 3), self.__reactor, ) + self.set_item_to((1, 4), self.__gyroskope, ) + self.set_item_to((1, 5), self.__gyroskope, ) + self.set_item_to((1, 6), self.__gyroskope, ) + self.set_item_to((2, 1), self.__gyroskope, ) + self.set_item_to((2, 2), self.__reactor, ) + self.set_item_to((2, 3), self.__reactor, ) + self.set_item_to((2, 4), self.__reactor, ) + self.__area_factory.area.reactor = self.__reactor + + def __build_as_arm_leg(self) -> None: + self.set_item_to((1, 1), self._item_store.get_joint(), ) + self.set_item_to((1, 2), self._item_store.get_activator(), ) + self.set_item_to((1, 3), self._item_store.get_activator(), ) + self.set_item_to((1, 4), self._item_store.get_activator(), ) + + def add_item(self, area_item: Item) -> None: + for (index, item) in self.__area_factory.area.items.items(): + if item is not None: + continue + self.set_item_to(index, area_item) + return + raise UserWarning('no more space') + + def set_item_to(self, index: tuple[int, int], area_item: Item) -> None: + self.__lines[index] = area_item + self._watcher.add_item(area_item) + + @property + def area(self) -> Area: + return self.__area_factory.area + + @property + def reactor(self) -> Reaktor: + return self.__reactor + + @property + def cockpit(self) -> Cockpit: + return self.__cockpit + + @property + def gyroskope(self) -> Gyroskope: + return self.__gyroskope diff --git a/mech_factory/component_storage/__init__.py b/mech_factory/component_storage/__init__.py index 1b214fd..c6404eb 100755 --- a/mech_factory/component_storage/__init__.py +++ b/mech_factory/component_storage/__init__.py @@ -27,6 +27,10 @@ class AreaNames(enum.Enum): LEFT_LEG = 'Linkes Bein' LEFT_ARM = 'Linker Arm' + def is_big(self): + return self in (AreaNames.MIDDLE_TORSO, AreaNames.LEFT_TORSO, AreaNames.RIGHT_TORSO, + AreaNames.LEFT_ARM, AreaNames.RIGHT_ARM) + class AreaStatus(enum.Flag): FINE = 0 @@ -52,7 +56,7 @@ class Area(Zone): def __init__(self): super().__init__() - self.__dict__['_outer_amor'] = list() + self.__dict__['_outer_armor'] = list() self.__dict__['_children'] = list() self.__dict__['_items'] = dict() diff --git a/mech_factory/component_storage/items.py b/mech_factory/component_storage/items.py index 9313704..2097f7c 100644 --- a/mech_factory/component_storage/items.py +++ b/mech_factory/component_storage/items.py @@ -9,6 +9,7 @@ class ItemTypes(enum.Enum): JOINT = 5 SENSORS = 6 SUSTAINMENT = 7 + JUMP_JET = 8 class ItemStatus(enum.Flag): @@ -103,3 +104,8 @@ class Sensors(DurableItem): class Sustainment(Item): def __init__(self): super().__init__(ItemTypes.SUSTAINMENT) + +class JumpJet(BigItem): + def __init__(self, tonnage: float): + super().__init__(ItemTypes.JUMP_JET, tonnage) + diff --git a/mech_factory/reader.py b/mech_factory/reader.py index e8205cf..4f7f53e 100755 --- a/mech_factory/reader.py +++ b/mech_factory/reader.py @@ -33,6 +33,9 @@ class ComponentReader: def inner_structure_from(self, tonnage: float) -> float: return float(self._inner_structure_data.get(tonnage, {}).get('Tonnage IS', 0.0)) + def jump_jet_from(self, tonnage: float) -> float: + return float(self._inner_structure_data.get(tonnage, {}).get('Tonnage SD', 0.0)) + def reactor_tonnage_from(self, reactor_value: int) -> float: return float(self._reactor_data.get(reactor_value, {}).get('Tonnage', 0.0)) diff --git a/mech_factory/store.py b/mech_factory/store.py index 17ebb74..18ccaf1 100644 --- a/mech_factory/store.py +++ b/mech_factory/store.py @@ -1,5 +1,6 @@ -from mech_factory import InnerStructure, Joint, Sustainment -from mech_factory.component_storage.items import Activator, Cockpit, Gyroskope, Reaktor, Sensors +from mech_factory import AreaNames, InnerStructure +from mech_factory.component_storage.items import Joint, Reaktor, Sustainment, Activator, Cockpit, Gyroskope, JumpJet, \ + Sensors from mech_factory.reader import ComponentReader @@ -8,6 +9,8 @@ class ComponentStore(object): self.__components_reader = ComponentReader() self.__tonnage = tonnage self.__reactor_value = int(movement_rate * tonnage) + self._jump_jet_tonnage = self.__components_reader.jump_jet_from(self.__tonnage) + ''' Erstellt den erforderlichen Reaktor ''' @@ -25,6 +28,12 @@ class ComponentStore(object): gyroscope = self.get_gyroskope() return InnerStructure(self.__components_reader.inner_structure_from(self.__tonnage), gyroscope) + ''' + Erstellt eine Sprungdüse + ''' + def get_jump_jet(self) -> JumpJet: + return JumpJet(self._jump_jet_tonnage) + # noinspection PyMethodMayBeStatic class ItemStore(object): @@ -75,6 +84,19 @@ class InnerAmorStore: def __init__(self, tonnage: float): self.__inner_structure_data = ComponentReader().inner_amor_for_tonnage(tonnage) + def get_armor_for_area(self, area_name: AreaNames) -> int: + match area_name: + case AreaNames.HEAD: + return self.get_head_amor() + case AreaNames.MIDDLE_TORSO: + return self.get_middle_torso_amor() + case AreaNames.LEFT_TORSO | AreaNames.RIGHT_TORSO: + return self.get_side_torso_amor() + case AreaNames.LEFT_ARM | AreaNames.RIGHT_ARM: + return self.get_arm_amore() + case AreaNames.LEFT_LEG | AreaNames.RIGHT_LEG: + return self.get_leg_amore() + def get_head_amor(self) -> int: return self.__inner_structure_data['head'] diff --git a/mech_factory/watcher/__init__.py b/mech_factory/watcher/__init__.py index 5c3dd8a..d9b6dbc 100644 --- a/mech_factory/watcher/__init__.py +++ b/mech_factory/watcher/__init__.py @@ -1,17 +1,16 @@ from typing import Any +from mech_factory.store import InnerAmorStore from mech_factory.component_storage import AreaNames, InnerStructure from mech_factory.component_storage.items import BigItem class Watcher: - def __init__(self, tonnage: float): + def __init__(self, tonnage: float, inner_armor_store: InnerAmorStore): self._tonnage = tonnage self._weight_watcher = WeightWatcher(tonnage) - self._amor_watcher = ArmorWatcher() + self._amor_watcher = ArmorWatcher(inner_armor_store) 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 @@ -27,8 +26,8 @@ class Watcher: class ArmorWatcher: - def __init__(self): - self._inner_structure = None + def __init__(self, inner_armor_store: InnerAmorStore): + self._inner_armor_store = inner_armor_store self._areas = {} @property @@ -38,15 +37,15 @@ class ArmorWatcher: 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)) + match area: + case AreaNames.HEAD: + if armor > 9: + raise ValueError(AreaNames.HEAD.name + 'Armor cannot be greater than 9') + case _: + max_armor = self._inner_armor_store.get_armor_for_area(area) * 2 + if armor > max_armor: + raise ValueError(AreaNames.HEAD.name + 'Armor cannot be greater than ' + str(max_armor)) self._areas[area] = armor class WeightWatcher: @@ -62,7 +61,7 @@ class WeightWatcher: def add_item(self, item: Any) -> Any: if isinstance(item, BigItem): self._items[item] = item.tonnage - if isinstance(item, InnerStructure): + elif isinstance(item, InnerStructure): self._items[item] = item.tonnage return item diff --git a/tests/test_mech/__init__.py b/tests/test_mech/__init__.py index 047914d..ddf9804 100644 --- a/tests/test_mech/__init__.py +++ b/tests/test_mech/__init__.py @@ -1,31 +1,32 @@ import unittest -from mech_factory import MechFabrik -from mech_factory.component_storage import AreaNames, ZoneNames +from mech_factory import MechBuilder +from mech_factory.component_storage import Area, AreaNames, ZoneNames +from mech_factory.component_storage.items import Item INNER_ARMOR = { AreaNames.HEAD: 3, - AreaNames.MIDDLE_TORSO: 6, - AreaNames.LEFT_TORSO: 5, - AreaNames.RIGHT_TORSO: 5, - AreaNames.LEFT_ARM: 3, - AreaNames.RIGHT_ARM: 3, - AreaNames.LEFT_LEG: 4, - AreaNames.RIGHT_LEG: 4, + AreaNames.MIDDLE_TORSO: 18, + AreaNames.LEFT_TORSO: 13, + AreaNames.RIGHT_TORSO: 13, + AreaNames.LEFT_ARM: 9, + AreaNames.RIGHT_ARM: 9, + AreaNames.LEFT_LEG: 13, + AreaNames.RIGHT_LEG: 13, } ## entspricht 64 Punkte → 4 t Panzerung OUTER_ARMOR = { - ZoneNames.HEAD: 6, - ZoneNames.MIDDLE_TORSO_FRONT: 8, - ZoneNames.MIDDLE_TORSO_REAR: 4, - ZoneNames.LEFT_TORSO_FRONT: 8, - ZoneNames.LEFT_TORSO_REAR: 2, - ZoneNames.RIGHT_TORSO_FRONT: 8, - ZoneNames.RIGHT_TORSO_REAR: 2, - ZoneNames.LEFT_ARM: 5, - ZoneNames.RIGHT_ARM: 5, - ZoneNames.LEFT_LEG: 8, - ZoneNames.RIGHT_LEG: 8, + ZoneNames.HEAD: 8, + ZoneNames.MIDDLE_TORSO_FRONT: 20, + ZoneNames.MIDDLE_TORSO_REAR: 8, + ZoneNames.LEFT_TORSO_FRONT: 20, + ZoneNames.LEFT_TORSO_REAR: 6, + ZoneNames.RIGHT_TORSO_FRONT: 20, + ZoneNames.RIGHT_TORSO_REAR: 6, + ZoneNames.LEFT_ARM: 16, + ZoneNames.RIGHT_ARM: 16, + ZoneNames.LEFT_LEG: 16, + ZoneNames.RIGHT_LEG: 16, } NEXT_OUTER_ZONE = { @@ -46,7 +47,12 @@ NEXT_OUTER_ZONE = { class AbstractTestMech(unittest.TestCase): def setUp(self): - self.factory = MechFabrik('Heuschrecke', 20.0, 8) + self.factory = MechBuilder('STP-6W Steppenwolf', 55.0, 5) + + def _test_for_items(self, area: Area, should_list: list): + for (key, item_type) in should_list: + self.assertIsInstance(area.items[key], Item) + self.assertEqual(area.items[key].type, item_type) class AbstractTestMechAmor(AbstractTestMech): @@ -58,3 +64,6 @@ class AbstractTestMechAmor(AbstractTestMech): 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]) + self.factory.add_jump_jet(AreaNames.MIDDLE_TORSO, 1) + self.factory.add_jump_jet(AreaNames.RIGHT_LEG, 2) + self.factory.add_jump_jet(AreaNames.LEFT_LEG, 2) diff --git a/tests/test_mech_bau.py b/tests/test_mech_bau.py index 8c5f2b8..57f3720 100755 --- a/tests/test_mech_bau.py +++ b/tests/test_mech_bau.py @@ -10,11 +10,11 @@ class TestMechBau(AbstractTestMech): self.mech = self.factory.auslieferung() self.assertIsInstance(self.mech, Mech) self.assertIsInstance(self.mech.name, str) - self.assertEqual('Heuschrecke', self.mech.name) + self.assertEqual('STP-6W Steppenwolf', self.mech.name) self.assertIsInstance(self.mech.tonnage, float) - self.assertEqual(20.0, self.mech.tonnage) + self.assertEqual(55.0, self.mech.tonnage) self.assertIsInstance(self.mech.movement_rate, int) - self.assertEqual(8, self.mech.movement_rate) + self.assertEqual(5, self.mech.movement_rate) for ara_name in AreaNames: area = self.mech.inner_structure.areas.get(ara_name) @@ -31,11 +31,11 @@ class TestMechBau(AbstractTestMech): self.assertIsInstance(self.mech.inner_structure, InnerStructure) self.assertIsInstance(self.mech.inner_structure.tonnage, float) - self.assertEqual(2.0, self.mech.inner_structure.tonnage) + self.assertEqual(5.5, self.mech.inner_structure.tonnage) self.assertIsInstance(self.mech.inner_structure.gyroskope, Gyroskope) self.assertIsInstance(self.mech.inner_structure.gyroskope.tonnage, float) - self.assertEqual(2.0, self.mech.inner_structure.gyroskope.tonnage) + self.assertEqual(3.0, self.mech.inner_structure.gyroskope.tonnage) self.assertIsInstance(self.mech.inner_structure.areas, dict) area_head = self.mech.inner_structure.areas.get(AreaNames.HEAD) @@ -49,9 +49,13 @@ class TestMechBau(AbstractTestMech): middle_torso = self._test_middle_torso() right_torso = self._test_areas(parent=middle_torso, index=AreaNames.RIGHT_TORSO, children=2) left_torso = self._test_areas(parent=middle_torso, index=AreaNames.LEFT_TORSO, children=2) + self._test_middle_torso() + self._test_for_middle_torso_items(middle_torso) + self._test_for_side_torso_items(right_torso) + self._test_for_side_torso_items(left_torso) self.assertIsInstance(area_head.parent, Area) self.assertEqual(middle_torso, area_head.parent) - self.assertCountEqual([right_torso, left_torso], middle_torso.children) + self.assertCountEqual([area_head, right_torso, left_torso], middle_torso.children) right_arm = self._test_areas(parent=right_torso, index=AreaNames.RIGHT_ARM, children=0) right_leg = self._test_areas(parent=right_torso, index=AreaNames.RIGHT_LEG, children=0) @@ -70,9 +74,9 @@ class TestMechBau(AbstractTestMech): reactor = middle_torso.reactor self.assertIsInstance(reactor, Reaktor) self.assertIsInstance(reactor.value, int) - self.assertEqual(160, reactor.value) + self.assertEqual(275, reactor.value) self.assertIsInstance(reactor.tonnage, float) - self.assertEqual(6.0, reactor.tonnage) + self.assertEqual(15.5, reactor.tonnage) self.assertIsNone(middle_torso.parent) self.assertIsInstance(middle_torso.children, list) return middle_torso @@ -88,7 +92,7 @@ class TestMechBau(AbstractTestMech): def _test_for_head_items(self, area: Area): self.assertEqual(6, len(area.items)) - self.__test_for_items(area, [ + self._test_for_items(area, [ ((1, 1), ItemTypes.SUSTAINMENT), ((1, 2), ItemTypes.SENSORS), ((1, 3), ItemTypes.COCKPIT), @@ -100,7 +104,7 @@ class TestMechBau(AbstractTestMech): def _test_for_middle_torso_items(self, area: Area): self.assertEqual(12, len(area.items)) - self.__test_for_items(area, [ + self._test_for_items(area, [ ((1, 1), ItemTypes.REAKTOR), ((1, 2), ItemTypes.REAKTOR), ((1, 3), ItemTypes.REAKTOR), @@ -109,8 +113,8 @@ class TestMechBau(AbstractTestMech): ((1, 6), ItemTypes.GYROSKOPE), ((2, 1), ItemTypes.GYROSKOPE), - ((2, 2), ItemTypes.GYROSKOPE), - ((2, 3), ItemTypes.GYROSKOPE), + ((2, 2), ItemTypes.REAKTOR), + ((2, 3), ItemTypes.REAKTOR), ((2, 4), ItemTypes.REAKTOR), ] ) @@ -120,7 +124,7 @@ class TestMechBau(AbstractTestMech): 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]) + self.assertIsNone(area.items[(group, key)]) def _test_for_arm_items(self, area: Area): self.assertEqual(12, len(area.items)) @@ -135,7 +139,7 @@ class TestMechBau(AbstractTestMech): pass def _test_for_arm_leg_items(self, area: Area): - self.__test_for_items(area, [ + self._test_for_items(area, [ ((1, 1), ItemTypes.JOINT), ((1, 2), ItemTypes.ACTIVATOR), ((1, 3), ItemTypes.ACTIVATOR), @@ -146,11 +150,6 @@ class TestMechBau(AbstractTestMech): self.assertIsNone(area.items[(1, 6)]) pass - def __test_for_items(self, area: Area, should_list: list): - for (key, item_type) in should_list: - self.assertIsInstance(area.items[key], Item) - self.assertEqual(area.items[key].type, item_type) - class TestMechAmor(AbstractTestMechAmor): @@ -171,13 +170,14 @@ class TestMechWeightWatch(AbstractTestMechAmor): Aufstellung Gewichte: Bauteil | Gewicht in Tonnen ------------------------------------ - Reaktor | 6.0 - Gyroskope | 2.0 - Interne-Struktur | 2.0 + Reaktor | 15.5 + Gyroskope | 3.0 + Interne-Struktur | 5.5 Cockpit | 3.0 - Panzerung | 4.0 + Panzerung | 9.5 + Sprungdüsen | 2.5 ------------------------------------ - | 17.0 + | 39.0 ''' - self.assertEqual(17.0, watcher.actual_weight) - self.assertEqual(3.0, watcher.rest_weight) + self.assertEqual(39.0, watcher.actual_weight) + self.assertEqual(16.0, watcher.rest_weight) diff --git a/tests/test_mech_process.py b/tests/test_mech_process.py index cfb4d3e..32b7256 100755 --- a/tests/test_mech_process.py +++ b/tests/test_mech_process.py @@ -157,3 +157,35 @@ class TestMechAmor(AbstractTestMechAmor): self.assertIsInstance(event, CriticalStrikeEvent) self.assertTrue(event.is_empty()) self.assertEqual(area, event.area) + +class TestMovement(AbstractTestMechAmor): + + def test_walk(self): + self.mech = self.factory.auslieferung() + self.mech.exchange_heat() + self.assertEqual(0, self.mech.actual_heat) + with self.assertRaises(ValueError): + self.mech.walk(9) + self.mech.walk(5) + self.assertEqual(1, self.mech.actual_heat) + self.mech.exchange_heat() + self.assertEqual(0, self.mech.actual_heat) + self.mech.walk(8) + self.assertEqual(2, self.mech.actual_heat) + self.mech.exchange_heat() + self.assertEqual(0, self.mech.actual_heat) + + def test_jump(self): + self.mech = self.factory.auslieferung() + self.mech.exchange_heat() + self.assertEqual(0, self.mech.actual_heat) + with self.assertRaises(ValueError): + self.mech.jump(6) + self.mech.jump(5) + self.assertEqual(5, self.mech.actual_heat) + self.mech.exchange_heat() + self.assertEqual(0, self.mech.actual_heat) + self.mech.jump(2) + self.assertEqual(3, self.mech.actual_heat) + self.mech.exchange_heat() + self.assertEqual(0, self.mech.actual_heat) \ No newline at end of file diff --git a/tests/test_store.py b/tests/test_store.py index 04315bd..3397d08 100644 --- a/tests/test_store.py +++ b/tests/test_store.py @@ -1,8 +1,8 @@ import unittest -from mech_factory import InnerStructure, Reaktor +from mech_factory.component_storage import InnerStructure from mech_factory.store import ComponentStore, ItemStore, InnerAmorStore -from mech_factory.component_storage.items import Gyroskope, Item, BigItem, DurableItem, ItemStatus, ItemTypes +from mech_factory.component_storage.items import Gyroskope, Item, BigItem, DurableItem, ItemStatus, ItemTypes, Reaktor class TestComponentStore(unittest.TestCase):