Start new sandbox project based on tmx map

cocos

@@ -0,0 +1 @@
+../cocos/cocos

sandbox/engulf/gui.py

@@ -6,7 +6,7 @@ from cocos.actions import MoveTo, Repeat, ScaleBy, Reverse, RotateTo
 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
 
@@ -85,9 +85,10 @@ class GrassLayer(GridLayerMixin, 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/tile/__init__.py

@@ -0,0 +1 @@
+# coding: utf-8

sandbox/tile/gui/__init__.py

@@ -0,0 +1 @@
+# coding: utf-8

sandbox/tile/gui/actor.py

@@ -0,0 +1,33 @@
+# coding: utf-8
+import pyglet
+
+from sandbox.tile.gui.animation import ANIMATION_WALK
+from sandbox.tile.gui.animation import ANIMATION_CRAWL
+from synergine2_cocos2d.actor import Actor
+
+
+class Man(Actor):
+    animation_image_paths = {
+        ANIMATION_WALK: [
+            'actors/man.png',
+            'actors/man_w1.png',
+            'actors/man_w2.png',
+            'actors/man_w3.png',
+            'actors/man_w4.png',
+            'actors/man_w5.png',
+            'actors/man_w6.png',
+            'actors/man_w7.png',
+            'actors/man_w8.png',
+            'actors/man_w9.png',
+            'actors/man_w10.png',
+        ],
+        ANIMATION_CRAWL: [
+            'actors/man_c1.png',
+            'actors/man_c2.png',
+            'actors/man_c3.png',
+            'actors/man_c4.png',
+        ]
+    }
+
+    def __init__(self):
+        super().__init__(pyglet.resource.image('actors/man.png'))

sandbox/tile/gui/animation.py

@@ -0,0 +1,5 @@
+# coding: utf-8
+
+
+ANIMATION_WALK = 'WALK'
+ANIMATION_CRAWL = 'CRAWL'

sandbox/tile/gui/base.py

@@ -0,0 +1,29 @@
+# coding: utf-8
+import random
+
+from sandbox.tile.gui.animation import ANIMATION_WALK
+from sandbox.tile.gui.animation import ANIMATION_CRAWL
+from synergine2_cocos2d.animation import Animate
+from synergine2_cocos2d.gui import TMXGui
+
+
+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))

sandbox/tile/maps/003/trees_64x64.tsx

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<tileset name="trees_64x64" tilewidth="64" tileheight="64" tilecount="9" columns="3">
+ <image source="trees_64x64.png" width="192" height="192"/>
+</tileset>

sandbox/tile/run.py

@@ -0,0 +1,73 @@
+# coding: utf-8
+import argparse
+import os
+import sys
+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 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
+from synergine2.core import Core
+from synergine2.cycle import CycleManager
+from synergine2.terminals import TerminalManager
+
+
+def main(map_dir_path: str, seed_value: int=42):
+    seed(seed_value)
+
+    config = Config()
+    config.load_files(['sandbox/engulf/config.yaml'])
+    logger = get_default_logger(level=logging.ERROR)
+
+    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(
+        config=config,
+        logger=logger,
+        simulation=simulation,
+        cycle_manager=CycleManager(
+            config=config,
+            logger=logger,
+            simulation=simulation,
+        ),
+        terminal_manager=TerminalManager(
+            config=config,
+            logger=logger,
+            terminals=[CocosTerminal(
+                config,
+                logger,
+                asynchronous=False,
+                map_dir_path=map_dir_path,
+            )]
+        ),
+        cycles_per_seconds=1 / config.core.cycle_duration,
+    )
+    core.run()
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Run TileStrategy')
+    parser.add_argument('map_dir_path', help='map directory path')
+    parser.add_argument('--seed', dest='seed', default=42)
+
+    args = parser.parse_args()
+
+    main(args.map_dir_path, seed_value=args.seed)

sandbox/tile/simulation/__init__.py

@@ -0,0 +1 @@
+# coding: utf-8

sandbox/tile/simulation/base.py

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

sandbox/tile/simulation/subject.py

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

sandbox/tile/terminal/__init__.py

@@ -0,0 +1 @@
+# coding: utf-8

sandbox/tile/terminal/base.py

@@ -0,0 +1,34 @@
+# 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
+
+
+class CocosTerminal(GameTerminal):
+    subscribed_events = [
+
+    ]
+
+    def __init__(self, *args, asynchronous: bool, map_dir_path: str, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.asynchronous = asynchronous
+        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/core.py

@@ -18,7 +18,7 @@ class Core(BaseObject):
         simulation: Simulation,
         cycle_manager: CycleManager,
         terminal_manager: TerminalManager=None,
-        cycles_per_seconds: int=1,
+        cycles_per_seconds: float=1.0,
     ):
         self.config = config
         self.logger = logger

synergine2_cocos2d/actor.py

