Merge branch 'feature/dump_state'

README.md

 * C: crouch
 * M: move
 * F: fire (not implemented)
+* S: Save current state into OpenCombat dir (or dir specified with `--state-save-dir`)

config.yaml

 
 global:
     state_loader: "opencombat.state.StateLoader"
+    state_dumper: "opencombat.state.StateDumper"
     state_schema: "opencombat/state.xsd"
+    state_template: "opencombat/state_template.xml"
     cache_dir_path: 'cache'
     include_path:
       maps:

maps/001/state1.xml

             <position>72,7</position>
             <direction>90</direction>
             <mode>standup</mode>
-            <side>URSS</side>
+            <properties>
+                <item>
+                    <key>SELECTION_COLOR_RGB</key>
+                    <value>204,0,0</value>
+                </item>
+                <item>
+                    <key>FLAG</key>
+                    <value>FLAG_URSS</value>
+                </item>
+                <item>
+                    <key>SIDE</key>
+                    <value>ALLIES</value>
+                </item>
+            </properties>
         </subject>
         <subject>
             <type>opencombat.simulation.subject.ManSubject</type>
             <position>72,9</position>
             <direction>90</direction>
             <mode>standup</mode>
-            <side>URSS</side>
+            <properties>
+                <item>
+                    <key>SELECTION_COLOR_RGB</key>
+                    <value>204,0,0</value>
+                </item>
+                <item>
+                    <key>FLAG</key>
+                    <value>FLAG_URSS</value>
+                </item>
+                <item>
+                    <key>SIDE</key>
+                    <value>ALLIES</value>
+                </item>
+            </properties>
         </subject>
         <subject>
             <type>opencombat.simulation.subject.ManSubject</type>
             <position>72,11</position>
             <direction>90</direction>
             <mode>standup</mode>
-            <side>URSS</side>
+            <properties>
+                <item>
+                    <key>SELECTION_COLOR_RGB</key>
+                    <value>204,0,0</value>
+                </item>
+                <item>
+                    <key>FLAG</key>
+                    <value>FLAG_URSS</value>
+                </item>
+                <item>
+                    <key>SIDE</key>
+                    <value>ALLIES</value>
+                </item>
+            </properties>
         </subject>
         <subject>
             <type>opencombat.simulation.subject.ManSubject</type>
             <position>58,54</position>
             <direction>270</direction>
             <mode>hiding</mode>
-            <side>DE</side>
+            <properties>
+                <item>
+                    <key>SELECTION_COLOR_RGB</key>
+                    <value>0,81,211</value>
+                </item>
+                <item>
+                    <key>FLAG</key>
+                    <value>FLAG_DE</value>
+                </item>
+                <item>
+                    <key>SIDE</key>
+                    <value>AXIS</value>
+                </item>
+            </properties>
         </subject>
         <subject>
             <type>opencombat.simulation.subject.ManSubject</type>
             <position>58,56</position>
             <direction>270</direction>
             <mode>hiding</mode>
-            <side>DE</side>
+            <properties>
+                <item>
+                    <key>SELECTION_COLOR_RGB</key>
+                    <value>0,81,211</value>
+                </item>
+                <item>
+                    <key>FLAG</key>
+                    <value>FLAG_DE</value>
+                </item>
+                <item>
+                    <key>SIDE</key>
+                    <value>AXIS</value>
+                </item>
+            </properties>
         </subject>
         <subject>
             <type>opencombat.simulation.subject.ManSubject</type>
             <position>58,58</position>
             <direction>270</direction>
             <mode>hiding</mode>
-            <side>DE</side>
+            <properties>
+                <item>
+                    <key>SELECTION_COLOR_RGB</key>
+                    <value>0,81,211</value>
+                </item>
+                <item>
+                    <key>FLAG</key>
+                    <value>FLAG_DE</value>
+                </item>
+                <item>
+                    <key>SIDE</key>
+                    <value>AXIS</value>
+                </item>
+            </properties>
         </subject>
     </subjects>
 </state>

opencombat/const.py

 COLLECTION_ALIVE = 'ALIVE'
 
 FLAG = 'FLAG'
-FLAG_DE = 'DE'
-FLAG_URSS = 'URSS'
+FLAG_DE = 'FLAG_DE'
+FLAG_URSS = 'FLAG_URSS'
 
 SIDE = 'SIDE'
 COMBAT_MODE = 'COMBAT_MODE'

