state: fill subject

opencombat/exception.py

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

opencombat/state.py

 # coding: utf-8
-import importlib
 import typing
-from _elementtree import Element
 
+from _elementtree import Element
 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
 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 get_text_xml_element
 
 
 class State(object):
     ) -> None:
         self._config = config
         self._state_root = state_root
-        self._subjects = None  # type: typing.List[Subject]
+        self._subjects = None  # type: typing.List[TileSubject]
         self._simulation = simulation
 
     @property
-    def subjects(self) -> typing.List[Subject]:
+    def subjects(self) -> typing.List[TileSubject]:
         if self._subjects is None:
             self._subjects = self._get_subjects()
 
         return self._subjects
 
-    def _get_subjects(self) -> typing.List[Subject]:
+    def _get_subjects(self) -> typing.List[TileSubject]:
         subjects = []
         subject_elements = self._state_root.find('subjects').findall('subject')
 
                 subject_class_path,
             )
             subject = subject_class(self._config, self._simulation)
+            self._fill_subject(subject, subject_element)
 
             # TODO BS 2018-06-13: Fill subject with property
             subjects.append(subject)
 
         return subjects
 
+    def _fill_subject(
+        self,
+        subject: TileSubject,
+        subject_element: Element,
+    ) -> None:
+        subject.position = tuple(
+            map(
+                int,
+                get_text_xml_element(subject_element, 'position').split(','),
+            ),
+        )
+        subject.direction = float(
+            get_text_xml_element(subject_element, 'direction'),
+        )
+
+        """
+        TODO:
+
+        properties={
+                 SELECTION_COLOR_RGB: DE_COLOR,
+                 FLAG: FLAG_DE,
+                 SIDE: 'AXIS',
+             }
+        """
+
 
 class StateLoader(object):
     def __init__(

opencombat/state.xsd

 
     <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:element name="type" type="xs:string" minOccurs="1" />
+            <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:sequence>
     </xs:complexType>
 

opencombat/util.py

 # coding: utf-8
 import importlib
 
+from _elementtree import Element
+
+from opencombat.exception import NotFoundError
+
+__DEFAULT__ = '__DEFAULT__'
+
 
 def get_class_from_string_path(config, string_path: str) -> type:
     """
     class_name = string_path.split('.')[-1]
     module_ = importlib.import_module(module_address)
     return getattr(module_, class_name)
+
+
+def get_text_xml_element(
+    element: Element,
+    search_element_name: str,
+    default_value: str = __DEFAULT__,
+) -> str:
+    found = element.find(search_element_name)
+    if found is None:
+        if default_value == __DEFAULT__:
+            raise NotFoundError(
+                'Asked element "{}" not exist in {}'.format(
+                    search_element_name,
+                    str(element),
+                ),
+            )
+        return default_value
+
+    return found.text

run.py

     subjects = TileStrategySubjects(simulation=simulation)
 
     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())
+        state_loader_builder = StateLoaderBuilder(config, simulation)
+        state_loader = state_loader_builder.get_state_loader()
+        state = state_loader.get_state(state_file_path)
+        subjects.extend(state.subjects)
 
     # for position in ((10, 2), (11, 3), (11, 4), (12, 5),):
     #     man = ManSubject(

tests/test_state.py

 from synergine2.config import Config
 
 from opencombat.exception import StateLoadError
+from opencombat.simulation.subject import ManSubject
 from opencombat.state import StateLoaderBuilder, StateLoader
 
 
     state_loader,
 ):
     state = state_loader.get_state('tests/fixtures/state_ok.xml')
+
     assert 2 == len(state.subjects)
+    assert isinstance(state.subjects[0], ManSubject)
+    assert isinstance(state.subjects[1], ManSubject)
+
+    assert (1, 1) == state.subjects[0].position
+    assert (10, 10) == state.subjects[1].position
+    assert 90.0 == state.subjects[0].direction
+    assert 270.0 == state.subjects[1].direction