@@ -0,0 +1,73 @@
+# coding: utf-8
+import typing
+
+import pyglet
+
+import cocos
+from cocos import collision_model
+from cocos import euclid
+from synergine2_cocos2d.animation import AnimatedInterface
+
+
+class Actor(AnimatedInterface, cocos.sprite.Sprite):
+    animation_image_paths = {}  # type: typing.Dict[str, typing.List[str]]
+    animation_images = {}  # type: typing.Dict[str, typing.List[pyglet.image.TextureRegion]]
+
+    def __init__(
+        self,
+        image: pyglet.image.TextureRegion,
+        position=(0, 0),
+        rotation=0,
+        scale=1,
+        opacity=255,
+        color=(255, 255, 255),
+        anchor=None,
+        **kwargs
+    ):
+        super().__init__(
+            image,
+            position,
+            rotation,
+            scale,
+            opacity,
+            color,
+            anchor,
+            **kwargs
+        )
+        self.cshape = None  # type: collision_model.AARectShape
+        self.update_cshape()
+        self.build_animation_images()
+        self.current_image = image
+        self.need_update_cshape = False
+
+    def update_cshape(self) -> None:
+        self.cshape = collision_model.AARectShape(
+            euclid.Vector2(self.position[0], self.position[1]),
+            self.width // 2,
+            self.height // 2,
+        )
+        self.need_update_cshape = False
+
+    def update_position(self, new_position: euclid.Vector2) -> None:
+        self.position = new_position
+        self.cshape.center = new_position  # Note: if remove: strange behaviour: drag change actor position with anomaly
+
+    def build_animation_images(self) -> None:
+        """
+        Fill self.animation_images with self.animation_image_paths
+        :return: None
+        """
+        for animation_name, animation_image_paths in self.animation_image_paths.items():
+            self.animation_images[animation_name] = []
+            for animation_image_path in animation_image_paths:
+                self.animation_images[animation_name].append(pyglet.resource.image(animation_image_path))
+
+    def get_images_for_animation(self, animation_name: str) -> typing.List[pyglet.image.TextureRegion]:
+        return self.animation_images.get(animation_name)
+
+    def get_inanimate_image(self) -> pyglet.image.TextureRegion:
+        return self.current_image
+
+    def update_image(self, new_image: pyglet.image.TextureRegion):
+        self.image = new_image
+        self.image_anchor = new_image.width // 2, new_image.height // 2

synergine2_cocos2d/animation.py

@@ -0,0 +1,88 @@
+# coding: utf-8
+import typing
+
+import pyglet
+import cocos
+
+
+class AnimatedInterface(object):
+    def get_images_for_animation(self, animation_name: str) -> typing.List[pyglet.image.TextureRegion]:
+        raise NotImplementedError()
+
+    def get_inanimate_image(self) -> pyglet.image.TextureRegion:
+        """
+        Use this function to specify what image have to be used when animation is finished.
+        :return: non inanimate pyglet.image.TextureRegion
+        """
+        raise NotImplementedError()
+
+    def update_image(self, new_image: pyglet.image.TextureRegion):
+        raise NotImplementedError()
+
+
+# TODO: regarder pyglet.image.Animation
+class Animate(cocos.actions.IntervalAction):
+    def __init__(
+        self,
+        animation_name: str,
+        duration: float,
+        cycle_duration: float,
+        direction: int=1,
+    ):
+        super().__init__()
+        self.animation_name = animation_name
+        self.duration = duration
+        self.animation_images = []  # type: typing.List[pyglet.image.TextureRegion]
+        self.last_step_elapsed = 0.0  # type: float
+        self.step_interval = None  # type: float
+        self.cycle_duration = cycle_duration
+        self.current_step = 0  # typ: int
+        self.target = typing.cast(AnimatedInterface, self.target)
+        self.direction = direction
+        self.reshape = False
+
+    def __reversed__(self):
+        return self.__class__(
+            self.animation_name,
+            self.duration,
+            self.cycle_duration,
+            self.direction * -1,
+        )
+
+    def set_need_to_reshape(self) -> None:
+        # TODO: Maybe inanimate_image is not the more appropriate image to refer ?
+        inanimate_image = self.target.get_inanimate_image()
+        for position, animation_image in enumerate(self.animation_images):
+            if animation_image.width != inanimate_image.width or animation_image.height != inanimate_image.height:
+                self.reshape = True
+                return
+
+    def start(self):
+        super().start()
+        self.animation_images = self.target.get_images_for_animation(self.animation_name)
+        self.step_interval = self.cycle_duration / len(self.animation_images)
+        self.set_need_to_reshape()
+
+    def stop(self):
+        self.target.update_image(self.target.get_inanimate_image())
+        super().stop()
+
+    def update(self, t):
+        if not self.is_time_for_new_image():
+            return
+
+        self.current_step += self.direction
+        try:
+            new_image = self.animation_images[self.current_step]
+        except IndexError:
+            self.current_step = 0
+            new_image = self.animation_images[0]
+
+        self.target.update_image(new_image)
+        self.last_step_elapsed = self._elapsed
+
+        if self.reshape:
+            self.target.need_update_cshape = True
+
+    def is_time_for_new_image(self) -> bool:
+        return self._elapsed - self.last_step_elapsed >= self.step_interval

synergine2_cocos2d/exception.py

@@ -0,0 +1,13 @@
+# coding: utf-8
+
+
+class WorldException(Exception):
+    pass
+
+
+class PositionException(WorldException):
+    pass
+
+
+class OuterWorldPosition(PositionException):
+    pass

synergine2_cocos2d/gui.py

@@ -1,108 +1,647 @@
 # coding: utf-8
-import cocos
+import typing
+import weakref
+from math import floor
+
 import pyglet
