tests: verbessere die Verantwortung der Trefferpunkte-Verarbeitung

MechFabrik/Uml/Mech.puml

@@ -1,87 +1,58 @@
 @startuml
 'https://plantuml.com/object-diagram
 
-object Mech <<Mech>> {
+object Mech <<Mech>>
+abstract Area <<Zone>> {
+    next_area: Area
+    item_lines: #
+    armor: #
+}
+abstract AreaItem <<Item>> {
+    item_lines: #
+}
+
+object InnerStructure <<InnerStructure>> {
     heater: x
 }
-object InnerStructure <<InnerStructure>>
+
-object Gyroskope <<Gyroskope>>
+object OuterAmor <<Zone>> {
-object Sustainment
+    armor: #
-object Sensors
+}
+
 object Head <<Area>> {
     item_lines: 6
-    inner_armor: #
-    amor: #
 }
-object Cockpit <<Cockpit>>
+
-object Reaktor <<Reaktor>>
+object Torso <<Area>> {
-object TorsoMiddle <<Area>> {
     item_lines: 12
-    inner_armor: #
-    amor: #
 }
-object TorsoLeft <<Area>> {
+
+object SideTorso <<Area>> {
     item_lines: 12
-    inner_armor: #
-    amor: #
 }
-object ArmLeft <<Area>> {
+
+object Arm <<Area>> {
     item_lines: 12
-    inner_armor: #
-    amor: #
 }
-object LegLeft <<Area>> {
+
+object Leg <<Area>> {
     item_lines: 6
-    inner_armor: #
-    amor: #
 }
-object TorsoRight <<Area>> {
+
-    item_lines: 12
+Area *- "1,*" OuterAmor
-    inner_armor: #
+AreaItem "*" -* Area
-    amor: #
+
-}
+Head <|-- Area
-object ArmRight <<Area>> {
+Torso <|-- Area
-    item_lines: 12
+SideTorso <|-- Area
-    inner_armor: #
+Arm <|-- Area
-    amor: #
+Leg <|-- Area
-}
-object LegRight <<Area>> {
-    item_lines: 6
-    inner_armor: #
-    amor: #
-}
-object JointAL as "Joint"
-object ActivatorAL as "Activator"
-object JointLL as "Joint"
-object ActivatorLL as "Activator"
-object JointAR as "Joint"
-object ActivatorAR as "Activator"
-object JointLR as "Joint"
-object ActivatorLR as "Activator"
 
 Mech *-- InnerStructure
 InnerStructure *-- Head
-InnerStructure *-- TorsoMiddle
+InnerStructure *-- Torso
-Mech *- Gyroskope
+Torso *-- SideTorso
-Head *- Cockpit
+SideTorso *-- "0|2" Arm
-Head *-- Sustainment
+SideTorso *-- "2|4" Leg
-Head *-- Sensors
-Mech *- Reaktor
-Gyroskope .. InnerStructure
-Reaktor ... InnerStructure
-TorsoMiddle *-- TorsoLeft
-TorsoMiddle *-- TorsoRight
-TorsoLeft *--  ArmLeft
-TorsoLeft *--  LegLeft
-TorsoRight *-- ArmRight
-TorsoRight *-- LegRight
-ArmLeft *--   JointAL
-ArmLeft *--  ActivatorAL
-ArmRight *--   JointAR
-ArmRight *--  ActivatorAR
-LegRight *--   JointLR
-LegRight *--  ActivatorLR
-LegLeft *--   JointLL
-LegLeft *--  ActivatorLL
 
 @enduml

MechFabrik/Uml/MechStructure.puml

@@ -0,0 +1,75 @@
+@startuml
+'https://plantuml.com/object-diagram
+
+object Mech <<Mech>> {
+    heater: x
+}
+
+object Head <<Area>> {
+    item_lines: 6
+}
+object Sustainment <<AreaItem>>
+object Sensors <<AreaItem>>
+object Cockpit <<Cockpit>> <<AreaItem>>
+
+object InnerStructure <<InnerStructure>>
+object Gyroskope <<Gyroskope>> <<AreaItem>>
+object Reaktor <<Reaktor>> <<AreaItem>>
+object TorsoMiddle <<Area>> {
+    item_lines: 12
+}
+object TorsoLeft <<Area>> {
+    item_lines: 12
+}
+object ArmLeft <<Area>> {
+    item_lines: 12
+}
+object LegLeft <<Area>> {
+    item_lines: 6
+}
+object TorsoRight <<Area>> {
+    item_lines: 12
+}
+object ArmRight <<Area>> {
+    item_lines: 12
+}
+object LegRight <<Area>> {
+    item_lines: 6
+}
+object JointAL as "Joint" <<AreaItem>>
+object ActivatorAL as "Activator" <<AreaItem>>
+object JointLL as "Joint" <<AreaItem>>
+object ActivatorLL as "Activator" <<AreaItem>>
+object JointAR as "Joint" <<AreaItem>>
+object ActivatorAR as "Activator" <<AreaItem>>
+object JointLR as "Joint" <<AreaItem>>
+object ActivatorLR as "Activator" <<AreaItem>>
+
+
+Mech *- Gyroskope
+Head *- Cockpit
+Head *-- Sustainment
+Head *-- Sensors
+
+Mech *-- InnerStructure
+InnerStructure *-- Head
+InnerStructure *-- TorsoMiddle
+Mech *- Reaktor
+Gyroskope .. TorsoMiddle
+Reaktor .. TorsoMiddle
+TorsoMiddle *-- TorsoLeft
+TorsoMiddle *-- TorsoRight
+TorsoLeft *--  ArmLeft
+TorsoLeft *--  LegLeft
+TorsoRight *-- ArmRight
+TorsoRight *-- LegRight
+ArmLeft *--   JointAL
+ArmLeft *--  ActivatorAL
+ArmRight *--   JointAR
+ArmRight *--  ActivatorAR
+LegRight *--   JointLR
+LegRight *--  ActivatorLR
+LegLeft *--   JointLL
+LegLeft *--  ActivatorLL
+
+@enduml

MechFabrik/Uml/StrikeProcessSequence.puml

@@ -0,0 +1,31 @@
+@startuml
+'https://plantuml.com/sequence-diagram
+
+autonumber
+
+actor Gegner
+
+actor Selbst
+database InnerStructure
+collections Zone
+entity ZoneEvent
+
+Gegner -> Selbst: Treffer
+Selbst -> InnerStructure: verarbeite Treffer
+InnerStructure -> Zone: suche getroffene Außen-Zone
+return Zone
+InnerStructure -> ZoneEvent: erstelle **ZonenEvent**
+return **ZonenEvent**
+alt aktuelles **ZoneEvent** hat noch nicht alle Trefferpunkte verarbeitet
+    alt **Zone** hat noch Panzerung
+        InnerStructure -> ZonenEvent: trage Trefferpunkte ab
+        return ZoneEvent
+    else **Zone** hat keine Panzerung
+        InnerStructure -> Zone: hole Weiterleitung-Zone
+        return Zone
+        InnerStructure -> ZoneEvent: erstelle **ZonenEvent** für weitergeleitete **Zone**
+        return ZoneEvent
+    end
+end
+
+@enduml

MechFabrik/bauteile/__init__.py

@@ -2,6 +2,20 @@ import enum
 from typing import Any
 
 
+class ZoneNames(enum.Enum):
+    HEAD = 'Kopf'
+    MIDDLE_TORSO_FRONT = 'Torso Mitte Vorn'
+    MIDDLE_TORSO_REAR = 'Torso Mitte Rücken'
+    RIGHT_TORSO_FRONT = 'Rechter Torso Vorn'
+    RIGHT_TORSO_REAR = 'Rechter Torso Rücken'
+    LEFT_TORSO_FRONT = 'Linker Torso Vorn'
+    LEFT_TORSO_REAR = 'Linker Torso Rücken'
+    RIGHT_LEG = 'Rechtes Bein'
+    RIGHT_ARM = 'Rechter Arm'
+    LEFT_LEG = 'Linkes Bein'
+    LEFT_ARM = 'Linker Arm'
+
+
 class AreaNames(enum.Enum):
     HEAD = 'Kopf'
     MIDDLE_TORSO = 'Torso Mitte'

tests/test_mech/__init__.py

@@ -1,7 +1,7 @@
 import unittest
 
 from MechFabrik import MechFabrik
-from MechFabrik.bauteile import AreaNames
+from MechFabrik.bauteile import AreaNames, ZoneNames
 
 INNER_ARMOR = {
         AreaNames.HEAD:         3,
@@ -15,26 +15,43 @@ INNER_ARMOR = {
         }
 
 OUTER_ARMOR = {
-        AreaNames.HEAD:         6,
+        ZoneNames.HEAD:               6,
-        AreaNames.MIDDLE_TORSO: 9,
+        ZoneNames.MIDDLE_TORSO_FRONT: 9,
-        AreaNames.LEFT_TORSO:   8,
+        ZoneNames.MIDDLE_TORSO_REAR:  4,
-        AreaNames.RIGHT_TORSO:  8,
+        ZoneNames.LEFT_TORSO_FRONT:   8,
-        AreaNames.LEFT_ARM:     5,
+        ZoneNames.LEFT_TORSO_REAR:    3,
-        AreaNames.RIGHT_ARM:    5,
+        ZoneNames.RIGHT_TORSO_FRONT:  8,
-        AreaNames.LEFT_LEG:     7,
+        ZoneNames.RIGHT_TORSO_REAR:   3,
-        AreaNames.RIGHT_LEG:    7,
+        ZoneNames.LEFT_ARM:           5,
+        ZoneNames.RIGHT_ARM:          5,
+        ZoneNames.LEFT_LEG:           7,
+        ZoneNames.RIGHT_LEG:          7,
         }
 
+NEXT_OUTER_ZONE = {
+        ZoneNames.HEAD:               AreaNames.HEAD,
+        ZoneNames.MIDDLE_TORSO_FRONT: AreaNames.MIDDLE_TORSO,
+        ZoneNames.MIDDLE_TORSO_REAR:  AreaNames.MIDDLE_TORSO,
+        ZoneNames.LEFT_TORSO_FRONT:   AreaNames.LEFT_TORSO,
+        ZoneNames.LEFT_TORSO_REAR:    AreaNames.LEFT_TORSO,
+        ZoneNames.RIGHT_TORSO_FRONT:  AreaNames.RIGHT_TORSO,
+        ZoneNames.RIGHT_TORSO_REAR:   AreaNames.RIGHT_TORSO,
+        ZoneNames.LEFT_ARM:           AreaNames.LEFT_ARM,
+        ZoneNames.RIGHT_ARM:          AreaNames.RIGHT_ARM,
+        ZoneNames.LEFT_LEG:           AreaNames.LEFT_LEG,
+        ZoneNames.RIGHT_LEG:          AreaNames.RIGHT_LEG,
+}
+
 
 class AbstractTestMechAmor(unittest.TestCase):
 
     def setUp(self):
         fabrik = MechFabrik('Heuschrecke', 20.0, 8)
 
-        fabrik.set_head_armor(OUTER_ARMOR[AreaNames.HEAD])
+        fabrik.set_head_armor(OUTER_ARMOR[ZoneNames.HEAD])
-        fabrik.set_middle_torso_armor(OUTER_ARMOR[AreaNames.MIDDLE_TORSO])
+        fabrik.set_middle_torso_armor(OUTER_ARMOR[ZoneNames.MIDDLE_TORSO_FRONT],OUTER_ARMOR[ZoneNames.MIDDLE_TORSO_REAR])
-        fabrik.set_side_torso_armor(OUTER_ARMOR[AreaNames.LEFT_TORSO])
+        fabrik.set_side_torso_armor(OUTER_ARMOR[ZoneNames.LEFT_TORSO_FRONT],OUTER_ARMOR[ZoneNames.LEFT_TORSO_REAR])
-        fabrik.set_arm_armor(OUTER_ARMOR[AreaNames.LEFT_ARM])
+        fabrik.set_arm_armor(OUTER_ARMOR[ZoneNames.LEFT_ARM])
-        fabrik.set_leg_armor(OUTER_ARMOR[AreaNames.LEFT_LEG])
+        fabrik.set_leg_armor(OUTER_ARMOR[ZoneNames.LEFT_LEG])
 
         self.mech = fabrik.auslieferung()

tests/test_mech_bau.py

@@ -1,7 +1,9 @@
 import unittest
 
 from MechFabrik import MechFabrik
-from MechFabrik.bauteile import InnerStructure, Gyroskope, AreaNames, Area, Cockpit, Item, ItemTypes, Reaktor, Mech
+from MechFabrik.bauteile import InnerStructure, Gyroskope, AreaNames, Area, Cockpit, Item, ItemTypes, OuterAmor, \
+    Reaktor, Mech, \
+    Zone, ZoneNames
 from test_mech import AbstractTestMechAmor, INNER_ARMOR, OUTER_ARMOR
 
 
@@ -20,9 +22,16 @@ class TestMechBau(unittest.TestCase):
 
         for ara_name in AreaNames:
             area = mech.inner_structure.areas.get(ara_name)
-            should_inner_amor = INNER_ARMOR[ara_name]
+            should_amor = INNER_ARMOR[ara_name]
-            self.assertEqual(should_inner_amor, area.inner_armor)
+            self.assertIsInstance(area, Zone)
-            self.assertEqual(0, area.armor)
+            self.assertIsInstance(area, Area)
+            self.assertEqual(should_amor, area.armor)
+
+        for zone_name in ZoneNames:
+            zone = 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)
@@ -44,6 +53,8 @@ class TestMechBau(unittest.TestCase):
         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)
+        self.assertIsInstance(area_head.parent, Area)
+        self.assertEqual(middle_torso, area_head.parent)
         self.assertCountEqual([right_torso, left_torso], middle_torso.children)
 
         right_arm = self._test_areas(mech=mech, parent=right_torso, index=AreaNames.RIGHT_ARM, children=0)
@@ -148,7 +159,7 @@ class TestMechBau(unittest.TestCase):
 class TestMechAmor(AbstractTestMechAmor):
 
     def test_build(self):
-        for area_name in AreaNames:
+        for zone_name in ZoneNames:
-            area = self.mech.inner_structure.areas.get(area_name)
+            zone = self.mech.inner_structure.zones.get(zone_name)
-            should_outer_armor = OUTER_ARMOR[area_name]
+            should_outer_armor = OUTER_ARMOR[zone_name]
-            self.assertEqual(should_outer_armor, area.armor)
+            self.assertEqual(should_outer_armor, zone.armor)

tests/test_mech_process.py

@@ -1,32 +1,85 @@
 import unittest
 
-from test_mech import AbstractTestMechAmor, INNER_ARMOR, OUTER_ARMOR
+from test_mech import AbstractTestMechAmor, INNER_ARMOR, NEXT_OUTER_ZONE, OUTER_ARMOR
-from MechFabrik.bauteile import AreaNames, AreaStatus
+from MechFabrik.bauteile import Area, AreaStatus, OuterAmor, StrikeEvent, ZoneNames
 
 
 class TestMechAmor(AbstractTestMechAmor):
 
     def test_process(self):
-        for area_name in AreaNames:
+        for zone_name in ZoneNames:
-            area = self.mech.inner_structure.areas.get(area_name)
+            with self.subTest(msg=zone_name.value):
-            start_armor = OUTER_ARMOR[area_name]
+                zone = self.mech.inner_structure.zones.get(zone_name)
-            start_inner_armor = INNER_ARMOR[area_name]
+                area = zone.area
+                start_outer_armor = OUTER_ARMOR[zone_name]
+                start_inner_armor = INNER_ARMOR[NEXT_OUTER_ZONE[zone_name]]
 
-            self.assertEqual(start_armor, area.armor)
+                self.assertEqual(start_outer_armor, zone.armor)
-            self.assertEqual(start_inner_armor, area.inner_armor)
+                self.assertEqual(area, zone.parent)
+                self.assertEqual(start_inner_armor, area.armor)
+                self.assertEqual(AreaStatus.FINE, zone.state)
                 self.assertEqual(AreaStatus.FINE, area.state)
 
-            self.mech.strike(area_name, start_armor - 3)
+                event = self.mech.strike(zone_name, 10)
-            self.assertEqual(3, area.armor)
+                self.assertEqual(start_outer_armor, zone.armor)
-            self.assertEqual(start_inner_armor, area.inner_armor)
+                self.assertEqual(start_inner_armor, area.armor)
+                self.assertEqual(AreaStatus.FINE, zone.state)
+                self.assertEqual(AreaStatus.FINE, area.state)
+                self.assertIsInstance(event, StrikeEvent)
+                self.assertEqual(zone, event.zone)
+                self.assertEqual(10, event.hits)
+                self.assertEqual(area, event.zone.parent)
+
+    def test_strike(self):
+        start_outer_armor = 11
+        start_area_armor = 5
+        start_parent_armor = 3
+        parent = Area()
+        parent.armor = start_parent_armor
+        area = Area()
+        area.armor = start_area_armor
+        area.parent = parent
+        zone = OuterAmor(area)
+        zone.armor = start_outer_armor
+
+        self.assertEqual(start_outer_armor, zone.armor)
+        self.assertEqual(start_area_armor, area.armor)
+        self.assertEqual(AreaStatus.FINE, zone.state)
         self.assertEqual(AreaStatus.FINE, area.state)
 
-            self.mech.strike(area_name, 4)
+        event = StrikeEvent(zone, start_outer_armor - 3).process_event()
-            self.assertEqual(0, area.armor)
+        self.assertEqual(3, zone.armor)
-            self.assertEqual(start_inner_armor - 1, area.inner_armor)
+        self.assertEqual(start_area_armor, area.armor)
-            self.assertEqual(AreaStatus.CRITICAL_STRIKE, area.state)
+        self.assertEqual(AreaStatus.DAMAGED, zone.state)
+        self.assertEqual(AreaStatus.FINE, area.state)
+        self.assertIsInstance(event, StrikeEvent)
+        self.assertEqual(zone, event.zone)
+        self.assertEqual(0, event.hits)
 
-            self.mech.strike(area_name, start_inner_armor - 1)
+        event = StrikeEvent(zone, 4).process_event()
+        self.assertEqual(0, zone.armor)
+        self.assertEqual(start_area_armor - 1, area.armor)
+        self.assertEqual(AreaStatus.DESTROYED, zone.state)
+        self.assertEqual(AreaStatus.DAMAGED, area.state)
+        self.assertIsInstance(event, StrikeEvent)
+        self.assertEqual(area, event.zone)
+        self.assertEqual(0, event.hits)
+
+        event = StrikeEvent(zone, start_area_armor - 1).process_event()
+        self.assertEqual(0, zone.armor)
         self.assertEqual(0, area.armor)
-            self.assertEqual(0, area.inner_armor)
+        self.assertEqual(AreaStatus.DESTROYED, zone.state)
         self.assertEqual(AreaStatus.DESTROYED, area.state)
+        self.assertIsInstance(event, StrikeEvent)
+        self.assertEqual(area, event.zone)
+        self.assertEqual(0, event.hits)
+
+        event = StrikeEvent(zone, 1).process_event()
+        self.assertEqual(0, zone.armor)
+        self.assertEqual(0, area.armor)
+        self.assertEqual(AreaStatus.DESTROYED, zone.state)
+        self.assertEqual(AreaStatus.DESTROYED, area.state)
+        self.assertIsInstance(event, StrikeEvent)
+        self.assertNotEqual(area, event.zone)
+        self.assertEqual(area.parent, event.zone)
+        self.assertEqual(0, event.hits)