Compare commits

...
11 changed files with 477 additions and 187 deletions
+35 -2
View File
@@ -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)
return CriticalStrikeEvent(zone, index)
def exchange_heat(self):
self._actual_heat = 0
+300 -118
View File
@@ -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
+5 -1
View File
@@ -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()
+6
View File
@@ -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)
+3
View File
@@ -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))
+24 -2
View File
@@ -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']
+14 -15
View File
@@ -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
+30 -21
View File
@@ -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)
+26 -26
View File
@@ -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)
+32
View File
@@ -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)
+2 -2
View File
@@ -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):