-from pyglet.window import key as wkey
+from pyglet.window import mouse
+
+import cocos
+from cocos import collision_model
+from cocos import euclid
 from cocos.director import director
-from cocos.layer import ScrollableLayer, Layer
+from cocos.layer import Layer
+from cocos.layer import ScrollableLayer
 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
+from synergine2_cocos2d.middleware import TMXMiddleware
+
+
+# class GridManager(object):
+#     def __init__(
+#         self,
+#         layer: Layer,
+#         square_width: int,
+#         border: int=0,
+#     ):
+#         self.layer = layer
+#         self.square_width = square_width
+#         self.border = border
+#
+#     @property
+#     def final_width(self):
+#         return self.square_width + self.border
+#
+#     def scale_sprite(self, sprite: Sprite):
+#         sprite.scale_x = self.final_width / sprite.image.width
+#         sprite.scale_y = self.final_width / sprite.image.height
+#
+#     def position_sprite(self, sprite: Sprite, grid_position):
+#         grid_x = grid_position[0]
+#         grid_y = grid_position[1]
+#         sprite.position = grid_x * self.final_width, grid_y * self.final_width
+#
+#     def get_window_position(self, grid_position_x, grid_position_y):
+#         grid_x = grid_position_x
+#         grid_y = grid_position_y
+#         return grid_x * self.final_width, grid_y * self.final_width
+#
+#     def get_grid_position(self, window_x, window_y, z=0) -> tuple:
+#         window_size = director.get_window_size()
+#
+#         window_center_x = window_size[0] // 2
+#         window_center_y = window_size[1] // 2
+#
+#         window_relative_x = window_x - window_center_x
+#         window_relative_y = window_y - window_center_y
+#
+#         real_width = self.final_width * self.layer.scale
+#
+#         return int(window_relative_x // real_width),\
+#                int(window_relative_y // real_width),\
+#                z
+#
+#
+# class GridLayerMixin(object):
+#     def __init__(self, *args, **kwargs):
+#         square_width = kwargs.pop('square_width', 32)
+#         square_border = kwargs.pop('square_border', 2)
+#         self.grid_manager = GridManager(
+#             self,
+#             square_width=square_width,
+#             border=square_border,
+#         )
+#         super().__init__(*args, **kwargs)
 
 
 class GridManager(object):
     def __init__(
         self,
-        layer: Layer,
-        square_width: int,
-        border: int=0,
+        cell_width: int,
+        cell_height: int,
+        world_width: int,
+        world_height: int,
+    ) -> None:
+        self.cell_width = cell_width
+        self.cell_height = cell_height
+        self.world_width = world_width
+        self.world_height = world_height
+
+    def get_grid_position(self, pixel_position: typing.Tuple[int, int]) -> typing.Tuple[int, int]:
+        pixel_x, pixel_y = pixel_position
+
+        cell_x = int(floor(pixel_x / self.cell_width))
+        cell_y = int(floor(pixel_y / self.cell_height))
+
+        if cell_x > self.world_width or cell_y > self.world_height or cell_x < 0 or cell_y < 0:
+            raise OuterWorldPosition('Position "{}" is outer world ({}x{})'.format(
+                (cell_x, cell_y),
+                self.world_width,
+                self.world_height,
+            ))
+
+        return cell_x, cell_y
+
+    def get_pixel_position_of_grid_position(self, grid_position: typing.Tuple[int, int]) -> typing.Tuple[int, int]:
+        return grid_position[0] * self.cell_width + self.cell_width,\
+               grid_position[1] * self.cell_height + self.cell_height
+
+
+class MinMaxRect(cocos.cocosnode.CocosNode):
+    def __init__(self, layer_manager: LayerManager):
+        super(MinMaxRect, self).__init__()
+        self.layer_manager = layer_manager
+        self.color3 = (20, 20, 20)
+        self.vertexes = [(0.0, 0.0), (0.0, 0.0), (0.0, 0.0), (0.0, 0.0)]
+        self.visible = False
+
+    def adjust_from_w_minmax(self, wminx, wmaxx, wminy, wmaxy):
+        # asumes world to screen preserves order
+        sminx, sminy = self.layer_manager.scrolling_manager.world_to_screen(wminx, wminy)
+        smaxx, smaxy = self.layer_manager.scrolling_manager.world_to_screen(wmaxx, wmaxy)
+        self.vertexes = [(sminx, sminy), (sminx, smaxy), (smaxx, smaxy), (smaxx, sminy)]
+
+    def draw(self):
+        if not self.visible:
+            return
+        pyglet.gl.glLineWidth(1)  # deprecated
+        pyglet.gl.glColor3ub(*self.color3)
+        pyglet.gl.glBegin(pyglet.gl.GL_LINE_STRIP)
+        for v in self.vertexes:
+            pyglet.gl.glVertex2f(*v)
+        pyglet.gl.glVertex2f(*self.vertexes[0])
+        pyglet.gl.glEnd()
+
+        # rectangle
+        pyglet.gl.glColor4f(0, 0, 0, 0.5)
+        pyglet.gl.glBegin(pyglet.gl.GL_QUADS)
+        pyglet.gl.glVertex3f(self.vertexes[0][0], self.vertexes[0][1], 0)
+        pyglet.gl.glVertex3f(self.vertexes[1][0], self.vertexes[1][1], 0)
+        pyglet.gl.glVertex3f(self.vertexes[2][0], self.vertexes[2][1], 0)
+        pyglet.gl.glVertex3f(self.vertexes[3][0], self.vertexes[3][1], 0)
+        pyglet.gl.glEnd()
+
+    def set_vertexes_from_minmax(self, minx, maxx, miny, maxy):
+        self.vertexes = [(minx, miny), (minx, maxy), (maxx, maxy), (maxx, miny)]
+
+
+class EditLayer(cocos.layer.Layer):
+    is_event_handler = True
+
+    def __init__(
+        self,
+        config: Config,
+        logger: SynergineLogger,
+        layer_manager: LayerManager,
+        grid_manager: GridManager,
+        worldview,
+        bindings=None,
+        fastness=None,
+        autoscroll_border=10,
+        autoscroll_fastness=None,
+        wheel_multiplier=None,
+        zoom_min=None,
+        zoom_max=None,
+        zoom_fastness=None,
+        mod_modify_selection=None,
+        mod_restricted_mov=None,
     ):
