Merge branch 'feature/select_troops'

README.md

 
 Tested only under linux, debian/Ubuntu. Before install project, install OS packages:
 
-    build-essential libsdl1.2debian libsdl-image1.2 libsdl-image1.2-dev libsdl-ttf2.0-0 libsdl-ttf2.0-dev libsdl-mixer1.2 libsdl-mixer1.2-dev redis-server
+    build-essential python3-tk libsdl1.2debian libsdl-image1.2 libsdl-image1.2-dev libsdl-ttf2.0-0 libsdl-ttf2.0-dev libsdl-mixer1.2 libsdl-mixer1.2-dev redis-server
 
 Python version: 3.5+
 
 
 ## Troops selection
 
-Not developed yet
+Start troops selection GUI with:
+
+    python select_troops.py --country URSS --country DE
 
 ## Troops Placement phase
 

config.yaml

     state_dumper: "opencombat.state.StateDumper"
     state_schema: "opencombat/state.xsd"
     state_template: "opencombat/state_template.xml"
+    unit_stash: "opencombat.strategy.unit.stash.UnitStash"
+    team_stash: "opencombat.strategy.team.stash.TeamStash"
+    teams_schema: "opencombat/strategy/teams.xsd"
+    units_schema: "opencombat/strategy/units.xsd"
+    troop_dumper: "opencombat.strategy.troops.TroopDumper"
+    troop_schema: "opencombat/strategy/troops.xsd"
     cache_dir_path: 'cache'
     include_path:
       maps:

opencombat/exception.py

 
 class NotFoundError(OpenCombatException):
     pass
+
+
+class NotFoundException(OpenCombatException):
+    pass

opencombat/gui/actor.py → opencombat/game/actor.py

 from opencombat.exception import UnknownWeapon
 from opencombat.exception import WrongMode
 from opencombat.exception import UnknownFiringAnimation
-from opencombat.gui.animation import ANIMATION_CRAWL
-from opencombat.gui.animation import ANIMATION_WALK
-from opencombat.gui.const import MODE_MAN_STAND_UP
-from opencombat.gui.const import MODE_MAN_CRAWLING
-from opencombat.gui.image import TileImageCacheManager
-from opencombat.gui.weapon import RIFFLE
-from opencombat.gui.weapon import WeaponImageApplier
+from opencombat.game.animation import ANIMATION_CRAWL
+from opencombat.game.animation import ANIMATION_WALK
+from opencombat.game.const import MODE_MAN_STAND_UP
+from opencombat.game.const import MODE_MAN_CRAWLING
+from opencombat.game.image import TileImageCacheManager
+from opencombat.game.weapon import RIFFLE
+from opencombat.game.weapon import WeaponImageApplier
 from opencombat.user_action import UserAction
 
 if typing.TYPE_CHECKING:
-    from opencombat.gui.fire import GuiFiringEvent
+    from opencombat.game.fire import GuiFiringEvent
 
 
 MODE_DEFAULT = 'MODE_DEFAULT'

opencombat/gui/base.py → opencombat/game/base.py

 from synergine2_cocos2d.middleware import MapMiddleware
 from synergine2_cocos2d.util import PathManager
 
-from opencombat.gui.animation import ANIMATION_WALK
-from opencombat.gui.animation import ANIMATION_CRAWL
-from opencombat.gui.fire import GuiFiringEvent
-from opencombat.gui.placement import SetSubjectPositionsInteraction
-from opencombat.gui.state import SaveStateInteraction
+from opencombat.game.animation import ANIMATION_WALK
+from opencombat.game.animation import ANIMATION_CRAWL
+from opencombat.game.fire import GuiFiringEvent
+from opencombat.game.placement import SetSubjectPositionsInteraction
+from opencombat.game.state import SaveStateInteraction
 from opencombat.simulation.interior import InteriorManager
 from opencombat.simulation.tmx import TileMap
 from opencombat.user_action import UserAction
 from opencombat.simulation.event import DieEvent
 from opencombat.simulation.subject import ManSubject
 from opencombat.simulation.subject import TankSubject
-from opencombat.gui.actor import Man as ManActor
-from opencombat.gui.actor import HeavyVehicle as HeavyVehicleActor
+from opencombat.game.actor import Man as ManActor
+from opencombat.game.actor import HeavyVehicle as HeavyVehicleActor
 
 
 class EditLayer(BaseEditLayer):
         )
 
     def before_run(self) -> None:
