DEV

sandbox/tiledstrategy/gui/base.py

             if x % 2:
                 man.do(Animate(ANIMATION_WALK, 10, 4))
             else:
-                # TODO: Problème de zone selectable, elle reste a la taille de image debout.
                 man.do(Animate(ANIMATION_CRAWL, 20, 4))

synergine2_cocos2d/actor.py

 from cocos import collision_model
 from cocos import euclid
 from synergine2_cocos2d.animation import AnimatedInterface
+from synergine2_cocos2d.layer import LayerManager
 
 
 class Actor(AnimatedInterface, cocos.sprite.Sprite):
             anchor,
             **kwargs
         )
-        self.cshape = collision_model.AARectShape(
-            euclid.Vector2(0.0, 0.0),
-            self.width,
-            self.height,
-        )
+        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,
+        )
 
     def update_position(self, new_position: euclid.Vector2) -> None:
         self.position = new_position

synergine2_cocos2d/animation.py

         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.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())
         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/gui.py

 from synergine2.log import SynergineLogger
 from synergine2.terminals import Terminal
 from synergine2.terminals import TerminalPackage
+from synergine2_cocos2d.actor import Actor
 from synergine2_cocos2d.layer import LayerManager
 from synergine2_cocos2d.middleware import TMXMiddleware
 
         )
 
         self.schedule(self.update)
+        self.selectable_actors = []
+
+    def set_selectable(self, actor: Actor) -> None:
+        self.selectable_actors.append(actor)
+        self.collision_manager.add(actor)
+
+    def unset_selectable(self, actor: Actor) -> None:
+        self.selectable_actors.remove(actor)
+        self.collision_manager.remove_tricky(actor)
+
+    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)
+                    actor.need_update_cshape = False
 
     def on_enter(self):
         super(EditLayer, self).on_enter()

synergine2_cocos2d/layer.py

         self.subject_layer.remove(subject)
 
     def set_selectable(self, subject: 'Actor') -> None:
-        self.edit_layer.collision_manager.add(subject)
+        self.edit_layer.set_selectable(subject)
 
     def unset_selectable(self, subject: 'Actor') -> None:
-        self.edit_layer.collision_manager.remove_tricky(subject)
+        self.edit_layer.unset_selectable(subject)