WIP

config.yaml

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

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
+import typing
+
+from synergine2.simulation import SimulationBehaviour
+from synergine2.simulation import Event
+from synergine2.terminals import TerminalPackage
+from synergine2_cocos2d.interaction import Interaction
+
+from opencombat.user_action import UserAction
+
+
+class SaveStateSimulationAction(SimulationBehaviour):
+    def run(self, data):
+        pass
+
+    def action(self, data) -> typing.List[Event]:
+        # TODO BS 2018-06-14: dump state here
+        pass
+
+    @classmethod
+    def merge_data(cls, new_data, start_data=None):
+        pass
+
+
+class SaveStateInteraction(Interaction):
+    gui_action = UserAction.SAVE_STATE
+
+    def get_package_for_terminal(self) -> TerminalPackage:
+        return TerminalPackage(
+            simulation_actions=[
+                (SaveStateSimulationAction, {}),
+            ]
+        )

opencombat/state.py

 from opencombat.simulation.subject import TileSubject
 from opencombat.util import get_class_from_string_path
 from opencombat.util import get_text_xml_element
-from opencombat.const import FLAG, SIDE
+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
             get_text_xml_element(subject_element, 'direction'),
         )
 
+        # FIXME BS 218-06-14: There is a confusion: don't use side but
+        # "team". It probably need change in other code.
         side = get_text_xml_element(subject_element, 'side')
         if side == 'DE':
             subject_properties.update({
         subject.properties = subject_properties
 
 
+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()
+        self._state_root = etree.fromstring(template_str.encode('utf-8'))
+
+    def get_state_dump(self) -> Element:
+        # TODO BS 2018-06-14: Code here xml construction
+        return self._state_root
+
+
 class StateLoader(object):
     def __init__(
         self,

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'

run.py

     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)
     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/test_state.py

 # coding: utf-8
 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 StateLoaderBuilder, 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)
+
+    man1 = ManSubject(config, simulation)
+    man1.position = (10, 11)
+    man1.direction = 42
+    man1.properties = {
+        SELECTION_COLOR_RGB: DE_COLOR,
+        FLAG: FLAG_DE,
+        SIDE: 'AXIS',
+    }
+
+    man2 = ManSubject(config, simulation)
+    man2.position = (16, 8)
+    man2.direction = 197
+    man2.properties = {
+        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,
 ):
     assert (10, 10) == state.subjects[1].position
     assert 90.0 == state.subjects[0].direction
     assert 270.0 == state.subjects[1].direction
+
+
+def test_state__ok__dump(
+    config: Config,
+    simulation_for_dump: TileStrategySimulation,
+):
+    state_dumper = StateDumper(config, simulation_for_dump)
+    state_xml = state_dumper.get_state_dump()
+    assert False