dev

sandbox/tile/gui/base.py

 
 class Game(TMXGui):
     def before_run(self) -> None:
+        pass
         # Test
-        from sandbox.tile.gui.actor import Man
-        from cocos import euclid
-
-        for i in range(10):
-            x = random.randint(0, 600)
-            y = random.randint(0, 300)
-            man = Man()
-            man.update_position(euclid.Vector2(x, y))
-            self.layer_manager.add_subject(man)
-            self.layer_manager.set_selectable(man)
-            man.scale = 1
-
-            if x % 2:
-                man.do(Animate(ANIMATION_WALK, 10, 4))
-            else:
-                man.do(Animate(ANIMATION_CRAWL, 20, 4))
+        # from sandbox.tile.gui.actor import Man
+        # from cocos import euclid
+        #
+        # for i in range(10):
+        #     x = random.randint(0, 600)
+        #     y = random.randint(0, 300)
+        #     man = Man()
+        #     man.update_position(euclid.Vector2(x, y))
+        #     self.layer_manager.add_subject(man)
+        #     self.layer_manager.set_selectable(man)
+        #     man.scale = 1
+        #
+        #     if x % 2:
+        #         man.do(Animate(ANIMATION_WALK, 10, 4))
+        #     else:
+        #         man.do(Animate(ANIMATION_CRAWL, 20, 4))

sandbox/tile/run.py

 import logging
 from random import seed
 
+from sandbox.tile.simulation.subject import Man
+
 synergine2_path = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), '../../'))
 sys.path.append(synergine2_path)
 
-from sandbox.tile.simulation.base import TiledStrategySimulation, TiledStrategySubjects
+from sandbox.tile.simulation.base import TileStrategySimulation
+from sandbox.tile.simulation.base import TileStrategySubjects
 from synergine2.log import get_default_logger
 from synergine2.config import Config
 from sandbox.tile.terminal.base import CocosTerminal
     config.load_files(['sandbox/engulf/config.yaml'])
     logger = get_default_logger(level=logging.ERROR)
 
-    simulation = TiledStrategySimulation(config)
-    subjects = TiledStrategySubjects(simulation=simulation)
-    # TODO: Create subjects
+    simulation = TileStrategySimulation(config)
+    subjects = TileStrategySubjects(simulation=simulation)
+
+    man = Man(
+        config=config,
+        simulation=simulation,
+        position=(0, 0),
+    )
+    man.position = 0, 0
+    subjects.append(man)
+
     simulation.subjects = subjects
 
     core = Core(
     core.run()
 
 if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description='Run TiledStrategy')
+    parser = argparse.ArgumentParser(description='Run TileStrategy')
     parser.add_argument('map_dir_path', help='map directory path')
     parser.add_argument('--seed', dest='seed', default=42)
 

sandbox/tile/simulation/base.py

 # coding: utf-8
+from synergine2.simulation import Subject
 from synergine2.xyz import XYZSimulation
+from synergine2.xyz import XYZSubjectMixin
 from synergine2.xyz import XYZSubjects
 
 
-class TiledStrategySimulation(XYZSimulation):
+class TileStrategySimulation(XYZSimulation):
     behaviours_classes = [
 
     ]
 
 
-class TiledStrategySubjects(XYZSubjects):
+class TileStrategySubjects(XYZSubjects):
+    pass
+
+
+class BaseSubject(XYZSubjectMixin, Subject):
     pass

sandbox/tile/simulation/subject.py

+# coding: utf-8
+from sandbox.tile.simulation.base import BaseSubject
+
+
+class Man(BaseSubject):
+    pass

sandbox/tile/terminal/base.py

 # coding: utf-8
+from sandbox.tile.simulation.subject import Man as ManSubject
+from sandbox.tile.gui.actor import Man as ManActor
+from synergine2_cocos2d.terminal import GameTerminal
 
-from synergine2.terminals import Terminal
 
-
-class CocosTerminal(Terminal):
+class CocosTerminal(GameTerminal):
     subscribed_events = [
 
     ]
     def __init__(self, *args, asynchronous: bool, map_dir_path: str, **kwargs):
         super().__init__(*args, **kwargs)
         self.asynchronous = asynchronous
