Merge branch 'feature/placement'

README.md

@@ -33,13 +33,17 @@ You also need a running redis server (used db number is `0`, soon configurable).
 
 Start troops selection GUI with:
 
-    python select_troops.py --country URSS --country DE
+    python select_troops.py --country USSR --country DE
+
+Select troops for every countries then generate s troops file.
 
 ## Troops Placement phase
 
 You must: specify a map and a state and `--placement` option:
 
-    python run.py maps/001 --state maps/001/state1.xml --placement
+    python run.py maps/001 --troops troops.xml --placement
+
+`troops.xml` must be previously (at `Troops selection` phase) generated troops file.
 
 Map will be loaded with state file troops and you will be able
 to move (drag and drop with your mouse) troops.

config.yaml

@@ -31,6 +31,8 @@ global:
     units_schema: "opencombat/strategy/units.xsd"
     troop_dumper: "opencombat.strategy.troops.TroopDumper"
     troop_schema: "opencombat/strategy/troops.xsd"
+    units: "opencombat/strategy/units.xml"
+    teams: "opencombat/strategy/teams.xml"
     cache_dir_path: 'cache'
     include_path:
       maps:

maps/001/state1.xml

@@ -16,7 +16,7 @@
                 </item>
                 <item>
                     <key>FLAG</key>
-                    <value>FLAG_URSS</value>
+                    <value>FLAG_USSR</value>
                 </item>
                 <item>
                     <key>SIDE</key>
@@ -36,7 +36,7 @@
                 </item>
                 <item>
                     <key>FLAG</key>
-                    <value>FLAG_URSS</value>
+                    <value>FLAG_USSR</value>
                 </item>
                 <item>
                     <key>SIDE</key>
@@ -56,7 +56,7 @@
                 </item>
                 <item>
                     <key>FLAG</key>
-                    <value>FLAG_URSS</value>
+                    <value>FLAG_USSR</value>
                 </item>
                 <item>
                     <key>SIDE</key>

opencombat/ai/__init__.py

@@ -0,0 +1 @@
+# coding: utf-8

opencombat/ai/placement.py

@@ -0,0 +1,39 @@
+# coding: utf-8
+import typing
+
+from synergine2.config import Config
+
+from opencombat.const import SIDE
+from opencombat.simulation.base import TileStrategySimulation
+
+if typing.TYPE_CHECKING:
+    from opencombat.simulation.subject import TileSubject
+
+
+class Placement(object):
+    """
+    Place troops on a map
+    """
+    def __init__(
+        self,
+        config: Config,
+        simulation: TileStrategySimulation,
+    ) -> None:
+        self._config = config
+        self._simulation = simulation
+
+    def place(self) -> None:
+        # For now it is an extremely simple way to do it
+        subject_by_sides = {}  # type: typing.Dict[str, typing.List[TileSubject]]  # nopep8
+        for subject in self._simulation.subjects:
+            subject_by_sides.setdefault(subject.properties[SIDE], []).append(
+                subject,
+            )
+
+        x, y = 0, 0
+        for side, subjects in subject_by_sides.items():
+            y += 2
+            for subject in subjects:
+                x += 2
+
+                subject.position = (x, y)

opencombat/const.py

@@ -2,14 +2,23 @@
 
 COLLECTION_ALIVE = 'ALIVE'
 
+SELECTION_COLOR_RGB = 'SELECTION_COLOR_RGB'
+
 FLAG = 'FLAG'
 FLAG_DE = 'FLAG_DE'
-FLAG_URSS = 'FLAG_URSS'
+FLAG_USSR = 'FLAG_USSR'
 
 SIDE = 'SIDE'
+SIDE_ALLIES = 'SIDE_ALLIES'
+SIDE_AXIS = 'SIDE_AXIS'
+
+COUNTRY = 'COUNTRY'
+COUNTRY_USSR = 'USSR'
+COUNTRY_DE = 'DE'
+
 COMBAT_MODE = 'COMBAT_MODE'
 COMBAT_MODE_DEFEND = 'COMBAT_MODE_DEFEND'
 COMBAT_MODE_HIDE = 'COMBAT_MODE_HIDE'
 
 DE_COLOR = (0, 81, 211)