-        from opencombat.gui.move import MoveActorInteraction
-        from opencombat.gui.move import MoveFastActorInteraction
-        from opencombat.gui.move import MoveCrawlActorInteraction
-        from opencombat.gui.fire import FireActorInteraction
+        from opencombat.game.move import MoveActorInteraction
+        from opencombat.game.move import MoveFastActorInteraction
+        from opencombat.game.move import MoveCrawlActorInteraction
+        from opencombat.game.fire import FireActorInteraction
 
         self.layer_manager.interaction_manager.register(
             MoveActorInteraction,

opencombat/gui/fire.py → opencombat/game/fire.py

 # coding: utf-8
 import typing
 
-from opencombat.gui.actor import BaseActor
+from opencombat.game.actor import BaseActor
 from opencombat.simulation.event import DEFAULT_WEAPON_TYPE
 from opencombat.simulation.fire import RequestFireBehaviour
 from synergine2_cocos2d.interaction import BaseActorInteraction

opencombat/gui/image.py → opencombat/game/image.py

 from opencombat.exception import UnknownFiringAnimation
 
 if typing.TYPE_CHECKING:
-    from opencombat.gui.actor import BaseActor
+    from opencombat.game.actor import BaseActor
 
 
 class FiringImageCache(ImageCache):
     ) -> None:
         super().__init__(actor, config)
         self.firing_cache = FiringImageCache()
