DEV

opencombat/exception.py

 
 class UnknownWeapon(OpenCombatException):
     pass
+
+
+class UnknownAnimationIndex(OpenCombatException):
+    pass

opencombat/gui/actor.py

 # coding: utf-8
 import typing
 
+import time
+
+import pyglet
 from PIL import Image
 from synergine2.config import Config
 from synergine2.simulation import Subject
 from synergine2_cocos2d.actor import Actor
 
-from opencombat.exception import UnknownWeapon
+from opencombat.exception import UnknownWeapon, UnknownAnimationIndex
 from opencombat.gui.animation import ANIMATION_CRAWL
 from opencombat.gui.animation import ANIMATION_WALK
 from opencombat.gui.const import POSITION_MAN_STAND_UP
 from opencombat.gui.const import POSITION_MAN_CRAWLING
+from opencombat.gui.image import TileImageCache
 from opencombat.gui.weapon import RIFFLE
 from opencombat.gui.weapon import WeaponImageApplier
 
+if typing.TYPE_CHECKING:
+    from opencombat.gui.fire import GuiFiringEvent
+
 
 class BaseActor(Actor):
     position_matching = {
         self.weapon_image_applier = WeaponImageApplier(config, self)
         super().__init__(image_path, subject=subject, config=config)
 
+        # Firing
+        self.last_firing_time = 0
+        self.firing_change_image_gap = 0.05  # seconds
+        self.firing_images_cache = {}  # type: TODO
+
+        self.default_image_path = image_path
+
+        self.image_cache = TileImageCache(self, self.config)
+        self.image_cache.build()
+        pass
+
     @property
     def mode(self) -> str:
         return self._mode
             return []
 
         return [
-            self.weapon_image_applier.get_default_image_for_weapon(
+            self.weapon_image_applier.get_image_for_weapon(
                 self.mode,
-                self.weapons[0],
+                self.weapons[0],  # FIXME
             )
         ]
 
         except UnknownWeapon:
             return []
 
-    def firing(self) -> None:
-        pass
+    def get_modes(self) -> typing.List[str]:
+        return [POSITION_MAN_STAND_UP]
+
+    # def build_firing_images(self) -> None:
+    #     cache_dir = self.config.resolve('global.cache_dir_path')
+    #     for mode in self.get_modes():
+    #         for weapon in self.weapons:
+    #             images = self.weapon_image_applier.get_firing_image(
+    #                 mode=mode,
+    #                 weapon_type=weapon,
+    #             )
+    #
+    #             for position in range(len(images)):
+    #                 pass
+    #
+    #
+    #     for animation_name, animation_image_paths in self.animation_image_paths.items():
+    #         self.animation_images[animation_name] = []
+    #         for i, animation_image_path in enumerate(animation_image_paths):
+    #             final_image_path = self.path_manager.path(animation_image_path)
+    #             final_image = Image.open(final_image_path)
+    #
+    #             for appliable_image in self.get_animation_appliable_images(
+    #                 animation_name,
+    #                 i,
+    #             ):
+    #                 final_image.paste(
+    #                     appliable_image,
+    #                     (0, 0),
+    #                     appliable_image,
+    #                 )
+    #
+    #             # FIXME NOW: nom des image utilise au dessus
+    #             final_name = '_'.join([
+    #                 str(subject_id),
+    #                 ntpath.basename(final_image_path),
+    #             ])
+    #             final_path = os.path.join(cache_dir, final_name)
+    #
+    #             final_image.save(final_path)
+    #
+    #             self.animation_images[animation_name].append(
+    #                 pyglet.image.load(
+    #                     final_path,
+    #                 )
+    #             )
+
+    def firing(self, firing: 'GuiFiringEvent') -> None:
+        # FIXME: move some code ?
+        now = time.time()
+        if now - self.last_firing_time >= self.firing_change_image_gap:
+            self.last_firing_time = now
+            firing.increment_animation_index()
+
+            try:
+                image = self.image_cache.firing_cache.get(
+                    mode=self.mode,
+                    weapon=firing.weapon,
+                    position=firing.animation_index,
+                )
+            except UnknownAnimationIndex:
+                image = self.image_cache.firing_cache.get(
+                    mode=self.mode,
+                    weapon=firing.weapon,
+                    position=0,
+                )
+                firing.reset_animation_index()
+
+            # FIXME cache: prepare before firing
+            import uuid
+            tmp_path = '/tmp/{}.png'.format(str(uuid.uuid4()))
+            image.save(tmp_path)
+            pyglet_image = pyglet.image.load(tmp_path)
+
+            self.update_image(pyglet_image.get_texture())
 
 
 class Man(BaseActor):
         return [RIFFLE]
 
 
-class HeavyVehicle(Actor):
+class HeavyVehicle(BaseActor):
     animation_image_paths = {
         ANIMATION_WALK: [
             'actors/tank1.png',
         subject: Subject,
     ) -> None:
         super().__init__('actors/tank1.png', subject=subject, config=config)
+
+    @property
+    def weapons(self) -> typing.List[str]:
+        # TODO BS 2018-01-26: Will be managed by complex part of code
+        return [RIFFLE]

opencombat/gui/base.py

 from synergine2_cocos2d.middleware import MapMiddleware
 from synergine2_cocos2d.util import PathManager
 
+from opencombat.gui.fire import GuiFiringEvent
 from opencombat.simulation.interior import InteriorManager
 from opencombat.simulation.tmx import TileMap
 from opencombat.user_action import UserAction
         def gunshot_sound():
             self.sound_lib.get_sound('gunshot_default').play()
 
+        firing_event = GuiFiringEvent(shooter_actor, event.weapon_type)
+        original_actor_image = shooter_actor.image
+
         def actor_firing():
-            shooter_actor.firing(event.weapon_type)
+            shooter_actor.firing(firing_event)
+
+        def actor_end_firing():
+            shooter_actor.update_image(original_actor_image)
 
         # To avoid all in same time
         # TODO BS 2018-01-24: This should be unecessary when core events sending will be
             actor_firing,
             duration=0.2,  # TODO BS 2018-01-25: Wil depend of weapon type
             delay=delay,
+            end_callback=actor_end_firing,
         )
 
     def subject_die(self, event: DieEvent) -> None:

opencombat/gui/fire.py

 # coding: utf-8
 import typing
 
+from opencombat.gui.actor import BaseActor
+from opencombat.simulation.event import DEFAULT_WEAPON_TYPE
 from opencombat.simulation.fire import RequestFireBehaviour
 from synergine2_cocos2d.interaction import BaseActorInteraction
 from opencombat.user_action import UserAction
 class FireActorInteraction(BaseFireActorInteraction):
     gui_action = UserAction.ORDER_FIRE
     color = (255, 0, 0)
+
+
+class GuiFiringEvent(object):
+    def __init__(
+        self,
+        actor: BaseActor,
+        weapon: str,
+    ) -> None:
+        self.actor = actor
+        self.weapon = weapon
+        self._animation_index = -1
+
+        if weapon == DEFAULT_WEAPON_TYPE:
+            self.weapon = self.actor.weapons[0]
+
+    @property
+    def animation_index(self) -> int:
+        return self._animation_index
+
+    def increment_animation_index(self) -> None:
+        self._animation_index += 1
+
+    def reset_animation_index(self) -> None:
+        self._animation_index = -1

opencombat/gui/image.py

+# coding: utf-8
+import io
+import typing
+
+from PIL import Image
+from synergine2.config import Config
+from synergine2_cocos2d.actor import Actor
+from synergine2_cocos2d.util import PathManager
+
+from opencombat.exception import UnknownAnimationIndex
+
+
+class ImageCache(object):
+    def __init__(self) -> None:
+        self.cache = {}
+
+
+class FiringCache(ImageCache):
+    def add(
+        self,
+        mode: str,
+        weapon: str,
+        image: Image.Image,
+    ) -> None:
+        self.cache.setdefault(mode, {}).setdefault(weapon, []).append(image)
+
+    def get(
+        self,
+        mode: str,
+        weapon: str,
+        position: int,
+    ) -> Image.Image:
+        try:
+            return self.cache[mode][weapon][position]
+        except KeyError:
+            raise Exception('TODO')
+        except IndexError:
+            raise UnknownAnimationIndex(
+                'Unknown animation index "{}" for mode "{}" and weapon "{}"'.format(
+                    position,
+                    mode,
+                    weapon,
+                ),
+            )
+
+
+class ImageCache(object):
+    # FIXME: Move into synergine
+    def __init__(
+        self,
+        actor: Actor,
+        config: Config,
+    ) -> None:
+        self.config = config
+        self.actor = actor
+
+    def build(self) -> None:
+        pass
+
+
+class TileImageCache(ImageCache):
+    def __init__(
+        self,
+        actor: Actor,
+        config: Config,
+    ) -> None:
+        super().__init__(actor, config)
+        self.firing_cache = FiringCache()
+        from opencombat.gui.actor import BaseActor
+        self.actor = typing.cast(BaseActor, self.actor)
+        self.path_manager = PathManager(
+            self.config.resolve('global.include_path.graphics'),
+        )
+
+    def build(self) -> None:
+        super().build()
+        self.build_firing()
+
+    def build_firing(self) -> None:
+        for mode in self.actor.get_modes():
+            mode_image_path = self.actor.default_image_path  # FIXME !
+            mode_image = Image.open(self.path_manager.path(mode_image_path))
+
+            for weapon in self.actor.weapons:
+                images = self.actor.weapon_image_applier.get_firing_image(
+                    mode=mode,
+                    weapon_type=weapon,
+                )
+
+                for position in range(len(images)):
+                    position_image = images[position]
+
+                    final_image = mode_image.copy()
+                    final_image.paste(
+                        position_image,
+                        (0, 0),
+                        position_image,
+                    )
+
+                    self.firing_cache.add(mode, weapon, final_image)

opencombat/gui/weapon.py

 # coding: utf-8
 import typing
 
+import pyglet
 from PIL import Image
+from pyglet.image import ImageData
 from synergine2.config import Config
 from synergine2_cocos2d.util import PathManager
 
         actor: 'BaseActor',
     ) -> None:
         self.actor = actor
-        self._images_scheme = self.get_images_scheme()
+        self._images_scheme = self.get_rest_images_scheme()
+        self._firing_images_scheme = self.get_firing_images_scheme()
         self.path_manager = PathManager(config.resolve('global.include_path.graphics'))
         self._cache = {}  # type: typing.Dict[str, Image.Image]
+        self._firing_cache = {}  # type: typing.Dict[str, Image.Image]
 
-    def get_images_scheme(self) -> typing.Dict[str, typing.Dict[str, typing.List[str]]]:
+    def get_rest_images_scheme(self) -> typing.Dict[str, typing.Dict[str, typing.List[str]]]:
         return {
             POSITION_MAN_STAND_UP: {
                 RIFFLE: [
             }
         }
 
-    def get_default_image_for_weapon(self, mode: str, weapon_type: str) -> Image.Image:
+    def get_firing_images_scheme(self) -> typing.Dict[str, typing.Dict[str, typing.List[str]]]:
+        return {
+            POSITION_MAN_STAND_UP: {
+                RIFFLE: [
+                    'actors/man_weap1_firing1.png',
+                    'actors/man_weap1_firing2.png',
+                    'actors/man_weap1_firing3.png',
+                ],
+            },
+        }
+
+    def get_image_for_weapon(self, mode: str, weapon_type: str) -> Image.Image:
         try:
             image_file_path = self.path_manager.path(
                 self._images_scheme[mode][weapon_type][0],
                 'Unknown weapon "{}" for mode "{}"'.format(weapon_type, mode),
             )
 
+    def get_firing_image(
+        self, mode: str,
+        weapon_type: str,
+    ) -> typing.List[Image.Image]:
+        images = []
+        try:
+            image_file_paths = self._firing_images_scheme[mode][weapon_type]
+            for image_file_path in image_file_paths:
+                final_path = self.path_manager.path(image_file_path)
+                try:
+                    images.append(self._firing_cache[final_path])
+                except KeyError:
+                    self._firing_cache[image_file_path] = Image.open(final_path)
+                    images.append(self._firing_cache[image_file_path])
+            return images
+        except KeyError:
+            raise UnknownWeapon(
+                'Unknown weapon "{}" for mode "{}"'.format(weapon_type, mode),
+            )
+
     def get_animation_image_for_weapon(
         self,
         mode: str,