DEV

sandbox/tiledstrategy/gui/actor.py

+# coding: utf-8
+import typing
+
+import pyglet
+
+from sandbox.tiledstrategy.gui.animation import ANIMATION_WALK
+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',
+        ]
+    }
+
+    def __init__(self):
+        super().__init__(pyglet.resource.image('actors/man.png'))

sandbox/tiledstrategy/gui/animation.py

+# coding: utf-8
+
+
+ANIMATION_WALK = 'WALK'

sandbox/tiledstrategy/gui/base.py

 # coding: utf-8
+import random
+
+from sandbox.tiledstrategy.gui.animation import ANIMATION_WALK
+from synergine2_cocos2d.animation import Animate
 from synergine2_cocos2d.gui import TMXGui
 
 
 class Game(TMXGui):
     def before_run(self) -> None:
         # Test
+        from sandbox.tiledstrategy.gui.actor import Man
         from cocos import euclid
-        from synergine2_cocos2d.gui import Actor
 
-        man = Actor('man.png')
-        man.update_position(euclid.Vector2(100.0, 100.0))
-        self.layer_manager.add_subject(man)
-        self.layer_manager.set_selectable(man)
+        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
 
-        man2 = Actor('man.png')
-        man2.update_position(euclid.Vector2(200.0, 200.0))
-        self.layer_manager.add_subject(man2)
-        self.layer_manager.set_selectable(man2)
+            man.do(Animate(ANIMATION_WALK, 10, 4))

synergine2_cocos2d/actor.py

+# 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 = collision_model.AARectShape(
+            euclid.Vector2(0.0, 0.0),
+            self.width,
+            self.height,
+        )
+        self.build_animation_images()
+        self.current_image = image
+
+    def update_position(self, new_position: euclid.Vector2) -> None:
+        self.position = new_position
+        self.cshape.center = new_position
+
+    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

synergine2_cocos2d/animation.py

+# 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()
+
+
+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
+
+    def __reversed__(self):
+        return self.__class__(
+            self.animation_name,
+            self.duration,
+            self.cycle_duration,
+            self.direction * -1,
+        )
+
+    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)
+
+    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
+
+    def is_time_for_new_image(self) -> bool:
+        return self._elapsed - self.last_step_elapsed >= self.step_interval

synergine2_cocos2d/gui.py

 # coding: utf-8
 import weakref
 
-import cocos
 import pyglet
 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
 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.terminals import Terminal
 from synergine2_cocos2d.middleware import TMXMiddleware
 
 
-class Actor(cocos.sprite.Sprite):
-    def __init__(
-        self,
-        image,
-        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 = collision_model.AARectShape(
-            euclid.Vector2(0.0, 0.0),
-            self.width,
-            self.height,
-        )
-
-    def update_position(self, new_position: euclid.Vector2) -> None:
-        self.position = new_position
-        self.cshape.center = new_position
-
-
 class GridManager(object):
     def __init__(
         self,
 
     def __init__(
         self,
+        config: Config,
+        logger: SynergineLogger,
         layer_manager: LayerManager,
         worldview,
         bindings=None,
     ):
         super(EditLayer, self).__init__()
 
+        self.config = config
+        self.logger = logger
         self.layer_manager = layer_manager
+
         self.bindings = bindings
         buttons = {}
         modifiers = {}
         self.autoscrolling = False
 
     def on_mouse_press(self, x, y, buttons, modifiers):
-        pass
+        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 ?

synergine2_cocos2d/layer.py

 from synergine2_cocos2d.middleware import MapMiddleware
 
 if False:
-    from synergine2_cocos2d.gui import Actor
+    from synergine2_cocos2d.actor import Actor
 
 
 class LayerManager(object):
             }
         )
         self.edit_layer = EditLayer(
+            self.config,
+            self.logger,
             self,
             self.main_layer,
             **{