opencombat/gui/base.py

 from opencombat.gui.animation import ANIMATION_WALK
 from opencombat.gui.animation import ANIMATION_CRAWL
 from opencombat.gui.fire import GuiFiringEvent
+from opencombat.gui.state import SaveStateInteraction
 from opencombat.simulation.interior import InteriorManager
 from opencombat.simulation.tmx import TileMap
 from opencombat.user_action import UserAction
             if k == key.F:
                 self.user_action_pending = UserAction.ORDER_FIRE
 
+        if k == key.S:
+            self.run_save_state()
+
     def draw(self) -> None:
         super().draw()
 
+    def run_save_state(self) -> None:
+        interaction = self.layer_manager\
+            .interaction_manager\
+            .get_for_user_action(
+                UserAction.SAVE_STATE,
+            )
+        interaction.execute()
+
 
 class BackgroundLayer(cocos.layer.Layer):
     def __init__(
         self.layer_manager.interaction_manager.register(MoveFastActorInteraction, self.layer_manager)
         self.layer_manager.interaction_manager.register(MoveCrawlActorInteraction, self.layer_manager)
         self.layer_manager.interaction_manager.register(FireActorInteraction, self.layer_manager)
+        self.layer_manager.interaction_manager.register(
+            SaveStateInteraction,
+            self.layer_manager,
+        )
 
     def set_subject_position(
         self,

opencombat/gui/state.py

+# coding: utf-8
+
+from synergine2.terminals import TerminalPackage
+from synergine2_cocos2d.interaction import Interaction
+
+from opencombat.simulation.state import SaveStateSimulationAction
+from opencombat.user_action import UserAction
+
+
+class SaveStateInteraction(Interaction):
+    gui_action = UserAction.SAVE_STATE
+
+    def get_package_for_terminal(self) -> TerminalPackage:
+        return TerminalPackage(
+            simulation_actions=[
+                (SaveStateSimulationAction, {}),
+            ]
+        )

opencombat/simulation/state.py

+import os
+import time
+import typing
+
+from synergine2.config import Config
+from synergine2.simulation import SimulationBehaviour
+from synergine2.simulation import Event
+from synergine2.simulation import Simulation
+
+from opencombat.state import StateConstructorBuilder
+
+
+class SaveStateSimulationAction(SimulationBehaviour):
+    def __init__(
+        self,
+        config: Config,
+        simulation: Simulation,
+    ):
+        super().__init__(config, simulation)
+        self.state_dumper = StateConstructorBuilder(
+            config,
+            simulation,
+        ).get_state_dumper()
+        self.state_save_dir = self.config.resolve('_runtime.state_save_dir')
+
+    def run(self, data):
+        pass
+
+    def action(self, data) -> typing.List[Event]:
+        state_file_path = os.path.join(
+            self.state_save_dir,
+            'state_{}.xml'.format(time.time())
+        )
+        with open(state_file_path, 'w+') as file:
+            file.write(self.state_dumper.get_state_dump())
+
+        return []
+
+    @classmethod
+    def merge_data(cls, new_data, start_data=None):
+        pass

opencombat/state.py

 
 from synergine2.config import Config
 from synergine2.log import get_logger
-from synergine2_cocos2d.const import SELECTION_COLOR_RGB
 
 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.const import FLAG, 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
 
 
 class State(object):
             get_text_xml_element(subject_element, 'direction'),
         )
 
-        side = get_text_xml_element(subject_element, 'side')
-        if side == 'DE':
-            subject_properties.update({
-                SELECTION_COLOR_RGB: DE_COLOR,
-                FLAG: FLAG_DE,
-                SIDE: 'AXIS',
-            })
-        elif side == 'URSS':
-            subject_properties.update({
-                SELECTION_COLOR_RGB: URSS_COLOR,
-                FLAG: FLAG_URSS,
-                SIDE: 'ALLIES',
-            })
-        else:
-            raise NotImplementedError('Don\'t know "{}" side'.format(
-                side,
-            ))
+        properties_element = subject_element.find('properties')
+        decode_properties_map = self._get_decode_properties_map()
+
+        for item_element in properties_element.findall('item'):
+            key_text = item_element.find('key').text
+            value_text = item_element.find('value').text
+
+            try:
+                decoded_value = decode_properties_map[key_text](value_text)
+            except KeyError:
+                raise NotFoundError(
+                    'You try to load property "{}" but it is unknown'.format(
+                        key_text,
+                    )
+                )
+
+            subject_properties[key_text] = decoded_value
 
         subject.properties = subject_properties
 
+    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,
+        }
+
+
+class StateDumper(object):
+    def __init__(
+        self,
+        config: Config,
+        simulation: TileStrategySimulation,
+    ) -> None:
+        self._logger = get_logger('StateDumper', config)
+        self._config = config
+        self._simulation = simulation
+
+        state_template = self._config.resolve(
+           'global.state_template',
+           'opencombat/state_template.xml',
+        )
+        with open(state_template, 'r') as xml_file:
+            template_str = xml_file.read()
+
+        parser = etree.XMLParser(remove_blank_text=True)
+        self._state_root = etree.fromstring(
+            template_str.encode('utf-8'),
+            parser,
+        )
+        self._state_root_filled = False
+
+    def get_state_dump(self) -> str:
+        if not self._state_root_filled:
+            self._fill_state_root()
+
+        return pretty_xml(
+            etree.tostring(
+                self._state_root,
+            ).decode('utf-8'),
+        )
+
+    def _fill_state_root(self) -> None:
+        subjects_element = self._state_root.find('subjects')
+
+        for subject in self._simulation.subjects:
+            subject_element = etree.SubElement(subjects_element, 'subject')
+
+            position_element = etree.SubElement(subject_element, 'type')
+            position_element.text = '.'.join([
+                subject.__module__,
+                subject.__class__.__name__,
+            ])
+
+            position_element = etree.SubElement(subject_element, 'position')
+            position_element.text = ','.join(map(str, subject.position))
+
+            direction_element = etree.SubElement(subject_element, 'direction')
+            direction_element.text = str(subject.direction)
+
+            properties_element = etree.SubElement(
+                subject_element,
+                'properties',
+            )
+            encode_properties_map = self._get_encode_properties_map()
+
+            for key, value in subject.properties.items():
+                item_element = etree.SubElement(properties_element, 'item')
+                key_element = etree.SubElement(item_element, 'key')
+                value_element = etree.SubElement(item_element, 'value')
+
+                key_element.text = str(key)
+                value_element.text = encode_properties_map[key](value)
+
+        self._state_root_filled = True
+
+    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,
+        }
+
 
 class StateLoader(object):
     def __init__(
         return doc
 
 
-class StateLoaderBuilder(object):
+class StateConstructorBuilder(object):
     def __init__(
         self,
         config: Config,
         simulation: TileStrategySimulation,
     ) -> None:
-        self._logger = get_logger('StateLoader', config)
+        self._logger = get_logger('StateConstructorBuilder', config)
         self._config = config
         self._simulation = simulation
 
             self._config,
             self._simulation,
         )
