DEV

sandbox/engulf/gui.py

 from cocos.sprite import Sprite
 from sandbox.engulf.behaviour import GrassGrownUp, GrassSpawn, MoveTo as MoveToEvent, EatEvent, AttackEvent, EatenEvent
 from sandbox.engulf.subject import Cell, Grass, PreyCell, PredatorCell
-from synergine2.terminals import TerminalPackage
+from synergine2.terminals import TerminalPackage, Terminal
 from synergine2_cocos2d.gui import Gui, GridLayerMixin
 from synergine2_cocos2d.gui import MainLayer as BaseMainLayer
 
 
 
 class MainLayer(GridLayerMixin, BaseMainLayer):
-    def __init__(self, game: 'Game', terminal, *args, **kwargs):
+    def __init__(self, game: 'Game', terminal: Terminal, *args, **kwargs):
         super().__init__(terminal, *args, **kwargs)
         self.game = game
+        self.terminal = terminal
 
         self.cells = CellsLayer(game=game, terminal=terminal)
         self.add(self.cells)

sandbox/tiledstrategy/gui/base.py

 # coding: utf-8
 import cocos
-import pyglet
+from synergine2_cocos2d.gui import TMXGui
 
-from synergine2_cocos2d.gui import Gui
-from synergine2_cocos2d.gui import MainLayer
-from synergine2_cocos2d.layer import LayerManager
-from synergine2_cocos2d.middleware import TMXMiddleware
 
-
-class Game(Gui):
-    def __init__(self, *args, map_dir_path: str, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.map_dir_path = map_dir_path
-        self.layer_manager = LayerManager(
-            self.config,
-            self.logger,
-            middleware=TMXMiddleware(
-                self.config,
-                self.logger,
-                self.map_dir_path,
-            ),
-        )
-        self.layer_manager.init()
-
-        pyglet.clock.schedule_interval(
-            lambda *_, **__: self.terminal.read(),
-            1 / 60.0,
-        )
-        cocos.director.director.run(self.layer_manager.main_scene)
+class Game(TMXGui):
+    def before_run(self) -> None:
+        # Test
+        man = cocos.sprite.Sprite('man.png')
+        self.layer_manager.subject_layer.add(man)
+        man.position = 0, 0
+        move = cocos.actions.MoveTo((80, 80), 2)
+        man.do(move)

sandbox/tiledstrategy/run.py

 from synergine2.terminals import TerminalManager
 
 
-def main(seed_value: int=42):
+def main(map_dir_path: str, seed_value: int=42):
     seed(seed_value)
 
     config = Config()
                 config,
                 logger,
                 asynchronous=False,
+                map_dir_path=map_dir_path,
             )]
         ),
         cycles_per_seconds=1 / config.core.cycle_duration,
 
 if __name__ == '__main__':
     parser = argparse.ArgumentParser(description='Run TiledStrategy')
+    parser.add_argument('map_dir_path', help='map directory path')
     parser.add_argument('--seed', dest='seed', default=42)
 
     args = parser.parse_args()
 
-    main(seed_value=args.seed)
+    main(args.map_dir_path, seed_value=args.seed)

synergine2_cocos2d/gui.py

 from synergine2.log import SynergineLogger
 from synergine2.terminals import Terminal
 from synergine2.terminals import TerminalPackage
+from synergine2_cocos2d.layer import LayerManager
+from synergine2_cocos2d.middleware import TMXMiddleware
 
 
 class GridManager(object):
 class MainLayer(ScrollableLayer):
     is_event_handler = True
 
-    def __init__(self, terminal: Terminal, scroll_step: int=100):
+    def __init__(self, scroll_step: int=100):
         super().__init__()
-
-        self.terminal = terminal
         self.scroll_step = scroll_step
         self.grid_manager = GridManager(self, 32, border=2)
 
             read_queue_interval: float= 1/60.0,
     ):
         self.config = config
-        self.logger = logger,
+        self.logger = logger
         self._read_queue_interval = read_queue_interval
         self.terminal = terminal
         self.cycle_duration = self.config.core.cycle_duration
         cocos.director.director.init()
 
     def run(self):
+        self.before_run()
         pyglet.clock.schedule_interval(
             lambda *_, **__: self.terminal.read(),
             self._read_queue_interval,
         )
         cocos.director.director.run(self.get_main_scene())
 
+    def before_run(self) -> None:
+        pass
+
     def get_main_scene(self) -> cocos.cocosnode.CocosNode:
         raise NotImplementedError()
 
 
     def after_received(self, package: TerminalPackage):
         pass
+
+
+class TMXGui(Gui):
+    def __init__(
+        self,
+        config: Config,
+        logger: SynergineLogger,
+        terminal: Terminal,
+        read_queue_interval: float = 1 / 60.0,
+        map_dir_path: str=None,
+    ):
+        assert map_dir_path
+        super(TMXGui, self).__init__(
+            config,
+            logger,
+            terminal,
+            read_queue_interval,
+        )
+        self.map_dir_path = map_dir_path
+        self.layer_manager = LayerManager(
+            self.config,
+            self.logger,
+            middleware=TMXMiddleware(
+                self.config,
+                self.logger,
+                self.map_dir_path,
+            ),
+        )
+        self.layer_manager.init()
+        self.layer_manager.center()
+
+    def get_main_scene(self) -> cocos.cocosnode.CocosNode:
+        return self.layer_manager.main_scene