-        self.layer = layer
-        self.square_width = square_width
-        self.border = border
+        # TODO: Clean init params
+        super(EditLayer, self).__init__()
+
+        self.config = config
+        self.logger = logger
+        self.layer_manager = layer_manager
+        self.grid_manager = grid_manager
 
-    @property
-    def final_width(self):
-        return self.square_width + self.border
+        self.bindings = bindings
+        buttons = {}
+        modifiers = {}
+        for k in bindings:
+            buttons[bindings[k]] = 0
+            modifiers[bindings[k]] = 0
+        self.buttons = buttons
+        self.modifiers = modifiers
 
-    def scale_sprite(self, sprite: Sprite):
-        sprite.scale_x = self.final_width / sprite.image.width
-        sprite.scale_y = self.final_width / sprite.image.height
+        self.fastness = fastness
+        self.autoscroll_border = autoscroll_border
+        self.autoscroll_fastness = autoscroll_fastness
+        self.wheel_multiplier = wheel_multiplier
+        self.zoom_min = zoom_min
+        self.zoom_max = zoom_max
+        self.zoom_fastness = zoom_fastness
+        self.mod_modify_selection = mod_modify_selection
+        self.mod_restricted_mov = mod_restricted_mov
 
-    def position_sprite(self, sprite: Sprite, grid_position):
-        grid_x = grid_position[0]
-        grid_y = grid_position[1]
-        sprite.position = grid_x * self.final_width, grid_y * self.final_width
+        self.weak_scroller = weakref.ref(self.layer_manager.scrolling_manager)
+        self.weak_worldview = weakref.ref(worldview)
+        self.wwidth = worldview.width
+        self.wheight = worldview.height
 
-    def get_window_position(self, grid_position_x, grid_position_y):
-        grid_x = grid_position_x
-        grid_y = grid_position_y
-        return grid_x * self.final_width, grid_y * self.final_width
+        self.autoscrolling = False
+        self.drag_selecting = False
+        self.drag_moving = False
+        self.restricted_mov = False
+        self.wheel = 0
+        self.dragging = False
+        self.keyscrolling = False
+        self.keyscrolling_descriptor = (0, 0)
+        self.wdrag_start_point = (0, 0)
+        self.elastic_box = None  # type: MinMaxRect
+        self.elastic_box_wminmax = 0, 0, 0, 0
+        self.selection = {}
+        self.screen_mouse = (0, 0)
+        self.world_mouse = (0, 0)
+        self.sleft = None
+        self.sright = None
+        self.sbottom = None
+        self.s_top = None
 
-    def get_grid_position(self, window_x, window_y, z=0) -> tuple:
-        window_size = director.get_window_size()
+        # opers that change cshape must ensure it goes to False,
+        # selection opers must ensure it goes to True
+        self.selection_in_collman = True
+        # TODO: Hardcoded here, should be obtained from level properties or calc
+        # from available actors or current actors in worldview
+        gsize = 32 * 1.25
+        self.collision_manager = collision_model.CollisionManagerGrid(
+            -gsize,
+            self.wwidth + gsize,
+            -gsize,
+            self.wheight + gsize,
+            gsize,
+            gsize,
+        )
 
-        window_center_x = window_size[0] // 2
-        window_center_y = window_size[1] // 2
+        self.schedule(self.update)
+        self.selectable_actors = []
 
-        window_relative_x = window_x - window_center_x
-        window_relative_y = window_y - window_center_y
+    def set_selectable(self, actor: Actor) -> None:
+        self.selectable_actors.append(actor)
+        self.collision_manager.add(actor)
 
-        real_width = self.final_width * self.layer.scale
+    def unset_selectable(self, actor: Actor) -> None:
+        self.selectable_actors.remove(actor)
+        self.collision_manager.remove_tricky(actor)
 
