Compare commits
24
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
7798b41efc | ||
|
|
56235ced39 | ||
|
|
e5bbb8bd9f | ||
|
|
39f6e090d6 | ||
|
|
ef49fc4abf | ||
|
|
9290884774 | ||
|
|
56752a8a4d | ||
|
|
8518249906 | ||
|
|
8e04467d4a | ||
|
|
1bb5cff5fa | ||
|
|
ddce601527 | ||
|
|
9870c41799 | ||
|
|
402370cf8a | ||
|
|
939b2cef92 | ||
|
|
36779ac715 | ||
|
|
af2d943094 | ||
|
|
e4ed45e2fb | ||
|
|
dbbd772c69 | ||
|
|
84236eb324 | ||
|
|
d4002624f4 | ||
|
|
22fbdaa82f | ||
|
|
d8df5db7f4 | ||
|
|
0c985589a2 | ||
|
|
861b073633 |
@@ -1,35 +0,0 @@
|
||||
from MechFabrik.bauteile import InnerStructure, Item, StrikeEvent, ZoneNames
|
||||
|
||||
|
||||
class Mech(object):
|
||||
|
||||
def __init__(self, name: str, tonnage: float, movement_rate: int, inner_structure: InnerStructure):
|
||||
self._movement_rate = movement_rate
|
||||
self._tonnage = tonnage
|
||||
self._name = name
|
||||
self._inner_structure = inner_structure
|
||||
|
||||
@property
|
||||
def name(self) -> str:
|
||||
return self._name
|
||||
|
||||
@property
|
||||
def tonnage(self) -> float:
|
||||
return self._tonnage
|
||||
|
||||
@property
|
||||
def inner_structure(self) -> InnerStructure:
|
||||
return self._inner_structure
|
||||
|
||||
@property
|
||||
def movement_rate(self) -> int:
|
||||
return self._movement_rate
|
||||
|
||||
def set_item(self, key: tuple, item: Item):
|
||||
pass
|
||||
|
||||
def strike(self, zone_name: ZoneNames, hits: int) -> StrikeEvent:
|
||||
zone = self._inner_structure.zones.get(zone_name)
|
||||
if zone is None:
|
||||
raise Exception(f"Zone {zone_name} not found")
|
||||
return StrikeEvent(zone, hits)
|
||||
@@ -1,161 +0,0 @@
|
||||
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
|
||||
|
||||
|
||||
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 = {
|
||||
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.__build_inner_structure(tonnage, movement_rate)
|
||||
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()
|
||||
self.__areas[AreaNames.HEAD].cockpit = cockpit
|
||||
self.__areas[AreaNames.HEAD].items = {
|
||||
(1, 1): Sustainment(),
|
||||
(1, 2): Sensors(),
|
||||
(1, 3): cockpit,
|
||||
(1, 4): None,
|
||||
(1, 5): Sensors(),
|
||||
(1, 6): Sustainment(),
|
||||
}
|
||||
self.__areas[AreaNames.HEAD].armor = 3
|
||||
self.__areas[AreaNames.HEAD].parent = self.__areas[AreaNames.MIDDLE_TORSO]
|
||||
|
||||
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))
|
||||
self.__areas[AreaNames.MIDDLE_TORSO].reactor = reactor
|
||||
self.__areas[AreaNames.MIDDLE_TORSO].children = [
|
||||
self.__areas[AreaNames.RIGHT_TORSO],
|
||||
self.__areas[AreaNames.LEFT_TORSO]
|
||||
]
|
||||
self.__areas[AreaNames.MIDDLE_TORSO].items = {
|
||||
(1, 1): reactor,
|
||||
(1, 2): reactor,
|
||||
(1, 3): reactor,
|
||||
(1, 4): gyroscope,
|
||||
(1, 5): gyroscope,
|
||||
(1, 6): gyroscope,
|
||||
(2, 1): gyroscope,
|
||||
(2, 2): reactor,
|
||||
(2, 3): reactor,
|
||||
(2, 4): reactor,
|
||||
(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.__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)
|
||||
self.__build_leg(self.__areas[AreaNames.LEFT_TORSO], AreaNames.LEFT_LEG)
|
||||
|
||||
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, 5): None,
|
||||
(1, 6): None,
|
||||
(2, 1): None,
|
||||
(2, 2): None,
|
||||
(2, 3): None,
|
||||
(2, 4): None,
|
||||
(2, 5): None,
|
||||
(2, 6): None,
|
||||
}
|
||||
self.__areas[index].armor = self.__components.inner_amor_for_tonnage_and_area(self.__tonnage, index)
|
||||
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, 5): None,
|
||||
(1, 6): None,
|
||||
}
|
||||
self.__areas[index].armor = self.__components.inner_amor_for_tonnage_and_area(self.__tonnage, index)
|
||||
parent.children.append(self.__areas[index])
|
||||
|
||||
def auslieferung(self) -> Mech:
|
||||
for (index, area) in self.__areas.items():
|
||||
self._inner_structure.add_area(index, area)
|
||||
for (index, outer_amor) in self.__zones.items():
|
||||
self._inner_structure.add_zone(index, outer_amor)
|
||||
return self._mech
|
||||
|
||||
def set_head_armor(self, armor: int) -> None:
|
||||
self.__set_outer_armor(armor, ZoneNames.HEAD, AreaNames.HEAD)
|
||||
|
||||
def set_middle_torso_armor(self, armor_front: int, amor_rear: int) -> None:
|
||||
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_side_torso_armor(self, armor_front: int, amor_rear: int) -> None:
|
||||
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.__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_arm_armor(self, armor: int) -> None:
|
||||
self.__set_outer_armor(armor, ZoneNames.LEFT_ARM, AreaNames.LEFT_ARM)
|
||||
self.__set_outer_armor(armor, ZoneNames.RIGHT_ARM, AreaNames.RIGHT_ARM)
|
||||
|
||||
def set_leg_armor(self, armor: int) -> None:
|
||||
self.__set_outer_armor(armor, ZoneNames.LEFT_LEG, AreaNames.LEFT_LEG)
|
||||
self.__set_outer_armor(armor, ZoneNames.RIGHT_LEG, AreaNames.RIGHT_LEG)
|
||||
|
||||
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])
|
||||
@@ -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)
|
||||
@@ -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']
|
||||
@@ -0,0 +1,75 @@
|
||||
import math
|
||||
|
||||
from events import CriticalStrikeEvent, StrikeEvent
|
||||
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:
|
||||
return self._name
|
||||
|
||||
@property
|
||||
def tonnage(self) -> float:
|
||||
return self._tonnage
|
||||
|
||||
@property
|
||||
def inner_structure(self) -> InnerStructure:
|
||||
return self._inner_structure
|
||||
|
||||
@property
|
||||
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:
|
||||
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)
|
||||
|
||||
def exchange_heat(self):
|
||||
self._actual_heat = 0
|
||||
Executable
+338
@@ -0,0 +1,338 @@
|
||||
from hangar.mech import Mech
|
||||
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 MechBuilder(object):
|
||||
|
||||
def __init__(self, name: str, tonnage: float, movement_rate: int):
|
||||
self.__name = name
|
||||
self.__tonnage = tonnage
|
||||
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)
|
||||
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()
|
||||
self._watcher.add_item(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:
|
||||
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_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)
|
||||
|
||||
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, 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 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._my_zones[ZoneNames.HEAD].armor = armor
|
||||
|
||||
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, 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._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._my_zones[ZoneNames.RIGHT_LEG].armor = armor
|
||||
|
||||
def __iter__(self):
|
||||
for (index, outer_amor) in self._my_zones.items():
|
||||
yield index, outer_amor
|
||||
|
||||
@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
|
||||
@@ -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):
|
||||
@@ -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()
|
||||
|
||||
@@ -65,48 +69,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 +93,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
|
||||
|
||||
@@ -0,0 +1,111 @@
|
||||
import enum
|
||||
|
||||
|
||||
class ItemTypes(enum.Enum):
|
||||
COCKPIT = 1
|
||||
REAKTOR = 2
|
||||
GYROSKOPE = 3
|
||||
ACTIVATOR = 4
|
||||
JOINT = 5
|
||||
SENSORS = 6
|
||||
SUSTAINMENT = 7
|
||||
JUMP_JET = 8
|
||||
|
||||
|
||||
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)
|
||||
|
||||
class JumpJet(BigItem):
|
||||
def __init__(self, tonnage: float):
|
||||
super().__init__(ItemTypes.JUMP_JET, tonnage)
|
||||
|
||||
@@ -1,8 +1,6 @@
|
||||
import csv
|
||||
import os.path
|
||||
|
||||
from MechFabrik import AreaNames
|
||||
|
||||
|
||||
# noinspection SpellCheckingInspection
|
||||
class CsvDialect(csv.Dialect):
|
||||
@@ -35,18 +33,17 @@ 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))
|
||||
|
||||
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)),
|
||||
}
|
||||
@@ -0,0 +1,113 @@
|
||||
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
|
||||
|
||||
|
||||
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)
|
||||
self._jump_jet_tonnage = self.__components_reader.jump_jet_from(self.__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)
|
||||
|
||||
'''
|
||||
Erstellt eine Sprungdüse
|
||||
'''
|
||||
def get_jump_jet(self) -> JumpJet:
|
||||
return JumpJet(self._jump_jet_tonnage)
|
||||
|
||||
|
||||
# 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_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']
|
||||
|
||||
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']
|
||||
@@ -0,0 +1,69 @@
|
||||
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, inner_armor_store: InnerAmorStore):
|
||||
self._tonnage = tonnage
|
||||
self._weight_watcher = WeightWatcher(tonnage)
|
||||
self._amor_watcher = ArmorWatcher(inner_armor_store)
|
||||
|
||||
def add_item(self, item: Any) -> Any:
|
||||
return self._weight_watcher.add_item(item)
|
||||
|
||||
@property
|
||||
def actual_weight(self):
|
||||
return self._weight_watcher.actual_weight + self._amor_watcher.actual_armor_tonnage
|
||||
|
||||
@property
|
||||
def rest_weight(self):
|
||||
return self._tonnage - self.actual_weight
|
||||
|
||||
def add_armor(self, area: AreaNames, armor: int):
|
||||
self._amor_watcher.add_armor(area, armor)
|
||||
|
||||
|
||||
class ArmorWatcher:
|
||||
def __init__(self, inner_armor_store: InnerAmorStore):
|
||||
self._inner_armor_store = inner_armor_store
|
||||
self._areas = {}
|
||||
|
||||
@property
|
||||
def actual_armor_tonnage(self):
|
||||
actual_armor = sum(self._areas.values())
|
||||
if actual_armor % 8 > 0:
|
||||
raise ValueError('Armor is not valid')
|
||||
return actual_armor / 16
|
||||
|
||||
def add_armor(self, area: AreaNames, armor: int):
|
||||
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:
|
||||
def __init__(self, max_weight: float):
|
||||
self._max_weight = max_weight
|
||||
self._items = {}
|
||||
self._armor = 0
|
||||
|
||||
@property
|
||||
def actual_weight(self):
|
||||
return sum(self._items.values())
|
||||
|
||||
def add_item(self, item: Any) -> Any:
|
||||
if isinstance(item, BigItem):
|
||||
self._items[item] = item.tonnage
|
||||
elif isinstance(item, InnerStructure):
|
||||
self._items[item] = item.tonnage
|
||||
return item
|
||||
|
||||
def set_armor(self, armor: int):
|
||||
self._armor = armor
|
||||
+41
-29
@@ -1,31 +1,32 @@
|
||||
import unittest
|
||||
|
||||
from MechFabrik import MechFabrik
|
||||
from MechFabrik.bauteile 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: 9,
|
||||
ZoneNames.MIDDLE_TORSO_REAR: 4,
|
||||
ZoneNames.LEFT_TORSO_FRONT: 8,
|
||||
ZoneNames.LEFT_TORSO_REAR: 3,
|
||||
ZoneNames.RIGHT_TORSO_FRONT: 8,
|
||||
ZoneNames.RIGHT_TORSO_REAR: 3,
|
||||
ZoneNames.LEFT_ARM: 5,
|
||||
ZoneNames.RIGHT_ARM: 5,
|
||||
ZoneNames.LEFT_LEG: 7,
|
||||
ZoneNames.RIGHT_LEG: 7,
|
||||
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 = {
|
||||
@@ -43,15 +44,26 @@ NEXT_OUTER_ZONE = {
|
||||
}
|
||||
|
||||
|
||||
class AbstractTestMechAmor(unittest.TestCase):
|
||||
class AbstractTestMech(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
fabrik = MechFabrik('Heuschrecke', 20.0, 8)
|
||||
self.factory = MechBuilder('STP-6W Steppenwolf', 55.0, 5)
|
||||
|
||||
fabrik.set_head_armor(OUTER_ARMOR[ZoneNames.HEAD])
|
||||
fabrik.set_middle_torso_armor(OUTER_ARMOR[ZoneNames.MIDDLE_TORSO_FRONT],OUTER_ARMOR[ZoneNames.MIDDLE_TORSO_REAR])
|
||||
fabrik.set_side_torso_armor(OUTER_ARMOR[ZoneNames.LEFT_TORSO_FRONT],OUTER_ARMOR[ZoneNames.LEFT_TORSO_REAR])
|
||||
fabrik.set_arm_armor(OUTER_ARMOR[ZoneNames.LEFT_ARM])
|
||||
fabrik.set_leg_armor(OUTER_ARMOR[ZoneNames.LEFT_LEG])
|
||||
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)
|
||||
|
||||
self.mech = fabrik.auslieferung()
|
||||
|
||||
class AbstractTestMechAmor(AbstractTestMech):
|
||||
|
||||
def setUp(self):
|
||||
super(AbstractTestMechAmor, self).setUp()
|
||||
self.factory.set_head_armor(OUTER_ARMOR[ZoneNames.HEAD])
|
||||
self.factory.set_middle_torso_armor(OUTER_ARMOR[ZoneNames.MIDDLE_TORSO_FRONT],OUTER_ARMOR[ZoneNames.MIDDLE_TORSO_REAR])
|
||||
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)
|
||||
|
||||
+71
-53
@@ -1,48 +1,44 @@
|
||||
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 test_mech import AbstractTestMechAmor, INNER_ARMOR, OUTER_ARMOR
|
||||
from hangar.mech import Mech
|
||||
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 AbstractTestMech, AbstractTestMechAmor, INNER_ARMOR, OUTER_ARMOR
|
||||
|
||||
|
||||
class TestMechBau(unittest.TestCase):
|
||||
class TestMechBau(AbstractTestMech):
|
||||
|
||||
def test_simple(self):
|
||||
fabrik = MechFabrik('Heuschrecke', 20.0, 8)
|
||||
mech = fabrik.auslieferung()
|
||||
self.assertIsInstance(mech, Mech)
|
||||
self.assertIsInstance(mech.name, str)
|
||||
self.assertEqual('Heuschrecke', mech.name)
|
||||
self.assertIsInstance(mech.tonnage, float)
|
||||
self.assertEqual(20.0, mech.tonnage)
|
||||
self.assertIsInstance(mech.movement_rate, int)
|
||||
self.assertEqual(8, mech.movement_rate)
|
||||
self.mech = self.factory.auslieferung()
|
||||
self.assertIsInstance(self.mech, Mech)
|
||||
self.assertIsInstance(self.mech.name, str)
|
||||
self.assertEqual('STP-6W Steppenwolf', self.mech.name)
|
||||
self.assertIsInstance(self.mech.tonnage, float)
|
||||
self.assertEqual(55.0, self.mech.tonnage)
|
||||
self.assertIsInstance(self.mech.movement_rate, int)
|
||||
self.assertEqual(5, self.mech.movement_rate)
|
||||
|
||||
for ara_name in AreaNames:
|
||||
area = mech.inner_structure.areas.get(ara_name)
|
||||
area = self.mech.inner_structure.areas.get(ara_name)
|
||||
should_amor = INNER_ARMOR[ara_name]
|
||||
self.assertIsInstance(area, Zone)
|
||||
self.assertIsInstance(area, Area)
|
||||
self.assertEqual(should_amor, area.armor)
|
||||
|
||||
for zone_name in ZoneNames:
|
||||
zone = mech.inner_structure.zones.get(zone_name)
|
||||
zone = self.mech.inner_structure.zones.get(zone_name)
|
||||
self.assertIsInstance(zone, Zone)
|
||||
self.assertIsInstance(zone, OuterAmor)
|
||||
self.assertEqual(0, zone.armor)
|
||||
|
||||
self.assertIsInstance(mech.inner_structure, InnerStructure)
|
||||
self.assertIsInstance(mech.inner_structure.tonnage, float)
|
||||
self.assertEqual(2.0, mech.inner_structure.tonnage)
|
||||
self.assertIsInstance(self.mech.inner_structure, InnerStructure)
|
||||
self.assertIsInstance(self.mech.inner_structure.tonnage, float)
|
||||
self.assertEqual(5.5, self.mech.inner_structure.tonnage)
|
||||
|
||||
self.assertIsInstance(mech.inner_structure.gyroskope, Gyroskope)
|
||||
self.assertIsInstance(mech.inner_structure.gyroskope.tonnage, float)
|
||||
self.assertEqual(2.0, mech.inner_structure.gyroskope.tonnage)
|
||||
self.assertIsInstance(mech.inner_structure.areas, dict)
|
||||
self.assertIsInstance(self.mech.inner_structure.gyroskope, Gyroskope)
|
||||
self.assertIsInstance(self.mech.inner_structure.gyroskope.tonnage, float)
|
||||
self.assertEqual(3.0, self.mech.inner_structure.gyroskope.tonnage)
|
||||
self.assertIsInstance(self.mech.inner_structure.areas, dict)
|
||||
|
||||
area_head = mech.inner_structure.areas.get(AreaNames.HEAD)
|
||||
area_head = self.mech.inner_structure.areas.get(AreaNames.HEAD)
|
||||
self.assertIsInstance(area_head, Area)
|
||||
cockpit = area_head.cockpit
|
||||
self.assertIsInstance(cockpit, Cockpit)
|
||||
@@ -50,39 +46,43 @@ class TestMechBau(unittest.TestCase):
|
||||
self.assertEqual(3.0, cockpit.tonnage)
|
||||
self._test_for_head_items(area_head)
|
||||
|
||||
middle_torso = self._test_middle_torso(mech)
|
||||
right_torso = self._test_areas(mech=mech, parent=middle_torso, index=AreaNames.RIGHT_TORSO, children=2)
|
||||
left_torso = self._test_areas(mech=mech, parent=middle_torso, index=AreaNames.LEFT_TORSO, children=2)
|
||||
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(mech=mech, parent=right_torso, index=AreaNames.RIGHT_ARM, children=0)
|
||||
right_leg = self._test_areas(mech=mech, parent=right_torso, index=AreaNames.RIGHT_LEG, children=0)
|
||||
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)
|
||||
self.assertCountEqual([right_arm, right_leg], right_torso.children)
|
||||
self._test_for_arm_items(right_arm)
|
||||
self._test_for_leg_items(right_leg)
|
||||
left_arm = self._test_areas(mech=mech, parent=left_torso, index=AreaNames.LEFT_ARM, children=0)
|
||||
left_leg = self._test_areas(mech=mech, parent=left_torso, index=AreaNames.LEFT_LEG, children=0)
|
||||
left_arm = self._test_areas(parent=left_torso, index=AreaNames.LEFT_ARM, children=0)
|
||||
left_leg = self._test_areas(parent=left_torso, index=AreaNames.LEFT_LEG, children=0)
|
||||
self.assertCountEqual([left_arm, left_leg], left_torso.children)
|
||||
self._test_for_arm_items(left_arm)
|
||||
self._test_for_leg_items(left_leg)
|
||||
|
||||
def _test_middle_torso(self, mech) -> Area:
|
||||
middle_torso = mech.inner_structure.areas.get(AreaNames.MIDDLE_TORSO)
|
||||
def _test_middle_torso(self) -> Area:
|
||||
middle_torso = self.mech.inner_structure.areas.get(AreaNames.MIDDLE_TORSO)
|
||||
self.assertIsInstance(middle_torso, Area)
|
||||
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
|
||||
|
||||
def _test_areas(self, mech: Mech, parent: Area, index: AreaNames, children: int) -> Area:
|
||||
area = mech.inner_structure.areas.get(index)
|
||||
def _test_areas(self, parent: Area, index: AreaNames, children: int) -> Area:
|
||||
area = self.mech.inner_structure.areas.get(index)
|
||||
self.assertIsInstance(area, Area)
|
||||
self.assertIsInstance(area.parent, Area)
|
||||
self.assertEqual(parent, area.parent)
|
||||
@@ -92,7 +92,7 @@ class TestMechBau(unittest.TestCase):
|
||||
|
||||
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),
|
||||
@@ -104,7 +104,7 @@ class TestMechBau(unittest.TestCase):
|
||||
|
||||
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),
|
||||
@@ -113,8 +113,8 @@ class TestMechBau(unittest.TestCase):
|
||||
((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),
|
||||
]
|
||||
)
|
||||
@@ -124,7 +124,7 @@ class TestMechBau(unittest.TestCase):
|
||||
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))
|
||||
@@ -139,7 +139,7 @@ class TestMechBau(unittest.TestCase):
|
||||
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),
|
||||
@@ -150,16 +150,34 @@ class TestMechBau(unittest.TestCase):
|
||||
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):
|
||||
|
||||
def test_build(self):
|
||||
mech = self.factory.auslieferung()
|
||||
|
||||
for zone_name in ZoneNames:
|
||||
zone = self.mech.inner_structure.zones.get(zone_name)
|
||||
zone = mech.inner_structure.zones.get(zone_name)
|
||||
should_outer_armor = OUTER_ARMOR[zone_name]
|
||||
self.assertEqual(should_outer_armor, zone.armor)
|
||||
|
||||
|
||||
class TestMechWeightWatch(AbstractTestMechAmor):
|
||||
|
||||
def test_watch(self):
|
||||
watcher = self.factory.watcher
|
||||
'''
|
||||
Aufstellung Gewichte:
|
||||
Bauteil | Gewicht in Tonnen
|
||||
------------------------------------
|
||||
Reaktor | 15.5
|
||||
Gyroskope | 3.0
|
||||
Interne-Struktur | 5.5
|
||||
Cockpit | 3.0
|
||||
Panzerung | 9.5
|
||||
Sprungdüsen | 2.5
|
||||
------------------------------------
|
||||
| 39.0
|
||||
'''
|
||||
self.assertEqual(39.0, watcher.actual_weight)
|
||||
self.assertEqual(16.0, watcher.rest_weight)
|
||||
|
||||
+109
-1
@@ -1,10 +1,13 @@
|
||||
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):
|
||||
|
||||
def test_process(self):
|
||||
self.mech = self.factory.auslieferung()
|
||||
for zone_name in ZoneNames:
|
||||
with self.subTest(msg=zone_name.value):
|
||||
zone = self.mech.inner_structure.zones.get(zone_name)
|
||||
@@ -28,6 +31,18 @@ class TestMechAmor(AbstractTestMechAmor):
|
||||
self.assertEqual(10, event.hits)
|
||||
self.assertEqual(area, event.zone.parent)
|
||||
|
||||
def test_critical_process(self):
|
||||
self.mech = self.factory.auslieferung()
|
||||
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 +96,96 @@ 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)
|
||||
|
||||
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)
|
||||
@@ -0,0 +1,101 @@
|
||||
import unittest
|
||||
|
||||
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, Reaktor
|
||||
|
||||
|
||||
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)
|
||||
|
||||
Reference in New Issue
Block a user