synergine2_cocos2d/layer.py

 import cocos
 from synergine2.config import Config
 from synergine2.log import SynergineLogger
-from synergine2_cocos2d.gui import MainLayer
 from synergine2_cocos2d.middleware import MapMiddleware
 
 
 
         self.main_scene = None  # type: cocos.scene.Scene
         self.main_layer = None  # type: cocos.layer.Layer
-        self.background_layers = []  # type: typing.List[cocos.layer.Layer]
-        self.subject_layers = []  # type: typing.List[cocos.layer.Layer]
-        self.decoration_layers = []  # type: typing.List[cocos.layer.Layer]
 
-    @property
-    def background(self) -> cocos.layer.Layer:
-        return self.background_layers[0]
-
-    @property
-    def subject(self) -> cocos.layer.Layer:
-        return self.background_layers[0]
-
-    @property
-    def decoration(self) -> cocos.layer.Layer:
-        return self.background_layers[0]
+        self.background_sprite = None  # type: cocos.sprite.Sprite
+        self.ground_layer = None  # type: cocos.tiles.RectMapLayer
+        self.subject_layer = None  # type: cocos.layer.Layer
+        self.top_layer = None  # type: cocos.tiles.RectMapLayer
 
     def init(self) -> None:
-        self.main_layer = MainLayer()  # self.terminal) TODO: Ne plus donner le terminal
-
-        self.background_layers.extend(self.middleware.get_background_layers())
-        self.subject_layers.append(cocos.layer.Layer())
-        self.decoration_layers.extend(self.middleware.get_decoration_layers())
-
-        for layer in self.background_layers:
-            self.main_layer.add(layer)
-
-        for layer in self.subject_layers:
-            self.main_layer.add(layer)
-
-        for layer in self.decoration_layers:
-            self.main_layer.add(layer)
+        from synergine2_cocos2d.gui import MainLayer
+
+        self.middleware.init()
+        self.main_layer = MainLayer()
+        self.main_scene = cocos.scene.Scene(self.main_layer)
+
+        self.background_sprite = self.middleware.get_background_sprite()
+        self.ground_layer = self.middleware.get_ground_layer()
+        self.subject_layer = cocos.layer.Layer()  # TODO: RectMapLayer
+        self.top_layer = self.middleware.get_top_layer()
+
+        self.main_layer.add(self.background_sprite)
+        self.main_layer.add(self.ground_layer)
+        self.main_layer.add(self.subject_layer)
+        self.main_layer.add(self.top_layer)
+
+    def center(self):
+        self.background_sprite.set_position(
+            0 + (self.background_sprite.width / 2),
+            0 + (self.background_sprite.height / 2),
+        )
+        self.ground_layer.set_view(0, 0, self.ground_layer.px_width, self.ground_layer.px_height)
+        # self.subject_layer.set_view(0, 0, self.decoration_layers[0].px_width, self.decoration_layers[0].px_height)
+        self.top_layer.set_view(0, 0, self.top_layer.px_width, self.top_layer.px_height)
+
+        self.main_scene.position = - self.ground_layer.px_width / 2, - self.ground_layer.px_height / 2

synergine2_cocos2d/middleware.py

 # coding: utf-8
+import os
+
+import cocos
 from synergine2.config import Config
 from synergine2.log import SynergineLogger
 
         self.config = config
         self.logger = logger
         self.map_dir_path = map_dir_path
+        self.tmx = None
 
+    def init(self) -> None:
+        self.tmx = cocos.tiles.load(os.path.join(
+            self.map_dir_path,
+            '{}.tmx'.format(os.path.basename(self.map_dir_path)),
+        ))
 
-class TMXMiddleware(MapMiddleware):
-    pass  # TODO
-
-tmx = cocos.tiles.load('maps/003/003.tmx')
-
-background = cocos.sprite.Sprite('background.png')
-level0 = tmx['level0']
-level1 = tmx['level1']
-
-layer = MainLayer(self.terminal)
-layer.add(background, 0)
-layer.add(level0, 1)
-layer.add(level1, 2)
+    def get_background_sprite(self) -> cocos.sprite.Sprite:
+        raise NotImplementedError()
 
-main_scene = cocos.scene.Scene(layer)
+    def get_ground_layer(self) -> cocos.tiles.RectMapLayer:
+        raise NotImplementedError()
 
-background.set_position(0 + (background.width / 2), 0 + (background.height / 2))
-level0.set_view(0, 0, level0.px_width, level0.px_height)
-level1.set_view(0, 0, level1.px_width, level1.px_height)
+    def get_top_layer(self) -> cocos.tiles.RectMapLayer:
+        raise NotImplementedError()
 
-main_scene.position = 0, 0
 
-man = cocos.sprite.Sprite('man.png')
-level0.add(man)
-man.position = 0, 0
-move = cocos.actions.MoveTo((80, 80), 2)
-man.do(move)
+class TMXMiddleware(MapMiddleware):
+    def get_background_sprite(self) -> cocos.sprite.Sprite:
+        return cocos.sprite.Sprite(os.path.join(
+            self.map_dir_path,
+            'background.png',
+        ))
+
+    def get_ground_layer(self) -> cocos.tiles.RectMapLayer:
+        assert self.tmx
+        return self.tmx['ground']
+
+    def get_top_layer(self) -> cocos.tiles.RectMapLayer:
+        assert self.tmx
+        return self.tmx['top']