-        return int(window_relative_x // real_width),\
-               int(window_relative_y // real_width),\
-               z
+    def draw(self, *args, **kwargs) -> None:
+        for actor in self.selectable_actors:
+            if actor.need_update_cshape:
+                if self.collision_manager.knows(actor):
+                    self.collision_manager.remove_tricky(actor)
+                    actor.update_cshape()
+                    self.collision_manager.add(actor)
 
+    def on_enter(self):
+        super(EditLayer, self).on_enter()
+        scene = self.get_ancestor(cocos.scene.Scene)
+        if self.elastic_box is None:
+            self.elastic_box = MinMaxRect(self.layer_manager)
+            scene.add(self.elastic_box, z=10)
 
-class GridLayerMixin(object):
-    def __init__(self, *args, **kwargs):
-        square_width = kwargs.pop('square_width', 32)
-        square_border = kwargs.pop('square_border', 2)
-        self.grid_manager = GridManager(
-            self,
-            square_width=square_width,
-            border=square_border,
+    def update(self, dt):
+        mx = self.buttons['right'] - self.buttons['left']
+        my = self.buttons['up'] - self.buttons['down']
+        dz = self.buttons['zoomin'] - self.buttons['zoomout']
+
+        # scroll
+        if self.autoscrolling:
+            self.update_autoscroll(dt)
+        else:
+            # care for keyscrolling
+            new_keyscrolling = ((len(self.selection) == 0) and
+                                (mx != 0 or my != 0))
+            new_keyscrolling_descriptor = (mx, my)
+            if ((new_keyscrolling != self.keyscrolling) or
+                (new_keyscrolling_descriptor != self.keyscrolling_descriptor)):
+                self.keyscrolling = new_keyscrolling
+                self.keyscrolling_descriptor = new_keyscrolling_descriptor
+                fastness = 1.0
+                if mx != 0 and my != 0:
+                    fastness *= 0.707106  # 1/sqrt(2)
+                self.autoscrolling_sdelta = (0.5 * fastness * mx, 0.5 * fastness * my)
+            if self.keyscrolling:
+                self.update_autoscroll(dt)
+
+        # selection move
+        if self.drag_moving:
+            # update positions
+            wx, wy = self.world_mouse
+            dx = wx - self.wdrag_start_point[0]
+            dy = wy - self.wdrag_start_point[1]
+            if self.restricted_mov:
+                if abs(dy) > abs(dx):
+                    dx = 0
+                else:
+                    dy = 0
+            dpos = euclid.Vector2(dx, dy)
+            for actor in self.selection:
+                old_pos = self.selection[actor].center
+                new_pos = old_pos + dpos
+
+                try:
+                    grid_pos = self.grid_manager.get_grid_position(new_pos)
+                    grid_pixel_pos = self.grid_manager.get_pixel_position_of_grid_position(grid_pos)
+                    actor.update_position(grid_pixel_pos)
+                except OuterWorldPosition:
+                    # don't update position
+                    pass
+
+        scroller = self.weak_scroller()
+
+        # zoom
+        zoom_change = (dz != 0 or self.wheel != 0)
+        if zoom_change:
+            if self.mouse_into_world():
+                wzoom_center = self.world_mouse
+                szoom_center = self.screen_mouse
+            else:
+                # decay to scroller unadorned
+                wzoom_center = None
+            if self.wheel != 0:
+                dt_dz = 0.01666666 * self.wheel
+                self.wheel = 0
+            else:
+                dt_dz = dt * dz
+            zoom = scroller.scale + dt_dz * self.zoom_fastness
+            if zoom < self.zoom_min:
+                zoom = self.zoom_min
+            elif zoom > self.zoom_max:
+                zoom = self.zoom_max
+            scroller.scale = zoom
+            if wzoom_center is not None:
+                # postprocess toward 'world point under mouse the same before
+                # and after zoom' ; other restrictions may prevent fully comply
+                wx1, wy1 = self.layer_manager.scrolling_manager.screen_to_world(*szoom_center)
+                fx = scroller.restricted_fx + (wzoom_center[0] - wx1)
+                fy = scroller.restricted_fy + (wzoom_center[1] - wy1)
+                scroller.set_focus(fx, fy)
+
+    def update_mouse_position(self, sx, sy):
+        self.screen_mouse = sx, sy
+        self.world_mouse = self.layer_manager.scrolling_manager.screen_to_world(sx, sy)
+        # handle autoscroll
+        border = self.autoscroll_border
+        if border is not None:
+            # sleft and companions includes the border
+            scroller = self.weak_scroller()
+            self.update_view_bounds()
+            sdx = 0.0
+            if sx < self.sleft:
+                sdx = sx - self.sleft
+            elif sx > self.sright:
+                sdx = sx - self.sright
+            sdy = 0.0
+            if sy < self.sbottom:
+                sdy = sy - self.sbottom
+            elif sy > self.s_top:
+                sdy = sy - self.s_top
+            self.autoscrolling = sdx != 0.0 or sdy != 0.0
+            if self.autoscrolling:
+                self.autoscrolling_sdelta = (sdx / border, sdy / border)
+
+    def update_autoscroll(self, dt):
+        fraction_sdx, fraction_sdy = self.autoscrolling_sdelta
+        scroller = self.weak_scroller()
+        worldview = self.weak_worldview()
+        f = self.autoscroll_fastness
+        wdx = (fraction_sdx * f * dt) / scroller.scale / worldview.scale
+        wdy = (fraction_sdy * f * dt) / scroller.scale / worldview.scale
+        # ask scroller to try scroll (wdx, wdy)
+        fx = scroller.restricted_fx + wdx
+        fy = scroller.restricted_fy + wdy
+        scroller.set_focus(fx, fy)
+        self.world_mouse = self.layer_manager.scrolling_manager.screen_to_world(*self.screen_mouse)
+        self.adjust_elastic_box()
+        # self.update_view_bounds()
+
+    def update_view_bounds(self):
+        scroller = self.weak_scroller()
+        scx, scy = self.layer_manager.scrolling_manager.world_to_screen(
+            scroller.restricted_fx,
+            scroller.restricted_fy,
         )
-        super().__init__(*args, **kwargs)
+        hw = scroller.view_w / 2.0
+        hh = scroller.view_h / 2.0
+        border = self.autoscroll_border
+        self.sleft = scx - hw + border
+        self.sright = scx + hw - border
+        self.sbottom = scy - hh + border
+        self.s_top = scy + hh - border
+
+    def mouse_into_world(self):
+        worldview = self.weak_worldview()
+        # TODO: allow lower limits != 0 ?
+        return ((0 <= self.world_mouse[0] <= worldview.width) and
+               (0 <= self.world_mouse[1] <= worldview.height))
+
+    def on_key_press(self, k, m):
+        binds = self.bindings
+        if k in binds:
+            self.buttons[binds[k]] = 1
+            self.modifiers[binds[k]] = 1
+            return True
+        return False
+
+    def on_key_release(self, k, m):
+        binds = self.bindings
+        if k in binds:
+            self.buttons[binds[k]] = 0
+            self.modifiers[binds[k]] = 0
+            return True
+        return False
+
+    def on_mouse_motion(self, sx, sy, dx, dy):
+        self.update_mouse_position(sx, sy)
+
+    def on_mouse_leave(self, sx, sy):
+        self.autoscrolling = False
+
+    def on_mouse_press(self, x, y, buttons, modifiers):
+        if self.logger.is_debug:
+            rx, ry = self.layer_manager.scrolling_manager.screen_to_world(x, y)
+            self.logger.debug('GUI click: x: {}, y: {}, rx: {}, ry: {}'.format(x, y, rx, ry))
+
+    def on_mouse_release(self, sx, sy, button, modifiers):
+        # should we handle here mod_restricted_mov ?
+        wx, wy = self.layer_manager.scrolling_manager.screen_to_world(sx, sy)
+        modify_selection = modifiers & self.mod_modify_selection
+        if self.dragging:
+            # ignore all buttons except left button
+            if button != mouse.LEFT:
+                return
+            if self.drag_selecting:
+                self.end_drag_selection(wx, wy, modify_selection)
+            elif self.drag_moving:
+                self.end_drag_move(wx, wy)
+            self.dragging = False
+        else:
+            if button == mouse.LEFT:
+                self.end_click_selection(wx, wy, modify_selection)
+
+    def end_click_selection(self, wx, wy, modify_selection):
+        under_mouse_unique = self.single_actor_from_mouse()
+        if modify_selection:
+            # toggle selected status for unique
+            if under_mouse_unique in self.selection:
+                self.selection_remove(under_mouse_unique)
+            elif under_mouse_unique is not None:
+                self.selection_add(under_mouse_unique)
+        else:
+            # new_selected becomes the current selected
+            self.selection.clear()
+            if under_mouse_unique is not None:
+                self.selection_add(under_mouse_unique)
+
+    def selection_add(self, actor):
+        self.selection[actor] = actor.cshape.copy()
+
+    def selection_remove(self, actor):
+        del self.selection[actor]
+
+    def end_drag_selection(self, wx, wy, modify_selection):
+        new_selection = self.collision_manager.objs_into_box(*self.elastic_box_wminmax)
+        if not modify_selection:
+            # new_selected becomes the current selected
+            self.selection.clear()
+        for actor in new_selection:
+            self.selection_add(actor)
+
+        self.elastic_box.visible = False
+        self.drag_selecting = False
+
+    def on_mouse_drag(self, sx, sy, dx, dy, buttons, modifiers):
+        # TODO: inhibir esta llamada si estamos fuera de la client area / viewport
+        self.update_mouse_position(sx, sy)
+        if not buttons & mouse.LEFT:
+            # ignore except for left-btn-drag
+            return
+
+        if not self.dragging:
+            print("begin drag")
+            self.begin_drag()
+            return
+
+        if self.drag_selecting:
+            # update elastic box
+            self.adjust_elastic_box()
+        elif self.drag_moving:
+            self.restricted_mov = (modifiers & self.mod_restricted_mov)
+
+    def adjust_elastic_box(self):
+        # when elastic_box visible this method needs to be called any time
+        # world_mouse changes or screen_to_world results changes (scroll, etc)
+        wx0, wy0 = self.wdrag_start_point
+        wx1, wy1 = self.world_mouse
+        wminx = min(wx0, wx1)
+        wmaxx = max(wx0, wx1)
+        wminy = min(wy0, wy1)
+        wmaxy = max(wy0, wy1)
+        self.elastic_box_wminmax = wminx, wmaxx, wminy, wmaxy
+        self.elastic_box.adjust_from_w_minmax(*self.elastic_box_wminmax)
+
+    def begin_drag(self):
+        self.dragging = True
+        self.wdrag_start_point = self.world_mouse
+        under_mouse_unique = self.single_actor_from_mouse()
+        if under_mouse_unique is None:
+            # begin drag selection
+            self.drag_selecting = True
+            self.adjust_elastic_box()
+            self.elastic_box.visible = True
+            print("begin drag selection: drag_selecting, drag_moving",
+                  self.drag_selecting, self.drag_moving)
+
+        else:
+            # want drag move
+            if under_mouse_unique in self.selection:
+                # want to move current selection
+                pass
+            else:
+                # change selection before moving
+                self.selection.clear()
+                self.selection_add(under_mouse_unique)
+            self.begin_drag_move()
+
+    def begin_drag_move(self):
+        # begin drag move
+        self.drag_moving = True
+
+        # how-to update collman: remove/add vs clear/add all
+        # when total number of actors is low anyone will be fine,
+        # with high numbers, most probably we move only a small fraction
+        # For simplicity I choose remove/add, albeit a hybrid aproach
+        # can be implemented later
+        self.set_selection_in_collman(False)
+#        print "begin drag: drag_selecting, drag_moving", self.drag_selecting, self.drag_moving
+
+    def end_drag_move(self, wx, wy):
+        self.set_selection_in_collman(True)
+        for actor in self.selection:
+            self.selection[actor] = actor.cshape.copy()
+
+        self.drag_moving = False
+
+    def single_actor_from_mouse(self):
+        under_mouse = self.collision_manager.objs_touching_point(*self.world_mouse)
+        if len(under_mouse) == 0:
+            return None
+        # return the one with the center most near to mouse, if tie then
+        # an arbitrary in the tie
+        nearest = None
+        near_d = None
+        p = euclid.Vector2(*self.world_mouse)
+        for actor in under_mouse:
+            d = (actor.cshape.center - p).magnitude_squared()
+            if nearest is None or (d < near_d):
+                nearest = actor
+                near_d = d
+        return nearest
+
+    def set_selection_in_collman(self, bool_value):
+        if self.selection_in_collman == bool_value:
+            return
+        self.selection_in_collman = bool_value
+        if bool_value:
+            for actor in self.selection:
+                self.collision_manager.add(actor)
+        else:
+            for actor in self.selection:
+                self.collision_manager.remove_tricky(actor)
+
+    def on_mouse_scroll(self, x, y, scroll_x, scroll_y):
+        # TODO: check if mouse over scroller viewport?
+        self.wheel += scroll_y * self.wheel_multiplier
 
 
 class MainLayer(ScrollableLayer):
     is_event_handler = True
 
-    def __init__(self, terminal: Terminal, scroll_step: int=100):
+    def __init__(
+        self,
+        layer_manager: LayerManager,
+        grid_manager: GridManager,
+        width: int,
+        height: int,
+        scroll_step: int=100,
+    ) -> None:
         super().__init__()
-
-        self.terminal = terminal
+        self.layer_manager = layer_manager
         self.scroll_step = scroll_step
-        self.grid_manager = GridManager(self, 32, border=2)
+        self.grid_manager = grid_manager
+
+        self.width = width
+        self.height = height
+        self.px_width = width
+        self.px_height = height
+
 
-        # Set scene center on center of screen
-        window_size = director.get_window_size()
-        self.position = window_size[0] // 2, window_size[1] // 2
+class SubjectMapper(object):
+    def __init__(
+        self,
+        actor_class: typing.Type[Actor],
+    ) -> None:
+        self.actor_class = actor_class
 
-    def on_key_press(self, key, modifiers):
-        if key == wkey.LEFT:
-            self.position = (self.position[0] + self.scroll_step, self.position[1])
+    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))
 
-        if key == wkey.RIGHT:
-            self.position = (self.position[0] - self.scroll_step, self.position[1])
+        # TODO: Selectable nature must be configurable
+        layer_manager.add_subject(actor)
+        layer_manager.set_selectable(actor)
 
-        if key == wkey.UP:
-            self.position = (self.position[0], self.position[1] - self.scroll_step)
 
-        if key == wkey.DOWN:
-            self.position = (self.position[0], self.position[1] + self.scroll_step)
+class SubjectMapperFactory(object):
+    def __init__(self) -> None:
+        self.mapping = {}  # type: typing.Dict[typing.Type[XYZSubjectMixin], SubjectMapper]
 
-        if key == wkey.A:
-            if self.scale >= 0.3:
-                self.scale -= 0.2
+    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])))
 
