Add a PathManager to permit override file usage prior

synergine2_cocos2d/actor.py

 import cocos
 from cocos import collision_model
 from cocos import euclid
+
+from synergine2.config import Config
 from synergine2.simulation import Subject
 from synergine2_cocos2d.animation import AnimatedInterface
+from synergine2_cocos2d.util import PathManager
 
 
 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,
+        image_path: str,
         subject: Subject,
         position=(0, 0),
         rotation=0,
         color=(255, 255, 255),
         anchor=None,
         properties: dict=None,
+        config: Config=None,
         **kwargs
     ):
+        # Note: Parameter required, but we want to modify little as possible parent init
+        assert config, "Config is a required parameter"
+        self.path_manager = PathManager(config.resolve('global.include_path.graphics'))
+        image = pyglet.resource.image(self.path_manager.path(image_path))
+        self.animation_images = {}  # type: typing.Dict[str, typing.List[pyglet.image.TextureRegion]]  # nopep8
         super().__init__(
             image,
             position,
         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))
+                final_image_path = self.path_manager.path(animation_image_path)
+                self.animation_images[animation_name].append(
+                    pyglet.resource.image(
+                        final_image_path,
+                    )
+                )
 
     def get_images_for_animation(self, animation_name: str) -> typing.List[pyglet.image.TextureRegion]:
         return self.animation_images.get(animation_name)

synergine2_cocos2d/exception.py

 # coding: utf-8
+from synergine2.exceptions import SynergineException
 
 
 class WorldException(Exception):
 
 class InteractionNotFound(Exception):
     pass
+
+
+class MediaException(SynergineException):
+    pass
+
+
+class FileNotFound(SynergineException):
+    pass

synergine2_cocos2d/gui.py

 class SubjectMapper(object):
     def __init__(
         self,
+        config: Config,
         actor_class: typing.Type[Actor],
     ) -> None:
+        self.config = config
         self.actor_class = actor_class
 
     def append(
         subject: XYZSubjectMixin,
         layer_manager: LayerManager,
     ) -> None:
-        actor = self.actor_class(subject)
+        actor = self.actor_class(self.config, subject)
         pixel_position = layer_manager.grid_manager.get_world_position_of_grid_position(
             (subject.position[0], subject.position[1]),
         )

synergine2_cocos2d/util.py

 # coding: utf-8
 import os
+import typing
+from os import path
+
+from synergine2_cocos2d.exception import FileNotFound
 
 
 def get_map_file_path_from_dir(map_dir_path: str) -> str:
     # TODO: path is temp here
     return '{}.tmx'.format(os.path.join(map_dir_path, os.path.basename(map_dir_path)))
+
+
+class PathManager(object):
+    def __init__(
+        self,
+        include_paths: typing.List[str],
+    ) -> None:
+        self._include_paths = []  # type: typing.List[str]
+        self.include_paths = include_paths
+
+    @property
+    def include_paths(self) -> typing.Tuple[str, ...]:
+        return tuple(self._include_paths)
+
+    @include_paths.setter
+    def include_paths(self, value: typing.List[str]) -> None:
+        self._include_paths = value
+        self._include_paths.sort(reverse=True)
+
+    def add_included_path(self, included_path: str) -> None:
+        self._include_paths.append(included_path)
+        self._include_paths.sort(reverse=True)
+
+    def path(self, file_path: str) -> str:
+        # Search in configured paths
+        for include_path in self._include_paths:
+            complete_file_path = path.join(include_path, file_path)
+            if path.isfile(complete_file_path):
+                return complete_file_path
+
+        # If not in include last chance in current dir
+        if path.isfile(file_path):
+            return file_path
+
+        raise FileNotFound('File "{}" not found in paths {}'.format(
+            file_path,
+            self._include_paths,
+        ))

tests/test_utils.py

 # coding: utf-8
+import os
+
+import pytest
+
 from synergine2.utils import ChunkManager
+from synergine2_cocos2d.exception import FileNotFound
+from synergine2_cocos2d.util import PathManager
 from tests import BaseTest
 
 
                 assert len(chunk) == 26
             else:
                 assert len(chunk) == 25
+
+    def test_path_manager(self):
+        path_manager = PathManager(['tests/fixtures/some_media'])
+        # file in thirst dir found
+        assert 'tests/fixtures/some_media/foo.txt' == path_manager.path('foo.txt')
+        # a non existing file is not found
+        with pytest.raises(FileNotFound):
+            path_manager.path('UNKNOWN')
+        # if add a folder to path manager paths
+        path_manager.add_included_path('tests/fixtures/some_media2')
+        # it is prior on path finding
+        assert 'tests/fixtures/some_media2/foo.txt' == path_manager.path('foo.txt')