+
+    def get_state_dumper(
+        self,
+    ) -> StateDumper:
+        class_address = self._config.resolve(
+            'global.state_dumper',
+            'opencombat.state.StateDumper',
+        )
+        state_loader_class = get_class_from_string_path(
+            self._config,
+            class_address,
+        )
+        return state_loader_class(
+            self._config,
+            self._simulation,
+        )

opencombat/state.xsd

         </xs:restriction>
     </xs:simpleType>
 
-    <xs:simpleType name="sidetype" final="restriction">
-        <xs:restriction base="xs:string">
-            <xs:enumeration value="DE"/>
-            <xs:enumeration value="URSS"/>
-            <xs:enumeration value="US"/>
-        </xs:restriction>
-    </xs:simpleType>
+    <xs:complexType name="propertiestype">
+        <xs:sequence>
+            <xs:element maxOccurs="unbounded" name="item">
+                <xs:complexType>
+                    <xs:sequence>
+                        <xs:element name="key" type="xs:string"  />
+                        <xs:element name="value" type="xs:string" />
+                    </xs:sequence>
+                </xs:complexType>
+            </xs:element>
+        </xs:sequence>
+    </xs:complexType>
 
     <xs:simpleType name="modetype" final="restriction">
         <xs:restriction base="xs:string">
             <xs:element name="position" type="positiontype" minOccurs="1"/>
             <xs:element name="direction" type="directiontype" minOccurs="1"/>
             <xs:element name="mode" type="modetype" minOccurs="1"/>
