Issue #46: write xml file and xsd, begin state loader

config.yaml

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

maps/001/state1.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<state type="before_battle">
+    <map>
+        <name>001</name>
+    </map>
+    <subjects>
+        <subject>
+            <type>opencombat.simulation.subject.ManSubject</type>
+            <position>1,1</position>
+            <direction>90</direction>
+            <mode>standup</mode>
+            <side>URSS</side>
+        </subject>
+        <subject>
+            <type>opencombat.simulation.subject.ManSubject</type>
+            <position>10,10</position>
+            <direction>270</direction>
+            <mode>hiding</mode>
+            <side>DE</side>
+        </subject>
+    </subjects>
+</state>

opencombat/exception.py

 
 class WrongMode(OpenCombatException):
     pass
+
+
+class StateLoadError(OpenCombatException):
+    pass

opencombat/state.py

+# coding: utf-8
+import importlib
+import typing
+from io import StringIO
+import sys
+
+from lxml import etree
+
+from synergine2.config import Config
+from synergine2.log import get_logger
+from synergine2.simulation import Subject
+
+from opencombat.exception import StateLoadError
+
+
+class StateLoader(object):
+    def __init__(
+        self,
+        config: Config,
+        state_file_path: str,
+    ) -> None:
+        self.logger = get_logger('StateLoader', config)
+        self.config = config
+        self.state_file_path = state_file_path
+        self._validate()
+
+    def _validate(self) -> None:
+        # 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(self.state_file_path, 'r') as xml_file:
+            xml_to_check = xml_file.read()
+
+        xmlschema_doc = etree.parse(StringIO(schema_to_check))
+        xmlschema = etree.XMLSchema(xmlschema_doc)
+
+        try:
+            doc = etree.parse(StringIO(xml_to_check))
+        # check for file IO error
+        except IOError as exc:
+            self.logger.error(exc)
+            raise StateLoadError('Invalid File "{}": {}'.format(
+                self.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(
+                self.state_file_path,
+                str(exc.error_log),
+            ))
+        except Exception as exc:
+            self.logger.error(exc)
+            raise StateLoadError('Unknown error with "{}": {}'.format(
+                self.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(
+                    self.state_file_path,
+                    str(exc),
+                )
+            )
+        except Exception as exc:
+            self.logger.error(exc)
+            raise StateLoadError(
+                'Unknown validation error with "{}": {}'.format(
+                    self.state_file_path,
+                    str(exc),
+                )
+            )
+
+    def get_subjects(self) -> typing.List[Subject]:
+        raise NotImplementedError('TODO')
+
+
+class StateLoaderBuilder(object):
+    def __init__(
+        self,
+        config: Config,
+    ) -> None:
+        self.logger = get_logger('StateLoader', config)
+        self.config = config
+
+    def get_state_loader(
+        self,
+        state_file_path: str,
+    ) -> StateLoader:
+        class_address = self.config.get(
+            'global.state_loader',
+            'opencombat.state.StateLoader',
+        )
+        module_address = '.'.join(class_address.split('.')[:-1])
+        class_name = class_address.split('.')[-1]
+        module_ = importlib.import_module(module_address)
+        state_loader_class = getattr(module_, class_name)
+        return state_loader_class(self.config, state_file_path)

opencombat/state.xsd

+<?xml version="1.0" encoding="UTF-8" ?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+
+    <xs:element name="state" type="statetype"/>
+
+    <xs:simpleType name="statetypetype" final="restriction">
+        <xs:restriction base="xs:string">
+            <xs:enumeration value="before_battle"/>
+            <xs:enumeration value="during_battle"/>
+        </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:simpleType name="modetype" final="restriction">
+        <xs:restriction base="xs:string">
+            <xs:enumeration value="standup"/>
+            <xs:enumeration value="defending"/>
+            <xs:enumeration value="hiding"/>
+        </xs:restriction>
+    </xs:simpleType>
+
+    <xs:simpleType name="positiontype">
+        <xs:restriction base="xs:string">
+            <xs:pattern value="[0-9]+,[0-9]+"/>
+        </xs:restriction>
+    </xs:simpleType>
+
+    <xs:simpleType name="directiontype">
+        <xs:restriction base="xs:positiveInteger"/>
+    </xs:simpleType>
+
+    <xs:complexType name="statetype">
+        <xs:sequence>
+            <xs:element name="map" type="maptype" maxOccurs="1"/>
+            <xs:element name="subjects" type="subjectstype"/>
+        </xs:sequence>
+        <xs:attribute name="type" type="statetypetype" use="required"/>
+    </xs:complexType>
+
+    <xs:complexType name="subjectstype">
+        <xs:sequence>
+            <xs:element name="subject" type="subjecttype" maxOccurs="unbounded"/>
+        </xs:sequence>
+    </xs:complexType>
+
+    <xs:complexType name="subjecttype">
+        <xs:sequence>
+            <xs:element name="type" type="xs:string"/>
+            <xs:element name="position" type="positiontype"/>
+            <xs:element name="direction" type="directiontype"/>
+            <xs:element name="mode" type="modetype"/>
+            <xs:element name="side" type="sidetype"/>
+        </xs:sequence>
+    </xs:complexType>
+
+    <xs:complexType name="maptype">
+        <xs:sequence>
+            <xs:element name="name" type="xs:string"/>
+        </xs:sequence>
+    </xs:complexType>
+
+</xs:schema>

requirements.txt

 Dijkstar==2.3.0
 freezegun==0.3.9
 future==0.16.0
+lxml==4.2.1
 numpy==1.13.3
 pluggy==0.6.0
 psutil==5.4.1

run.py

 from opencombat.simulation.subject import TankSubject
 from opencombat.simulation.base import TileStrategySimulation
 from opencombat.simulation.base import TileStrategySubjects
+from opencombat.state import StateLoaderBuilder
 from opencombat.terminal.base import CocosTerminal
 
 
-def main(map_dir_path: str, seed_value: int=None):
+def main(
+    map_dir_path: str,
+    seed_value: int=None,
+    state_file_path: str=None,
+):
     if seed_value is not None:
         seed(seed_value)
 
     simulation = TileStrategySimulation(config, map_file_path=map_file_path)
     subjects = TileStrategySubjects(simulation=simulation)
 
-    for position in ((10, 2), (11, 3), (11, 4), (12, 5),):
-        man = ManSubject(
-            config=config,
-            simulation=simulation,
-            position=position,
-            properties={
-                SELECTION_COLOR_RGB: DE_COLOR,
-                FLAG: FLAG_DE,
-                SIDE: 'AXIS',
-            }
-        )
-        subjects.append(man)
+    if state_file_path:
+        state_loader_builder = StateLoaderBuilder(config)
+        state_loader = state_loader_builder.get_state_loader(state_file_path)
+        subjects.extend(state_loader.get_subjects())
 
-    for position in ((30, 15), (31, 16), (32, 17), (33, 18),):
-        man = ManSubject(
-            config=config,
-            simulation=simulation,
-            position=position,
-            properties={
-                SELECTION_COLOR_RGB: URSS_COLOR,
-                FLAG: FLAG_URSS,
-                SIDE: 'ALLIES',
-            }
-        )
-        subjects.append(man)
-
-    for position in ((38, 24),):
-        man = TankSubject(
-            config=config,
-            simulation=simulation,
-            position=position,
-            properties={
-                SELECTION_COLOR_RGB: URSS_COLOR,
-                FLAG: FLAG_URSS,
-                SIDE: 'ALLIES',
-            }
-        )
-        subjects.append(man)
+    # for position in ((10, 2), (11, 3), (11, 4), (12, 5),):
+    #     man = ManSubject(
+    #         config=config,
+    #         simulation=simulation,
+    #         position=position,
+    #         properties={
+    #             SELECTION_COLOR_RGB: DE_COLOR,
+    #             FLAG: FLAG_DE,
+    #             SIDE: 'AXIS',
+    #         }
+    #     )
+    #     subjects.append(man)
+    #
+    # for position in ((30, 15), (31, 16), (32, 17), (33, 18),):
+    #     man = ManSubject(
+    #         config=config,
+    #         simulation=simulation,
+    #         position=position,
+    #         properties={
+    #             SELECTION_COLOR_RGB: URSS_COLOR,
+    #             FLAG: FLAG_URSS,
+    #             SIDE: 'ALLIES',
+    #         }
+    #     )
+    #     subjects.append(man)
+    #
+    # for position in ((38, 24),):
+    #     man = TankSubject(
+    #         config=config,
+    #         simulation=simulation,
+    #         position=position,
+    #         properties={
+    #             SELECTION_COLOR_RGB: URSS_COLOR,
+    #             FLAG: FLAG_URSS,
+    #             SIDE: 'ALLIES',
+    #         }
+    #     )
+    #     subjects.append(man)
 
     simulation.subjects = subjects