-URSS_COLOR = (204, 0, 0)
+USSR_COLOR = (204, 0, 0)

opencombat/game/const.py

@@ -6,4 +6,4 @@ FLAG_DE = 'DE'
 FLAG_COLORS = {
     FLAG_DE
 }
-FLAG_URSS = 'URSS'
+FLAG_USSR = 'USSR'

opencombat/simulation/base.py

@@ -1,5 +1,16 @@
 # coding: utf-8
 from opencombat.const import COLLECTION_ALIVE
+from opencombat.const import COUNTRY_USSR
+from opencombat.const import FLAG_USSR
+from opencombat.const import FLAG_DE
+from opencombat.const import SIDE_ALLIES
+from opencombat.const import SIDE_AXIS
+from opencombat.const import COUNTRY_DE
+from opencombat.const import USSR_COLOR
+from opencombat.const import DE_COLOR
+from opencombat.const import SIDE
+from opencombat.const import FLAG
+from opencombat.const import SELECTION_COLOR_RGB
 from opencombat.simulation.physics import TilePhysics
 from synergine2.config import Config
 from synergine2.simulation import SubjectBehaviour
@@ -14,6 +25,23 @@ class TileStrategySimulation(XYZSimulation):
 
     ]
 
+    @classmethod
+    def get_default_properties_for_country(cls, country: str) -> dict:
+        if country == COUNTRY_USSR:
+            return {
+                SELECTION_COLOR_RGB: USSR_COLOR,
+                FLAG: FLAG_USSR,
+                SIDE: SIDE_ALLIES,
+            }
+        elif country == COUNTRY_DE:
+            return {
+                SELECTION_COLOR_RGB: DE_COLOR,
+                FLAG: FLAG_DE,
+                SIDE: SIDE_AXIS,
+            }
+
+        raise NotImplementedError('Unknown country "{}"'.format(country))
+
     def __init__(
         self,
         config: Config,

opencombat/state.py

@@ -14,6 +14,9 @@ from opencombat.util import get_class_from_string_path
 from opencombat.util import pretty_xml
 from opencombat.util import get_text_xml_element
 from opencombat.xml import XmlValidator
+from opencombat.const import SIDE
+from opencombat.const import FLAG
+from opencombat.const import SELECTION_COLOR_RGB
 
 
 class State(object):
@@ -93,9 +96,9 @@ class State(object):
 
     def _get_decode_properties_map(self) -> typing.Dict[str, typing.Callable[[str], typing.Any]]:  # nopep8
         return {
-            'SELECTION_COLOR_RGB': lambda v: tuple(map(int, v.split(','))),
-            'FLAG': str,
-            'SIDE': str,
+            SELECTION_COLOR_RGB: lambda v: tuple(map(int, v.split(','))),
+            FLAG: str,
+            SIDE: str,
         }
 
 
@@ -179,9 +182,9 @@ class StateDumper(object):
 
     def _get_encode_properties_map(self) -> typing.Dict[str, typing.Callable[[typing.Any], str]]:  # nopep8:
         return {
-            'SELECTION_COLOR_RGB': lambda v: ','.join(map(str, v)),
-            'FLAG': str,
-            'SIDE': str,
+            SELECTION_COLOR_RGB: lambda v: ','.join(map(str, v)),
+            FLAG: str,
+            SIDE: str,
         }
 
 

opencombat/strategy/teams.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <teams>
-    <team id="std_team" country="URSS">
-        <name>Standard URSS team</name>
+    <team id="std_team" country="USSR">
+        <name>Standard USSR team</name>
         <units>
             <unit>
                 <id>std_soldier</id>

opencombat/strategy/troops.py

@@ -1,15 +1,73 @@
 # coding: utf-8
 import typing
+from _elementtree import Element
 
 from lxml import etree
 
 from synergine2.config import Config
 from synergine2.log import get_logger
 
+from opencombat.simulation.base import TileStrategySimulation
+from opencombat.simulation.subject import TileSubject
 from opencombat.strategy.team.model import TeamModel
 from opencombat.strategy.team.stash import TeamStash
 from opencombat.strategy.unit.stash import UnitStash
 from opencombat.util import get_class_from_string_path, pretty_xml
+from opencombat.xml import XmlValidator
+
+
+class Troop(object):
+    def __init__(
+        self,
+        config: Config,
+        state_root: Element,
+        simulation: TileStrategySimulation,
+    ) -> None:
+        self._config = config
+        self._state_root = state_root
+        self._subjects = None  # type: typing.List[TileSubject]
+        self._simulation = simulation
+        self._builder = TroopClassBuilder(config)
+
+    @property
+    def subjects(self) -> typing.List[TileSubject]:
+        if self._subjects is None:
+            self._subjects = self._get_computed_subjects()
+
+        return self._subjects
+
+    def _get_computed_subjects(self) -> typing.List[TileSubject]:
+        units_file_path = self._config.get(
+            'global.units',
+            'opencombat/strategy/units.xml',
+        )
+        teams_file_path = self._config.get(
+            'global.teams',
+            'opencombat/strategy/teams.xml',
+        )
+
+        team_stash = self._builder.get_team_stash(
+            units_file_path,
+            teams_file_path,
+        )
+
+        # Parse team, build Subjects
+        subjects = []  # type: typing.List[TileSubject]
+        for troop in self._state_root.findall('troop'):
+            country = troop.attrib['country']
+            team_id = troop.attrib['team_id']
+            team = team_stash.get_team(team_id, country)
+
+            for unit in team.units:
+                subject = unit.class_(self._config, self._simulation)
+                properties = \
+                    self._simulation.get_default_properties_for_country(
+                        country,
+                    )
+                subject.properties.update(properties)
+                subjects.append(subject)
+
+        return subjects
 
 
 class TroopDumper(object):
@@ -109,3 +167,66 @@ class TroopClassBuilder(object):
         return class_(
             self._config,
         )
+
+
+class TroopLoader(object):
+    def __init__(
+        self,
+        config: Config,
+        simulation: TileStrategySimulation,
+    ) -> None:
+        self._logger = get_logger('TroopLoader', config)
+        self._config = config
+        self._simulation = simulation
+
+        schema_file_path = self._config.get(
+            'global.troop_schema',
+            'opencombat/strategy/troops.xsd',
+        )
+        self._xml_validator = XmlValidator(
+            config,
+            schema_file_path,
+        )
+
+    def get_troop(
+        self,
+        troop_file_path: str,
+    ) -> Troop:
+        return Troop(
+            self._config,
+            self._validate_and_return_state_element(troop_file_path),
+            self._simulation,
+        )
+
+    def _validate_and_return_state_element(
+        self,
+        troop_file_path: str,
+    ) -> Element:
+        return self._xml_validator.validate_and_return(troop_file_path)
+
+
+class TroopConstructorBuilder(object):
+    def __init__(
+        self,
+        config: Config,
+        simulation: TileStrategySimulation,
+    ) -> None:
+        self._logger = get_logger('TroopConstructorBuilder', config)
+        self._config = config
+        self._simulation = simulation
+
+    def get_troop_loader(
+        self,
+    ) -> TroopLoader:
+        class_address = self._config.resolve(
+            'global.troop_loader',
+            'opencombat.strategy.troops.TroopLoader',
+        )
+        troop_loader_class = get_class_from_string_path(
+            self._config,
+            class_address,
+        )
+        return troop_loader_class(
+            self._config,
+            self._simulation,
+        )

opencombat/strategy/troops.xsd

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+    <xs:element name="troops" type="troopstype"/>
+
+    <xs:complexType name="troopstype">
+        <xs:sequence>
+            <xs:element name="troop" type="trooptype" maxOccurs="unbounded"/>
+        </xs:sequence>
+    </xs:complexType>
+
+    <xs:complexType name="trooptype">
+        <xs:attribute name="country" type="xs:string" use="required"/>
+        <xs:attribute name="team_id" type="xs:string" use="required"/>
+    </xs:complexType>
+
+</xs:schema>

opencombat/strategy/units.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <units>
-    <unit id="std_soldier" country="URSS">
+    <unit id="std_soldier" country="USSR">
         <name>Standard soldier</name>
         <type>opencombat.simulation.subject.ManSubject</type>
     </unit>

run.py

@@ -1,6 +1,7 @@
 # coding: utf-8
 import argparse
 import logging
+import sys
 from random import seed
 
 from synergine2.log import get_default_logger
@@ -10,9 +11,11 @@ from synergine2.core import Core
 from synergine2.cycle import CycleManager
 from synergine2.terminals import TerminalManager
 
+from opencombat.ai.placement import Placement
 from opencombat.simulation.base import TileStrategySimulation
 from opencombat.simulation.base import TileStrategySubjects
 from opencombat.state import StateConstructorBuilder
+from opencombat.strategy.troops import TroopConstructorBuilder
 from opencombat.terminal.base import CocosTerminal
 
 
@@ -20,9 +23,13 @@ def main(
     map_dir_path: str,
     seed_value: int=None,
     state_file_path: str=None,
+    troops_file_path: str=None,
     state_save_dir: str='.',
     placement_mode: bool = False,
 ):
+    assert not (state_file_path and troops_file_path),\
+        'Do not provide troops file when state file given'
+
     if seed_value is not None:
         seed(seed_value)
 
@@ -42,6 +49,7 @@ def main(
 
     simulation = TileStrategySimulation(config, map_file_path=map_file_path)
     subjects = TileStrategySubjects(simulation=simulation)
+    simulation.subjects = subjects
 
     if state_file_path:
         state_loader_builder = StateConstructorBuilder(config, simulation)
@@ -49,7 +57,14 @@ def main(
         state = state_loader.get_state(state_file_path)
         subjects.extend(state.subjects)
 
-    simulation.subjects = subjects
+    elif troops_file_path:
+        troop_loader_builder = TroopConstructorBuilder(config, simulation)
+        troop_loader = troop_loader_builder.get_troop_loader()
+        placement = Placement(config, simulation)
+
+        troops = troop_loader.get_troop(troops_file_path)
+        subjects.extend(troops.subjects)
+        placement.place()
 
     core = Core(
         config=config,
@@ -76,6 +91,7 @@ if __name__ == '__main__':
     )
     parser.add_argument('map_dir_path', help='map directory path')
     parser.add_argument('--seed', dest='seed', default=None)
+    parser.add_argument('--troops', dest='troops', default=None)
     parser.add_argument('--state', dest='state', default=None)
     parser.add_argument(
         '--state-save-dir',
@@ -90,10 +106,31 @@ if __name__ == '__main__':
 
     args = parser.parse_args()
 
+    if args.troops and args.state:
+        print(
+            'Cannot load state "{}" because you provide troops file "{}". '
+            'You must provide only one of them.'.format(
+                args.state,
+                args.troops,
+            ),
+            file=sys.stderr,
+        )
+        exit(1)
+
+    if args.troops and not args.placement:
+        print(
+            'Cannot load troops "{}" without activate placement mode.'.format(
+                args.state,
+            ),
+            file=sys.stderr,
+        )
+        exit(1)
+
     main(
         args.map_dir_path,
         seed_value=args.seed,
         state_file_path=args.state,
+        troops_file_path=args.troops,
         state_save_dir=args.state_save_dir,
         placement_mode=args.placement,
     )

select_troops.py

@@ -1,5 +1,6 @@
 # coding: utf-8
 import argparse
+import sys
 import typing
 from tkinter import Tk
 
@@ -62,6 +63,14 @@ if __name__ == '__main__':
     )
     args = parser.parse_args()
 
+    if not args.countries:
+        print(
+            'You must choose one or more countries with parameters '
+            '--country, eg. `--country USSR --country DE`',
+            file=sys.stderr,
+        )
+        exit(1)
+
     main(
         units_file_path=args.units_file_path,
         teams_file_path=args.teams_file_path,

tests/fixtures/state_ok.xml

@@ -16,7 +16,7 @@
                 </item>
                 <item>
                     <key>FLAG</key>
-                    <value>FLAG_URSS</value>
+                    <value>FLAG_USSR</value>
                 </item>
                 <item>
                     <key>SIDE</key>

tests/fixtures/teams.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <teams>
-    <team id="std_team" country="URSS">
-        <name>Standard URSS team</name>
+    <team id="std_team" country="USSR">
+        <name>Standard USSR team</name>
         <units>
             <unit>
                 <id>std_soldier</id>

tests/fixtures/units.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <units>
-    <unit id="std_soldier" country="URSS">
+    <unit id="std_soldier" country="USSR">
         <name>Standard soldier</name>
         <type>opencombat.simulation.subject.ManSubject</type>
     </unit>

tests/strategy/test_teams.py

@@ -46,7 +46,7 @@ def test_team_stash__ok__get_teams(
 
     assert 'std_team' == stash.teams[0].id
     assert 'Standard team' == stash.teams[0].name
-    assert 'URSS' == stash.teams[0].country
+    assert 'USSR' == stash.teams[0].country
     assert stash.teams[0].units
     assert 4 == len(stash.teams[0].units)
     assert isinstance(stash.teams[0].units[0], UnitModel)
@@ -76,7 +76,7 @@ def test_teams_stash__ok__get_unit(
         'tests/fixtures/teams.xml',
         unit_stash=unit_stash,
     )
-    assert stash.get_team('std_team', 'URSS')
+    assert stash.get_team('std_team', 'USSR')
 
 
 def test_teams_stash__error__get_team_wrong_country(
@@ -104,4 +104,4 @@ def test_teams_stash__error__get_team_wrong_id(
     )
 
     with pytest.raises(NotFoundException):
-        stash.get_team('unknown', 'URSS')
+        stash.get_team('unknown', 'USSR')

tests/strategy/test_units.py

@@ -31,7 +31,7 @@ def test_units_stash__ok__get_units(
 
     assert 'std_soldier' == stash.units[0].id
     assert 'Standard soldier' == stash.units[0].name
-    assert 'URSS' == stash.units[0].country
+    assert 'USSR' == stash.units[0].country
     assert ManSubject == stash.units[0].class_
 
     assert 'std_soldier' == stash.units[1].id
@@ -47,7 +47,7 @@ def test_units_stash__ok__get_unit(
         config,
         'tests/fixtures/units.xml',
     )
-    assert stash.get_unit('std_soldier', 'URSS')
+    assert stash.get_unit('std_soldier', 'USSR')
 
 
 def test_units_stash__error__get_unit_wrong_country(
@@ -71,4 +71,4 @@ def test_units_stash__error__get_unit_wrong_id(
     )
 
     with pytest.raises(NotFoundException):
-        stash.get_unit('unknown', 'URSS')
+        stash.get_unit('unknown', 'USSR')

tests/test_state.py

@@ -16,8 +16,10 @@ from opencombat.const import FLAG
 from opencombat.const import SIDE
 from opencombat.const import FLAG_DE
 from opencombat.const import DE_COLOR
-from opencombat.const import URSS_COLOR
-from opencombat.const import FLAG_URSS
+from opencombat.const import USSR_COLOR
+from opencombat.const import FLAG_USSR
+from opencombat.const import SIDE_ALLIES
+from opencombat.const import SIDE_AXIS
 
 
 class MyStateLoader(StateLoader):
@@ -44,16 +46,16 @@ def simulation_for_dump(config) -> TileStrategySimulation:
     man1.properties = OrderedDict([
         (SELECTION_COLOR_RGB, DE_COLOR),
         (FLAG, FLAG_DE),
-        (SIDE, 'AXIS'),
+        (SIDE, SIDE_AXIS),
     ])
 
     man2 = ManSubject(config, simulation)
     man2.position = (16, 8)
     man2.direction = 197
     man2.properties = OrderedDict([
-        (SELECTION_COLOR_RGB, URSS_COLOR),
-        (FLAG, FLAG_URSS),
-        (SIDE, 'ALLIES'),
+        (SELECTION_COLOR_RGB, USSR_COLOR),
+        (FLAG, FLAG_USSR),
+        (SIDE, SIDE_ALLIES),
     ])
 
     subjects.append(man1)
@@ -116,7 +118,7 @@ def test_state__ok__subjects(
 
     assert {
                'SELECTION_COLOR_RGB': (204, 0, 0),
-               'FLAG': 'FLAG_URSS',
+               'FLAG': 'FLAG_USSR',
                'SIDE': 'ALLIES',
            } == state.subjects[0].properties
     assert {
@@ -170,7 +172,7 @@ def test_state__ok__dump(
                 </item>
                 <item>
                     <key>FLAG</key>
-                    <value>FLAG_URSS</value>
+                    <value>FLAG_USSR</value>
                 </item>
                 <item>
                     <key>SIDE</key>