-        from opencombat.gui.actor import BaseActor
+        from opencombat.game.actor import BaseActor
         self.actor = typing.cast(BaseActor, self.actor)
         self.path_manager = PathManager(
             self.config.resolve('global.include_path.graphics'),

opencombat/gui/weapon.py → opencombat/game/weapon.py

 from synergine2_cocos2d.util import PathManager
 
 from opencombat.exception import UnknownWeapon
-from opencombat.gui.const import MODE_MAN_STAND_UP
-from opencombat.gui.const import MODE_MAN_CRAWLING
+from opencombat.game.const import MODE_MAN_STAND_UP
+from opencombat.game.const import MODE_MAN_CRAWLING
 
 if typing.TYPE_CHECKING:
-    from opencombat.gui.actor import BaseActor
+    from opencombat.game.actor import BaseActor
 
 RIFFLE = 'RIFFLE'
 

opencombat/gui.py

+# coding: utf-8
+from logging import Logger
+from tkinter import Tk
+
+from synergine2.config import Config
+from synergine2.log import get_logger
+
+
+class Gui(object):
+    def __init__(
+        self,
+        config: Config,
+        master: Tk,
+    ) -> None:
+        self._config = config
+        self._logger = get_logger(self.__class__.__name__, config)
+        self._master = master

opencombat/state.py

 from synergine2.config import Config
 from synergine2.log import get_logger
 
-from opencombat.exception import StateLoadError
 from opencombat.exception import NotFoundError
 from opencombat.simulation.base import TileStrategySimulation
 from opencombat.simulation.subject import TileSubject
 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
 
 
 class State(object):
         self._config = config
         self._simulation = simulation
 
+        schema_file_path = self._config.get(
+            'global.state_schema',
+            'opencombat/state.xsd',
+        )
+        self._xml_validator = XmlValidator(
+            config,
+            schema_file_path,
+        )
+
     def get_state(
         self,
         state_file_path: str,
         self,
         state_file_path: str,
     ) -> Element:
-        # open and read schema file
-        schema_file_path = self._config.get(
-            'global.state_schema',
-            'opencombat/state.xsd',
-        )
-        with open(schema_file_path, 'r') as schema_file:
-            schema_to_check = schema_file.read()
-
-        # open and read xml file
-        with open(state_file_path, 'r') as xml_file:
-            xml_to_check = xml_file.read()
-
-        xmlschema_doc = etree.fromstring(schema_to_check.encode('utf-8'))
-        xmlschema = etree.XMLSchema(xmlschema_doc)
-
-        try:
-            doc = etree.fromstring(xml_to_check.encode('utf-8'))
-        # check for file IO error
-        except IOError as exc:
-            self._logger.error(exc)
-            raise StateLoadError('Invalid File "{}": {}'.format(
-                state_file_path,
-                str(exc),
-            ))
-        # check for XML syntax errors
-        except etree.XMLSyntaxError as exc:
-            self._logger.error(exc)
-            raise StateLoadError('XML Syntax Error in "{}": {}'.format(
-                state_file_path,
-                str(exc.error_log),
-            ))
-        except Exception as exc:
-            self._logger.error(exc)
-            raise StateLoadError('Unknown error with "{}": {}'.format(
-                state_file_path,
-                str(exc),
-            ))
-
-        # validate against schema
-        try:
-            xmlschema.assertValid(doc)
-        except etree.DocumentInvalid as exc:
-            self._logger.error(exc)
-            raise StateLoadError(
-                'Schema validation error with "{}": {}'.format(
-                    state_file_path,
-                    str(exc),
-                )
-            )
-        except Exception as exc:
-            self._logger.error(exc)
-            raise StateLoadError(
-                'Unknown validation error with "{}": {}'.format(
-                    state_file_path,
-                    str(exc),
-                )
-            )
-
-        return doc
+        return self._xml_validator.validate_and_return(state_file_path)
 
 
 class StateConstructorBuilder(object):

opencombat/strategy/__init__.py

+# coding: utf-8

opencombat/strategy/manager.py

+# coding: utf-8
+import typing
+
+from synergine2.config import Config
+from synergine2.log import get_logger
+
+from opencombat.strategy.team.model import TeamModel
+from opencombat.strategy.team.stash import TeamStash
+from opencombat.strategy.troops import TroopClassBuilder
+from opencombat.strategy.unit.stash import UnitStash
+
+
+class TroopManager(object):
+    def __init__(
+        self,
+        config: Config,
+        units_file_path: str,
+        teams_file_path: str,
+    ) -> None:
+        self._config = config
+        self._logger = get_logger('TroopManager', config)
+
+        self._builder = TroopClassBuilder(config)
+        self._unit_stash = self._builder.get_unit_stash(
+            units_file_path,
+        )
+        self._team_stash = self._builder.get_team_stash(
+            units_file_path,
+            teams_file_path,
+        )
+
+    @property
+    def team_stash(self) -> TeamStash:
+        return self._team_stash
+
+    @property
+    def unit_stash(self) -> UnitStash:
+        return self._unit_stash
+
+    def get_troop_dump(
+        self,
+        countries_troops: typing.Dict[str, typing.List[TeamModel]],
+    ):
+        dumper = self._builder.get_troop_dumper()
+        return dumper.get_troop_dump(countries_troops)

opencombat/strategy/selection/__init__.py

+# coding: utf-8

opencombat/strategy/selection/gui.py

+# coding: utf-8
+import os
+import typing
+from tkinter import Tk
+from tkinter import Button
+from tkinter import YES
+from tkinter import StringVar
+from tkinter import OptionMenu
+from tkinter import W
+from tkinter import E
+from tkinter import messagebox
+from tkinter.ttk import Combobox
+from tkinter.ttk import Treeview
+
+
+import time
+from synergine2.config import Config
+
+from opencombat.gui import Gui
+from opencombat.strategy.manager import TroopManager
+from opencombat.strategy.team.stash import TeamStash
+
+
+class SelectTroopsGui(Gui):
+    def __init__(
+        self,
+        config: Config,
+        master: Tk,
+        team_stash: TeamStash,
+        troop_manager: TroopManager,
+        countries: typing.List[str],
+        troops_dir_path: str = '.',
+    ) -> None:
+        super().__init__(config, master)
+        self._master.title('Troops selection')
+        self._countries = countries
+        self._team_stash = team_stash
+        self._troop_manager = troop_manager
+        self._troops_dir_path = troops_dir_path
+        self._countries_troops = {}  # type: typing.Dict[str, typing.List[TeamModel]]  # nopep8
+
+        # Widgets
+        self._selected_country_var = StringVar(self._master)
+        self._selected_country_var.set(countries[0])
+        self._selected_country_var.trace('w', self._country_changed)
+        self._select_country_menu = OptionMenu(
+            self._master,
+            self._selected_country_var,
+            *countries,
+        )
+
+        self._teams_var = StringVar(self._master)
+        self._teams_list = Combobox(
+            self._master,
+            height=10,
+            state='readonly',
+            textvariable=self._teams_var,
+        )
+
+        self._add_troop_var = StringVar(self._master)
+        self._add_troop_button = Button(
+            self._master,
+            textvariable=self._add_troop_var,
+            command=self._add_troop,
+        )
+        self._add_troop_var.set('Add troop')
+
+        self._remove_troop_var = StringVar(self._master)
+        self._remove_troop_button = Button(
+            self._master,
+            textvariable=self._remove_troop_var,
+            command=self._remove_troop,
+        )
+        self._remove_troop_var.set('Remove troop')
+
+        self._troops_view = Treeview(
+            self._master,
+            columns=('Soldiers',),
+            height=10,
+        )
+        self._troops_view.heading('#0', text='Team')
+        self._troops_view.heading('#1', text='Soldiers')
+        self._troops_view.column('#0', stretch=YES)
+        self._troops_view.column('#1', stretch=YES)
+
+        self._generate_troops_var = StringVar(self._master)
+        self._generate_troops_button = Button(
+            self._master,
+            textvariable=self._generate_troops_var,
+            command=self._generate_troops,
+        )
+        self._generate_troops_var.set('Generate troops')
+
+        # Layout
+        self._select_country_menu.grid(row=0, column=0, sticky=W)
+        self._teams_list.grid(row=1, column=0, sticky=W)
+        self._add_troop_button.grid(row=2, column=0, sticky=W)
+        self._troops_view.grid(row=3, column=0, sticky=W)
+        self._remove_troop_button.grid(row=4, column=0, sticky=W)
+        self._generate_troops_button.grid(row=4, column=0, sticky=E)
+
+        # Default behaviours
+        self._selected_country_var.set(countries[0])
+        self._country_changed()
+
+    def _country_changed(self, *args, **kwargs) -> None:
+        country = self._selected_country_var.get()
+
+        self._logger.info('Change country to "{}"'.format(
+            country,
+        ))
+        country_team_names = [
+            t.name for
+            t in self._team_stash.get_team_by_country(
+                self._selected_country_var.get(),
+            )
+        ]
+
+        self._logger.debug('Change teams for: "{}"'.format(country_team_names))
+        self._teams_list['values'] = country_team_names
+        self._teams_var.set(country_team_names[0])
+        self._update_troops_view(country)
+
+    def _add_troop(self, *args, **kwargs) -> None:
+        if self._teams_var.get():
+            country = self._selected_country_var.get()
+            team_name = self._teams_var.get()
+
+            self._logger.info('Add troop "{}" to country "{}" troops'.format(
+                team_name,
+                team_name,
+            ))
+
+            team_model = self._team_stash.get_team_by_name(
+                team_name=team_name,
+                team_country=country,
+            )
+            self._countries_troops.setdefault(country, []).append(
+                team_model,
+            )
+            self._update_troops_view(country)
+
+    def _remove_troop(self, *args, **kwargs) -> None:
+        selecteds = self._troops_view.selection()
+
+        for selected in selecteds:
+            team_name = self._troops_view.item(selected)['text']
+            country = self._selected_country_var.get()
+
+            self._logger.info('Remove team "{}" from country "{}"'.format(
+                team_name,
+                country,
+            ))
+
+            team_model = self._team_stash.get_team_by_name(
+                team_name=team_name,
+                team_country=country,
+            )
+
+            self._countries_troops[country].remove(team_model)
+
+        if selecteds:
+            self._update_troops_view(country)
+
+    def _update_troops_view(self, country: str) -> None:
+        teams = self._countries_troops.get(country, [])
+
+        self._troops_view.delete(*self._troops_view.get_children())
+        for team in teams:
+            self._troops_view.insert(
+                '',
+                'end',
+                text=team.name,
+                values=('o' * len(team.units,))
+            )
+
+    def _generate_troops(self, *args, **kwargs) -> None:
+        # Must have team(s) in all countries
+        if len(self._countries_troops.keys()) == len(self._countries) \
+                and all(self._countries_troops.values()):
+
+            troops_file_path = os.path.join(
+                self._troops_dir_path,
+                'troops_{}.xml'.format(str(time.time())),
+            )
+
+            self._logger.info('Generate troops into file "{}"'.format(
+                troops_file_path,
+            ))
+
+            troops_xml = self._troop_manager.get_troop_dump(
+                self._countries_troops,
+            )
+            with open(troops_file_path, 'w+') as file:
+                file.write(troops_xml)
+
+            messagebox.showinfo(
+                'Troops file generated',
+                'Troops file successfully generate at "{}"'.format(
+                    troops_file_path,
+                )
+            )
+        else:
+            messagebox.showinfo(
+                'Missing information',
+                'All countries must have teams',
+            )

opencombat/strategy/team/__init__.py

+# coding: utf-8

opencombat/strategy/team/model.py

+# coding: utf-8
+import typing
+
+from opencombat.strategy.unit.model import UnitModel
+
+
+class TeamModel(object):
+    def __init__(
+        self,
+        id_: str,
+        name: str,
+        country: str,
+        units: typing.List[UnitModel],
+    ) -> None:
+        self._id = id_
+        self._name = name
+        self._country = country
+        self._units = units
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def country(self) -> str:
+        return self._country
+
+    @property
+    def units(self) -> typing.List[UnitModel]:
+        return self._units

opencombat/strategy/team/stash.py

+# coding: utf-8
+import typing
+from _elementtree import Element
+
+from synergine2.config import Config
+
+from opencombat.exception import NotFoundException
+from opencombat.strategy.team.model import TeamModel
+from opencombat.strategy.unit.stash import UnitStash
+from opencombat.util import get_text_xml_element
+from opencombat.xml import XmlValidator
+
+
+class TeamStash(object):
+    def __init__(
+        self,
+        config: Config,
+        teams_file_path: str,
+        unit_stash: UnitStash,
+    ) -> None:
+        self._config = config
+        self._teams = None  # type: typing.List[TeamModel]
+        self._unit_stash = unit_stash
+        self._teams_file_path = teams_file_path
+
+        self.schema_file_path = self._config.get(
+            'global.teams_schema',
+            'opencombat/strategy/teams.xsd',
+        )
+        self._xml_validator = XmlValidator(
+            config,
+            self.schema_file_path,
+        )
+        self._root_element = self._xml_validator.validate_and_return(
+            self._teams_file_path,
+        )
+
+    def _get_computed_teams(self) -> typing.List[TeamModel]:
+        teams = []
+
+        for team_element in self._root_element.findall('team'):
+            team_element = typing.cast(Element, team_element)
+
+            team_id = team_element.attrib['id']
+            team_country = team_element.attrib['country']
+            team_name = get_text_xml_element(team_element, 'name')
+            team_units = []
+
+            units_element = team_element.find('units')
+            for unit_element in units_element.findall('unit'):
+                unit_id = get_text_xml_element(unit_element, 'id')
+                unit = self._unit_stash.get_unit(unit_id, team_country)
+                team_units.append(unit)
+
+            teams.append(
+                TeamModel(
+                    id_=team_id,
+                    country=team_country,
+                    name=team_name,
+                    units=team_units
+                )
+            )
+
+        return teams
+
+    @property
+    def teams(self) -> typing.List[TeamModel]:
+        if self._teams is None:
+            self._teams = self._get_computed_teams()
+
+        return self._teams
+
+    def get_team(
+        self,
+        team_id: str,
+        team_country: str,
+    ) -> TeamModel:
+        for team in self.teams:
+            if team.id == team_id and team.country == team_country:
+                return team
+
+        raise NotFoundException(
+            'No team matching with id "{}" and country "{}" in "{}"'.format(
+                team_id,
+                team_country,
+                self.schema_file_path,
+            )
+        )
+
+    def get_team_by_name(
+        self,
+        team_name: str,
+        team_country: str,
+    ) -> TeamModel:
+        for team in self.teams:
+            if team.name == team_name and team.country == team_country:
+                return team
+
+        raise NotFoundException(
+            'No team matching with name "{}" and country "{}" in "{}"'.format(
+                team_name,
+                team_country,
+                self.schema_file_path,
+            )
+        )
+
+    def get_team_by_country(self, country: str) -> typing.List[TeamModel]:
+        teams = []  # type: typing.List[TeamModel]
+
+        for team in self.teams:
+            if team.country == country:
+                teams.append(team)
+
+        return teams

opencombat/strategy/teams.xml

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

opencombat/strategy/teams.xsd

+<?xml version="1.0" encoding="UTF-8" ?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+    <xs:element name="teams" type="teamstype"/>
+
+    <xs:complexType name="teamstype">
+        <xs:sequence>
+            <xs:element name="team" type="teamtype" maxOccurs="unbounded"/>
+        </xs:sequence>
+    </xs:complexType>
+
+    <xs:complexType name="teamtype">
+        <xs:sequence>
+            <xs:element name="name" type="xs:string" maxOccurs="1"/>
+            <xs:element name="units" type="unitstype" maxOccurs="1"/>
+        </xs:sequence>
+        <xs:attribute name="id" type="xs:string" use="required"/>
+        <xs:attribute name="country" type="xs:string" use="required"/>
+    </xs:complexType>
+
+    <xs:complexType name="unitstype">
+        <xs:sequence>
+            <xs:element name="unit" type="unittype" maxOccurs="unbounded" minOccurs="1"/>
+        </xs:sequence>
+    </xs:complexType>
+
+    <xs:complexType name="unittype">
+        <xs:sequence>
+            <xs:element name="id" type="xs:string" maxOccurs="1" minOccurs="1"/>
+        </xs:sequence>
+    </xs:complexType>
+
+</xs:schema>

opencombat/strategy/troops.py

+# coding: utf-8
+import typing
+
+from lxml import etree
+
+from synergine2.config import Config
+from synergine2.log import get_logger
+
+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
+
+
+class TroopDumper(object):
+    def __init__(
+        self,
+        config: Config,
+    ) -> None:
+        self._config = config
+        self._logger = get_logger('TroopDumper', config)
+
+    def get_troop_dump(
+        self,
+        countries_troops: typing.Dict[str, typing.List[TeamModel]],
+    ) -> str:
+        troops_template = self._config.resolve(
+            'global.troops_template',
+            'opencombat/strategy/troops_template.xml',
+        )
+        with open(troops_template, 'r') as xml_file:
+            template_str = xml_file.read()
+
+        parser = etree.XMLParser(remove_blank_text=True)
+        state_root = etree.fromstring(
+            template_str.encode('utf-8'),
+            parser,
+        )
+
+        for country, teams in countries_troops.items():
+            for team in teams:
+                troop_element = etree.SubElement(state_root, 'troop')
+                troop_element.attrib['country'] = country
+                troop_element.attrib['team_id'] = team.id
+
+        return pretty_xml(
+            etree.tostring(
+                state_root,
+            ).decode('utf-8'),
+        )
+
+
+class TroopClassBuilder(object):
+    def __init__(
+        self,
+        config: Config,
+    ) -> None:
+        self._logger = get_logger('TroopManagerBuilder', config)
+        self._config = config
+
+    def get_unit_stash(
+        self,
+        units_file_path: str,
+    ) -> UnitStash:
+        class_address = self._config.resolve(
+            'global.unit_stash',
+            'opencombat.strategy.unit.stash.UnitStash',
+        )
+        class_ = get_class_from_string_path(
+            self._config,
+            class_address,
+        )
+        return class_(
+            self._config,
+            units_file_path,
+        )
+
+    def get_team_stash(
+        self,
+        units_file_path: str,
+        teams_file_path: str,
+    ) -> TeamStash:
+        class_address = self._config.resolve(
+            'global.team_stash',
+            'opencombat.strategy.team.stash.TeamStash',
+        )
+        class_ = get_class_from_string_path(
+            self._config,
+            class_address,
+        )
+
+        unit_stash = self.get_unit_stash(units_file_path)
+        return class_(
+            self._config,
+            teams_file_path,
+            unit_stash=unit_stash,
+        )
+
+    def get_troop_dumper(self) -> TroopDumper:
+        class_address = self._config.resolve(
+            'global.troop_dumper',
+            'opencombat.strategy.troops.TroopDumper',
+        )
+        class_ = get_class_from_string_path(
+            self._config,
+            class_address,
+        )
+
+        return class_(
+            self._config,
+        )

opencombat/strategy/troops_template.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<troops>
+</troops>

opencombat/strategy/unit/__init__.py

+# coding: utf-8

opencombat/strategy/unit/model.py

+# coding: utf-8
+import typing
+
+from opencombat.simulation.subject import TileSubject
+
+
+class UnitModel(object):
+    def __init__(
+        self,
+        id_: str,
+        name: str,
+        class_: typing.Type[TileSubject],
+        country: str,
+    ) -> None:
+        self._id = id_
+        self._name = name
+        self._class = class_
+        self._country = country
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def class_(self) -> typing.Type[TileSubject]:
+        return self._class
+
+    @property
+    def country(self) -> str:
+        return self._country

opencombat/strategy/unit/stash.py

+# coding: utf-8
+import typing
+from _elementtree import Element
+
+from synergine2.config import Config
+
+from opencombat.exception import NotFoundException
+from opencombat.strategy.team.model import UnitModel
+from opencombat.util import get_text_xml_element
+from opencombat.util import get_class_from_string_path
+from opencombat.xml import XmlValidator
+
+
+class UnitStash(object):
+    def __init__(
+        self,
+        config: Config,
+        units_file_path: str,
+    ) -> None:
+        self._config = config
+        self._units = None  # type: typing.List[UnitModel]
+
+        self.schema_file_path = self._config.get(
+            'global.teams_schema',
+            'opencombat/strategy/units.xsd',
+        )
+        self._xml_validator = XmlValidator(
+            config,
+            self.schema_file_path,
+        )
+        self._root_element = self._xml_validator.validate_and_return(
+            units_file_path,
+        )
+
+    def _get_computed_units(self) -> typing.List[UnitModel]:
+        units = []
+
+        for unit_element in self._root_element.findall('unit'):
+            unit_element = typing.cast(Element, unit_element)
+
+            unit_id = unit_element.attrib['id']
+            unit_country = unit_element.attrib['country']
+            unit_name = get_text_xml_element(unit_element, 'name')
+            unit_class_path = get_text_xml_element(unit_element, 'type')
+            unit_class = get_class_from_string_path(
+                self._config,
+                unit_class_path,
+            )
+
+            units.append(
+                UnitModel(
+                    id_=unit_id,
+                    name=unit_name,
+                    class_=unit_class,
+                    country=unit_country,
+                )
+            )
+
+        return units
+
+    @property
+    def units(self) -> typing.List[UnitModel]:
+        if self._units is None:
+            self._units = self._get_computed_units()
+
+        return self._units
+
+    def get_unit(
+        self,
+        unit_id: str,
+        unit_country: str,
+    ) -> UnitModel:
+        for unit in self.units:
+            if unit.id == unit_id and unit.country == unit_country:
+                return unit
+
+        raise NotFoundException(
+            'No unit matching with id "{}" and country "{}" in "{}"'.format(
+                unit_id,
+                unit_country,
+                self.schema_file_path,
+            )
+        )

opencombat/strategy/units.xml

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

opencombat/strategy/units.xsd

+<?xml version="1.0" encoding="UTF-8" ?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+    <xs:element name="units" type="unitstype"/>
+
+    <xs:complexType name="unitstype">
+        <xs:sequence>
+            <xs:element name="unit" type="unittype" maxOccurs="unbounded" minOccurs="1"/>
+        </xs:sequence>
+    </xs:complexType>
+
+    <xs:complexType name="unittype">
+        <xs:sequence>
+            <xs:element name="name" type="xs:string" maxOccurs="1" minOccurs="1"/>
+            <xs:element name="type" type="xs:string" maxOccurs="1" minOccurs="1"/>
+        </xs:sequence>
+        <xs:attribute name="id" type="xs:string" use="required"/>
+        <xs:attribute name="country" type="xs:string" use="required"/>
+    </xs:complexType>
+
+</xs:schema>

opencombat/terminal/base.py

         self.map_dir_path = map_dir_path
 
     def run(self):
-        from opencombat.gui.base import Game
+        from opencombat.game.base import Game
 
         self.gui = Game(
             self.config,

opencombat/xml.py

+# coding: utf-8
+from _elementtree import Element
+
+from lxml import etree
+from synergine2.config import Config
+from synergine2.log import get_logger
+
+from opencombat.exception import StateLoadError
+
+
+class XmlValidator(object):
+    def __init__(
+        self,
+        config: Config,
+        schema_file_path: str,
+    ) -> None:
+        self._config = config
+        self._logger = get_logger('XmlValidator', config)
+        self._schema_file_path = schema_file_path
+
+    def validate_and_return(self, xml_file_path: str) -> Element:
+        with open(self._schema_file_path, 'r') as schema_file:
+            schema_to_check = schema_file.read()
+
+        # open and read xml file
+        with open(xml_file_path, 'r') as xml_file:
+            xml_to_check = xml_file.read()
+
+        xmlschema_doc = etree.fromstring(schema_to_check.encode('utf-8'))
+        xmlschema = etree.XMLSchema(xmlschema_doc)
+
+        try:
+            doc = etree.fromstring(xml_to_check.encode('utf-8'))
+        # check for file IO error
+        except IOError as exc:
+            self._logger.error(exc)
+            raise StateLoadError('Invalid File "{}": {}'.format(
+                xml_file_path,
+                str(exc),
+            ))
+        # check for XML syntax errors
+        except etree.XMLSyntaxError as exc:
+            self._logger.error(exc)
+            raise StateLoadError('XML Syntax Error in "{}": {}'.format(
+                xml_file_path,
+                str(exc.error_log),
+            ))
+        except Exception as exc:
+            self._logger.error(exc)
+            raise StateLoadError('Unknown error in "{}": {}'.format(
+                xml_file_path,
+                str(exc),
+            ))
+
+        # validate against schema
+        try:
+            xmlschema.assertValid(doc)
+        except etree.DocumentInvalid as exc:
+            self._logger.error(exc)
+            raise StateLoadError(
+                'Schema validation error in "{}": {}'.format(
+                    xml_file_path,
+                    str(exc),
+                )
+            )
+        except Exception as exc:
+            self._logger.error(exc)
+            raise StateLoadError(
+                'Unknown validation error in "{}": {}'.format(
+                    xml_file_path,
+                    str(exc),
+                )
+            )
+
+        return doc

run.py

     core.run()
 
 if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description='Run TileStrategy')
+    parser = argparse.ArgumentParser(
+        description='Run a map'
+    )
     parser.add_argument('map_dir_path', help='map directory path')
     parser.add_argument('--seed', dest='seed', default=None)
     parser.add_argument('--state', dest='state', default=None)

select_troops.py

+# coding: utf-8
+import argparse
+import typing
+from tkinter import Tk
+
+from synergine2.config import Config
+
+from opencombat.strategy.manager import TroopManager
+from opencombat.strategy.selection.gui import SelectTroopsGui
+
+
+def main(
+    units_file_path: str,
+    teams_file_path: str,
+    countries: typing.List[str],
+    troops_dir_path: str = '.',
+) -> None:
+    config = Config()
+    config.load_yaml('config.yaml')
+
+    troop_manager = TroopManager(
+        config,
+        units_file_path=units_file_path,
+        teams_file_path=teams_file_path,
+    )
+
+    master = Tk()
+    gui = SelectTroopsGui(
+        config,
+        master=master,
+        team_stash=troop_manager.team_stash,
+        troop_manager=troop_manager,
+        countries=countries,
+        troops_dir_path=troops_dir_path,
+    )
+    master.mainloop()
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(
+        description='Display troops selection gui',
+    )
+    parser.add_argument(
+        '--units',
+        dest='units_file_path',
+        default='opencombat/strategy/units.xml',
+    )
+    parser.add_argument(
+        '--teams',
+        dest='teams_file_path',
+        default='opencombat/strategy/teams.xml',
+    )
+    parser.add_argument(
+        '--country',
+        action='append',
+        dest='countries',
+    )
+    parser.add_argument(
+        '--troops-dir-path',
+        dest='troops_dir_path',
+        default='.',
+    )
+    args = parser.parse_args()
+
+    main(
+        units_file_path=args.units_file_path,
+        teams_file_path=args.teams_file_path,
+        countries=args.countries,
+        troops_dir_path=args.troops_dir_path,
+    )

test_config.yaml

       draw_interior_gap: 2
 
 global:
+    state_loader: "opencombat.state.StateLoader"
+    state_dumper: "opencombat.state.StateDumper"
+    state_schema: "opencombat/state.xsd"
+    state_template: "opencombat/state_template.xml"
+    unit_stash: "opencombat.strategy.unit.stash.UnitStash"
+    team_stash: "opencombat.strategy.team.stash.TeamStash"
+    teams_schema: "opencombat/strategy/teams.xsd"
+    units_schema: "opencombat/strategy/units.xsd"
+    troop_dumper: "opencombat.strategy.troops.TroopDumper"
+    troop_schema: "opencombat/strategy/troops.xsd"
     cache_dir_path: 'cache'
     include_path:
       maps:

tests/fixtures/teams.xml

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

tests/fixtures/units.xml

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

tests/strategy/test_teams.py

+# coding: utf-8
+import pytest
+from synergine2.config import Config
+
+from opencombat.exception import NotFoundException
+from opencombat.strategy.team.model import TeamModel
+from opencombat.strategy.team.stash import TeamStash
+from opencombat.strategy.unit.model import UnitModel
+from opencombat.strategy.unit.stash import UnitStash
+
+
+@pytest.fixture
+def unit_stash(
+    config: Config,
+) -> UnitStash:
+    return UnitStash(
+        config,
+        'tests/fixtures/units.xml',
+    )
+
+
+def test_units_stash__ok__instantiate(
+    config: Config,
+    unit_stash: UnitStash,
+):
+    TeamStash(
+        config,
+        'opencombat/strategy/teams.xml',
+        unit_stash=unit_stash,
+    )
+
+
+def test_team_stash__ok__get_teams(
+    config: Config,
+    unit_stash: UnitStash,
+):
+    stash = TeamStash(
+        config,
+        'tests/fixtures/teams.xml',
+        unit_stash=unit_stash,
+    )
+    assert stash.teams
+    assert 2 == len(stash.teams)
+    assert isinstance(stash.teams[0], TeamModel)
+    assert isinstance(stash.teams[1], TeamModel)
+
+    assert 'std_team' == stash.teams[0].id
+    assert 'Standard team' == stash.teams[0].name
+    assert 'URSS' == stash.teams[0].country
+    assert stash.teams[0].units
+    assert 4 == len(stash.teams[0].units)
+    assert isinstance(stash.teams[0].units[0], UnitModel)
+    assert 'std_soldier' == stash.teams[0].units[0].id
+    assert 'std_soldier' == stash.teams[0].units[1].id
+    assert 'std_soldier' == stash.teams[0].units[2].id
+    assert 'std_soldier' == stash.teams[0].units[3].id
+
+    assert 'std_team' == stash.teams[1].id
+    assert 'Standard team' == stash.teams[1].name
+    assert 'DE' == stash.teams[1].country
+    assert stash.teams[0].units
+    assert 4 == len(stash.teams[1].units)
+    assert isinstance(stash.teams[1].units[0], UnitModel)
+    assert 'std_soldier' == stash.teams[1].units[0].id
+    assert 'std_soldier' == stash.teams[1].units[1].id
+    assert 'std_soldier' == stash.teams[1].units[2].id
+    assert 'std_soldier' == stash.teams[1].units[3].id
+
+
+def test_teams_stash__ok__get_unit(
+    config: Config,
+    unit_stash: UnitStash,
+):
+    stash = TeamStash(
+        config,
+        'tests/fixtures/teams.xml',
+        unit_stash=unit_stash,
+    )
+    assert stash.get_team('std_team', 'URSS')
+
+
+def test_teams_stash__error__get_team_wrong_country(
+    config: Config,
+    unit_stash: UnitStash,
+):
+    stash = TeamStash(
+        config,
+        'tests/fixtures/teams.xml',
+        unit_stash=unit_stash,
+    )
+
+    with pytest.raises(NotFoundException):
+        stash.get_team('std_team', 'UNKNOWN')
+
+
+def test_teams_stash__error__get_team_wrong_id(
+    config: Config,
+    unit_stash: UnitStash,
+):
+    stash = TeamStash(
+        config,
+        'tests/fixtures/teams.xml',
+        unit_stash=unit_stash,
+    )
+
+    with pytest.raises(NotFoundException):
+        stash.get_team('unknown', 'URSS')

tests/strategy/test_units.py

+# coding: utf-8
+import pytest
+from synergine2.config import Config
+
+from opencombat.exception import NotFoundException
+from opencombat.simulation.subject import ManSubject
+from opencombat.strategy.team.model import UnitModel
+from opencombat.strategy.unit.stash import UnitStash
+
+
+def test_units_stash__ok__instantiate(
+    config: Config,
+):
+    UnitStash(
+        config,
+        'opencombat/strategy/units.xml',
+    )
+
+
+def test_units_stash__ok__get_units(
+    config: Config,
+):
+    stash = UnitStash(
+        config,
+        'tests/fixtures/units.xml',
+    )
+    assert stash.units
+    assert 2 == len(stash.units)
+    assert isinstance(stash.units[0], UnitModel)
+    assert isinstance(stash.units[1], UnitModel)
+
+    assert 'std_soldier' == stash.units[0].id
+    assert 'Standard soldier' == stash.units[0].name
+    assert 'URSS' == stash.units[0].country
+    assert ManSubject == stash.units[0].class_
+
+    assert 'std_soldier' == stash.units[1].id
+    assert 'Standard soldier' == stash.units[1].name
+    assert 'DE' == stash.units[1].country
+    assert ManSubject == stash.units[1].class_
+
+
+def test_units_stash__ok__get_unit(
+    config: Config,
+):
+    stash = UnitStash(
+        config,
+        'tests/fixtures/units.xml',
+    )
+    assert stash.get_unit('std_soldier', 'URSS')
+
+
+def test_units_stash__error__get_unit_wrong_country(
+    config: Config,
+):
+    stash = UnitStash(
+        config,
+        'tests/fixtures/units.xml',
+    )
+
+    with pytest.raises(NotFoundException):
+        stash.get_unit('std_soldier', 'UNKNOWN')
+
+
+def test_units_stash__error__get_unit_wrong_id(
+    config: Config,
+):
+    stash = UnitStash(
+        config,
+        'tests/fixtures/units.xml',
+    )
+
+    with pytest.raises(NotFoundException):
+        stash.get_unit('unknown', 'URSS')