-            <xs:element name="side" type="sidetype" minOccurs="1"/>
+            <xs:element name="properties" type="propertiestype" minOccurs="1"/>
         </xs:sequence>
     </xs:complexType>
 

opencombat/state_template.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<state type="before_battle">
+    <map>
+    </map>
+    <subjects>
+    </subjects>
+</state>

opencombat/user_action.py

 
 
 class UserAction(BaseUserAction):
+    SAVE_STATE = 'SAVE_STATE'
     ORDER_MOVE = 'ORDER_MOVE'
     ORDER_MOVE_FAST = 'ORDER_MOVE_FAST'
     ORDER_MOVE_CRAWL = 'ORDER_MOVE_CRAWL'

opencombat/util.py

 import importlib
 
 from _elementtree import Element
+import xml.dom.minidom as md
+from io import StringIO
 
 from opencombat.exception import NotFoundError
 
         return default_value
 
     return found.text
+
+
+def pretty_xml(xml_str):
+    """
+    Return a pretty xmlstr of given xml str. Thank's to:
+        https://gist.github.com/eliask/d8517790b11edac75983d1e6fdab3cab
+    :param xml_str: ugly xml str
+    :return: pretty xml str
+    """
+    indent = ' ' * 4
+    return '\n'.join(
+        line for line in
+        md.parse(StringIO(xml_str)).toprettyxml(indent=indent).split('\n')
+        if line.strip()
+    )

run.py

 
 from opencombat.simulation.base import TileStrategySimulation
 from opencombat.simulation.base import TileStrategySubjects
-from opencombat.state import StateLoaderBuilder
+from opencombat.state import StateConstructorBuilder
 from opencombat.terminal.base import CocosTerminal
 
 
     map_dir_path: str,
     seed_value: int=None,
     state_file_path: str=None,
+    state_save_dir: str='.',
 ):
     if seed_value is not None:
         seed(seed_value)
 
     config = Config()
     config.load_yaml('config.yaml')
+
+    # Runtime config
+    config.setdefault('_runtime', {})['state_save_dir'] = state_save_dir
+
     level = logging.getLevelName(config.resolve('global.logging_level', 'ERROR'))
     logger = get_default_logger(level=level)
 
     subjects = TileStrategySubjects(simulation=simulation)
 
     if state_file_path:
-        state_loader_builder = StateLoaderBuilder(config, simulation)
+        state_loader_builder = StateConstructorBuilder(config, simulation)
         state_loader = state_loader_builder.get_state_loader()
         state = state_loader.get_state(state_file_path)
         subjects.extend(state.subjects)
     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)
+    parser.add_argument(
+        '--state-save-dir',
+        dest='state_save_dir',
+        default='.',
+    )
 
     args = parser.parse_args()
 
-    main(args.map_dir_path, seed_value=args.seed, state_file_path=args.state)
+    main(
+        args.map_dir_path,
+        seed_value=args.seed,
+        state_file_path=args.state,
+        state_save_dir=args.state_save_dir,
+    )

tests/fixtures/state_error_schema.xml

             <position>1,1</position>
             <direction>90</direction>
             <mode>standup</mode>
-            <side>URSS</side>
         </subject>
         <subjectFOO>
             <type>opencombat.simulation.subject.ManSubject</type>
             <position>10,10</position>
             <direction>270</direction>
             <mode>hiding</mode>
-            <side>DE</side>
         </subjectFOO>
     </subjects>
 </state>

tests/fixtures/state_ok.xml

             <position>1,1</position>
             <direction>90</direction>
             <mode>standup</mode>
-            <side>URSS</side>
+            <properties>
+                <item>
+                    <key>SELECTION_COLOR_RGB</key>
+                    <value>204,0,0</value>
+                </item>
+                <item>
+                    <key>FLAG</key>
+                    <value>FLAG_URSS</value>
+                </item>
+                <item>
+                    <key>SIDE</key>
+                    <value>ALLIES</value>
+                </item>
+            </properties>
         </subject>
         <subject>
             <type>opencombat.simulation.subject.ManSubject</type>
             <position>10,10</position>
             <direction>270</direction>
             <mode>hiding</mode>