-        if key == wkey.Z:
-            if self.scale <= 4:
-                self.scale += 0.2
+    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):
@@ -114,19 +653,39 @@ class Gui(object):
             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()
+
+        cocos.director.director.init(
+            width=640,
+            height=480,
+            vsync=True,
+            resizable=True,
+        )
+
+        # Enable blending
+        pyglet.gl.glEnable(pyglet.gl.GL_BLEND)
+        pyglet.gl.glBlendFunc(pyglet.gl.GL_SRC_ALPHA, pyglet.gl.GL_ONE_MINUS_SRC_ALPHA)
+
+        # Enable transparency
+        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(
             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()
 
@@ -135,3 +694,46 @@ class Gui(object):
 
     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
+
+    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/layer.py

@@ -0,0 +1,120 @@
+# coding: utf-8
+from pyglet.window import key
+
+import cocos
+
+from synergine2.config import Config
+from synergine2.log import SynergineLogger
+from synergine2_cocos2d.middleware import MapMiddleware
+
+if False:
+    from synergine2_cocos2d.actor import Actor
+    from synergine2_cocos2d.gui import GridManager
+
+
+class LayerManager(object):
+    def __init__(
+        self,
+        config: Config,
+        logger: SynergineLogger,
+        middleware: MapMiddleware,
+    ) -> None:
+        self.config = config
+        self.logger = logger
+        self.middleware = middleware
+
+        self.grid_manager = None  # type: GridManager
+        self.scrolling_manager = None  # type: cocos.layer.ScrollingManager
+        self.main_scene = None  # type: cocos.scene.Scene
+        self.main_layer = None  # type: cocos.layer.Layer
+        self.edit_layer = None  # TODO type
+
+        self.background_sprite = None  # type: cocos.sprite.Sprite
+        self.ground_layer = None  # type: cocos.tiles.RectMapLayer
+        self.subject_layer = None  # type: cocos.layer.ScrollableLayer
+        self.top_layer = None  # type: cocos.tiles.RectMapLayer
+
+    def init(self) -> None:
+        # TODO: cyclic import
+        from synergine2_cocos2d.gui import MainLayer
+        from synergine2_cocos2d.gui import EditLayer
+        from synergine2_cocos2d.gui import GridManager
+
+        self.middleware.init()
+
+        self.grid_manager = GridManager(
+            self.middleware.get_cell_width(),
+            self.middleware.get_cell_height(),
+            self.middleware.get_world_width(),
+            self.middleware.get_world_height(),
+        )
+
+        self.main_scene = cocos.scene.Scene()
+        self.scrolling_manager = cocos.layer.ScrollingManager()
+
+        self.main_layer = MainLayer(
+            self,
+            self.grid_manager,
+            **{
+                'width': 1200,  # Note: world size
+                'height': 1000,  # Note: world size
+            }
+        )
+        self.edit_layer = EditLayer(
+            self.config,
+            self.logger,
+            self,
+            self.grid_manager,
+            self.main_layer,
+            **{
+                'bindings': {
+                    key.LEFT: 'left',
+                    key.RIGHT: 'right',
+                    key.UP: 'up',
+                    key.DOWN: 'down',
+                    key.NUM_ADD: 'zoomin',
+                    key.NUM_SUBTRACT: 'zoomout'
+                },
+                'mod_modify_selection': key.MOD_SHIFT,
+                'mod_restricted_mov': key.MOD_ACCEL,
+                'fastness': 160.0,
+                'autoscroll_border': 20.0,  # in pixels, float; None disables autoscroll
+                'autoscroll_fastness': 320.0,
+                'wheel_multiplier': 2.5,
+                'zoom_min': 0.1,
+                'zoom_max': 2.0,
+                'zoom_fastness': 1.0
+            }
+        )
+
+        self.main_scene.add(self.scrolling_manager)
+        self.scrolling_manager.add(self.main_layer, z=0)
+        self.main_scene.add(self.edit_layer)
+
+        self.background_sprite = self.middleware.get_background_sprite()
+        self.ground_layer = self.middleware.get_ground_layer()
+        self.subject_layer = cocos.layer.ScrollableLayer()
+        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.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.position = 0, 0
+        self.top_layer.set_view(0, 0, self.top_layer.px_width, self.top_layer.px_height)
+
+    def add_subject(self, subject: 'Actor') -> None:
+        self.subject_layer.add(subject)
+
+    def remove_subject(self, subject: 'Actor') -> None:
+        self.subject_layer.remove(subject)
+
+    def set_selectable(self, subject: 'Actor') -> None:
+        self.edit_layer.set_selectable(subject)
+
+    def unset_selectable(self, subject: 'Actor') -> None:
+        self.edit_layer.unset_selectable(subject)

synergine2_cocos2d/middleware.py

@@ -0,0 +1,74 @@
+# coding: utf-8
+import os
+
+import cocos
+from synergine2.config import Config
+from synergine2.log import SynergineLogger
+
+
+class MapMiddleware(object):
+    def __init__(
+        self,
+        config: Config,
+        logger: SynergineLogger,
+        map_dir_path: str,
+    ) -> None:
+        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)),
+        ))
+
+    def get_background_sprite(self) -> cocos.sprite.Sprite:
+        raise NotImplementedError()
+
+    def get_ground_layer(self) -> cocos.tiles.RectMapLayer:
+        raise NotImplementedError()
+
+    def get_top_layer(self) -> cocos.tiles.RectMapLayer:
+        raise NotImplementedError()
+
+    def get_world_height(self) -> int:
+        raise NotImplementedError()
+
+    def get_world_width(self) -> int:
+        raise NotImplementedError()
+
+    def get_cell_height(self) -> int:
+        raise NotImplementedError()
+
+    def get_cell_width(self) -> int:
+        raise NotImplementedError()
+
+
+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']
+
+    def get_world_height(self) -> int:
+        return len(self.tmx['ground'].cells[0])
+
+    def get_world_width(self) -> int:
+        return len(self.tmx['ground'].cells)
+
+    def get_cell_height(self) -> int:
+        return self.tmx['ground'].cells[0][0].size[1]
+
+    def get_cell_width(self) -> int:
+        return self.tmx['ground'].cells[0][0].size[0]

synergine2_cocos2d/terminal.py

@@ -0,0 +1,16 @@
+# 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()