-        self.gui = None
         self.map_dir_path = map_dir_path
 
     def run(self):
         from sandbox.tile.gui.base import Game
+        from synergine2_cocos2d.gui import SubjectMapper
+
         self.gui = Game(
             self.config,
             self.logger,
             self,
             map_dir_path=self.map_dir_path,
         )
+
+        # TODO: Defind on some other place ?
+        self.gui.subject_mapper_factory.register_mapper(
+            ManSubject,
+            SubjectMapper(ManActor),
+        )
+
         self.gui.run()

synergine2_cocos2d/gui.py

 from cocos.sprite import Sprite
 from synergine2.config import Config
 from synergine2.log import SynergineLogger
+from synergine2.simulation import Subject
 from synergine2.terminals import Terminal
 from synergine2.terminals import TerminalPackage
+from synergine2.xyz import XYZSubjectMixin
 from synergine2_cocos2d.actor import Actor
 from synergine2_cocos2d.exception import OuterWorldPosition
 from synergine2_cocos2d.layer import LayerManager
         self.px_height = height
 
 
+class SubjectMapper(object):
+    def __init__(
+        self,
+        actor_class: typing.Type[Actor],
+    ) -> None:
+        self.actor_class = actor_class
+
+    def append(
+        self,
+        subject: XYZSubjectMixin,
+        layer_manager: LayerManager,
+    ) -> None:
+        actor = self.actor_class()
+        pixel_position = layer_manager.grid_manager.get_pixel_position_of_grid_position((
+            subject.position[0],
+            subject.position[1],
+        ))
+        actor.update_position(euclid.Vector2(*pixel_position))
+
+        # TODO: Selectable nature must be configurable
+        layer_manager.add_subject(actor)
+        layer_manager.set_selectable(actor)
+
+
+class SubjectMapperFactory(object):
+    def __init__(self) -> None:
+        self.mapping = {}  # type: typing.Dict[typing.Type[XYZSubjectMixin], SubjectMapper]
+
+    def register_mapper(self, subject_class: typing.Type[XYZSubjectMixin], mapper: SubjectMapper) -> None:
+        if subject_class not in self.mapping:
+            self.mapping[subject_class] = mapper
+        else:
+            raise ValueError('subject_class already register with "{}"'.format(str(self.mapping[subject_class])))
+
+    def get_subject_mapper(self, subject: XYZSubjectMixin) -> SubjectMapper:
+        for subject_class, mapper in self.mapping.items():
+            if isinstance(subject, subject_class):
+                return mapper
+        raise KeyError('No mapper for subject "{}"'.format(str(subject)))
+
+
 class Gui(object):
     def __init__(
             self,
         pyglet.gl.glEnable(pyglet.gl.GL_ALPHA_TEST)
         pyglet.gl.glAlphaFunc(pyglet.gl.GL_GREATER, .1)
 
+        self.subject_mapper_factory = SubjectMapperFactory()
+
     def run(self):
         self.before_run()
         pyglet.clock.schedule_interval(
         self.layer_manager.center()
 
     def get_main_scene(self) -> cocos.cocosnode.CocosNode:
-        return self.layer_manager.main_scene
+        return self.layer_manager.main_scene
+
+    def before_received(self, package: TerminalPackage):
+        super().before_received(package)
+        if package.subjects:  # They are new subjects in the simulation
+            for subject in package.subjects:
+                self.append_subject(subject)
+
+    def append_subject(self, subject: XYZSubjectMixin) -> None:
+        subject_mapper = self.subject_mapper_factory.get_subject_mapper(subject)
+        subject_mapper.append(subject, self.layer_manager)

synergine2_cocos2d/terminal.py

+# coding: utf-8
+from synergine2.terminals import Terminal, TerminalPackage
+
+
+class GameTerminal(Terminal):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.gui = None
+
+    def receive(self, package: TerminalPackage):
+        self.gui.before_received(package)
+        super().receive(package)
+        self.gui.after_received(package)
+
+    def run(self):
+        raise NotImplementedError()