-            <side>DE</side>
+            <properties>
+                <item>
+                    <key>SELECTION_COLOR_RGB</key>
+                    <value>0,81,211</value>
+                </item>
+                <item>
+                    <key>FLAG</key>
+                    <value>FLAG_DE</value>
+                </item>
+                <item>
+                    <key>SIDE</key>
+                    <value>AXIS</value>
+                </item>
+            </properties>
         </subject>
     </subjects>
 </state>

tests/test_state.py

 # coding: utf-8
+from collections import OrderedDict
+
 import pytest
 from synergine2.config import Config
+from synergine2_cocos2d.const import SELECTION_COLOR_RGB
 
 from opencombat.exception import StateLoadError
+from opencombat.simulation.base import TileStrategySimulation
+from opencombat.simulation.base import TileStrategySubjects
 from opencombat.simulation.subject import ManSubject
-from opencombat.state import StateLoaderBuilder, StateLoader
+from opencombat.state import StateConstructorBuilder, StateDumper
+from opencombat.state import StateLoader
+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
 
 
 class MyStateLoader(StateLoader):
     return StateLoader(config, simulation)
 
 
+@pytest.fixture
+def simulation_for_dump(config) -> TileStrategySimulation:
+    simulation = TileStrategySimulation(
+        config,
+        'tests/fixtures/map_a/map_a.tmx',
+    )
+    subjects = TileStrategySubjects(simulation=simulation)
+    simulation.subjects = subjects
+
+    man1 = ManSubject(config, simulation)
+    man1.position = (10, 11)
+    man1.direction = 42
+    man1.properties = OrderedDict([
+        (SELECTION_COLOR_RGB, DE_COLOR),
+        (FLAG, FLAG_DE),
+        (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'),
+    ])
+
+    subjects.append(man1)
+    subjects.append(man2)
+
+    return simulation
+
+
 def test_state_loader_builder__ok__nominal_case(
     simulation,
 ):
             'state_loader': 'tests.test_state.MyStateLoader',
         }
     })
-    builder = StateLoaderBuilder(config, simulation)
+    builder = StateConstructorBuilder(config, simulation)
     state_loader = builder.get_state_loader()
     assert type(state_loader) == MyStateLoader
 
     assert (10, 10) == state.subjects[1].position
     assert 90.0 == state.subjects[0].direction
     assert 270.0 == state.subjects[1].direction
+
+    assert {
+               'SELECTION_COLOR_RGB': (204, 0, 0),
+               'FLAG': 'FLAG_URSS',
+               'SIDE': 'ALLIES',
+           } == state.subjects[0].properties
+    assert {
+               'SELECTION_COLOR_RGB': (0, 81, 211),
+               'FLAG': 'FLAG_DE',
+               'SIDE': 'AXIS',
+           } == state.subjects[1].properties
+
+
+def test_state__ok__dump(
+    config: Config,
+    simulation_for_dump: TileStrategySimulation,
+):
+    state_dumper = StateDumper(config, simulation_for_dump)
+    state_xml_str = state_dumper.get_state_dump()
+    assert """<?xml version="1.0" ?>
+<state type="before_battle">
+    <map>
+    </map>
+    <subjects>
+        <subject>
+            <type>opencombat.simulation.subject.ManSubject</type>
+            <position>10,11</position>
+            <direction>42</direction>
+            <properties>
+                <item>
+                    <key>SELECTION_COLOR_RGB</key>
+                    <value>0,81,211</value>
+                </item>
+                <item>
+                    <key>FLAG</key>
+                    <value>FLAG_DE</value>
+                </item>
+                <item>
+                    <key>SIDE</key>
+                    <value>AXIS</value>
+                </item>
+            </properties>
+        </subject>
+        <subject>
+            <type>opencombat.simulation.subject.ManSubject</type>
+            <position>16,8</position>
+            <direction>197</direction>
+            <properties>
+                <item>
+                    <key>SELECTION_COLOR_RGB</key>
+                    <value>204,0,0</value>
+                </item>
+                <item>
+                    <key>FLAG</key>
+                    <value>FLAG_URSS</value>
+                </item>
+                <item>
+                    <key>SIDE</key>
+                    <value>ALLIES</value>
+                </item>
+            </properties>
+        </subject>
+    </subjects>
+</state>""" == state_xml_str