save state with S key

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'

opencombat/simulation/state.py

+import os
+import time
 import typing
 
-from synergine2.simulation import SimulationBehaviour, Event
+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]:
-        # TODO BS 2018-06-14: dump state here
-        pass
+        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):

opencombat/state.py

         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,
+        )

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
 
 
 
     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)

tests/test_state.py

 from opencombat.simulation.base import TileStrategySimulation
 from opencombat.simulation.base import TileStrategySubjects
 from opencombat.simulation.subject import ManSubject
-from opencombat.state import StateLoaderBuilder, StateDumper
+from opencombat.state import StateConstructorBuilder, StateDumper
 from opencombat.state import StateLoader
 from opencombat.const import FLAG
 from opencombat.const import SIDE
             '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