Smell code

intelligine/core/Context.py

         return self._pheromones
 
     def position_is_penetrable(self, position):
+        """
+
+        Return True if position is empty or occuped by non physical impenetrable object.
+
+        :param position:
+        :return:
+        """
         objects_ids_on_this_point = self.metas.list.get(POSITIONS, position, allow_empty=True)
         for object_id_on_this_point in objects_ids_on_this_point:
           if self.metas.states.have(object_id_on_this_point, IMPENETRABLE):
             return False
-        return True
+        return True
+
+    def position_can_be_odorus(self, position):
+        """
+
+        Return True if position can smell
+
+        :param position:
+        :return:
+        """
+        return self.position_is_penetrable(position)

intelligine/cst.py

 PHEROMON_DIR_EXPLO = IncrementedNamedInt.get('intelligine.phero.direction.explo')
 PHEROMON_DIR_HOME = IncrementedNamedInt.get('intelligine.phero.direction.home')
 
+OBJ_SMELL = IncrementedNamedInt.get('intelligine.obj_smell')
+SMELL_FOOD = IncrementedNamedInt.get('intelligine.smell.food')
+SMELL_EGG = IncrementedNamedInt.get('intelligine.smell.egg')
+POINT_SMELL = IncrementedNamedInt.get('intelligine.point_smell')
+POINTS_SMELL = IncrementedNamedInt.get('intelligine.points_smell')
+
 COL_ALIVE = IncrementedNamedInt.get('intelligine.col.alive')
 COL_WALKER = IncrementedNamedInt.get('intelligine.col.walker')
 COL_FIGHTER = IncrementedNamedInt.get('intelligine.col.walker')
 COL_TRANSPORTER_CARRYING = IncrementedNamedInt.get('intelligine.col.transporter_carrying')
 COL_TRANSPORTER_NOT_CARRYING = IncrementedNamedInt.get('intelligine.col.transporter_not_carrying')
 COL_EATABLE = IncrementedNamedInt.get('intelligine.col.eatable')
+COL_SMELL = IncrementedNamedInt.get('intelligine.col.smell')
 
 BRAIN_SCHEMA = IncrementedNamedInt.get('intelligine.brain_schema')
 BRAIN_PART_MOVE = IncrementedNamedInt.get('intelligine.brain.part.move')

intelligine/display/Pygame.py

 from intelligine.core.exceptions import NoPheromone
 from synergine_xyz.display.Pygame import Pygame as XyzPygame
 import pygame
-from intelligine.cst import PHEROMON_DIRECTION, PHEROMON_DIR_HOME, PHEROMON_DIR_EXPLO, PHEROMON_POSITIONS
-from intelligine.display.pygame.visualisation import SURFACE_PHEROMONE_EXPLORATION, SURFACE_PHEROMONE_HOME
+from intelligine.cst import PHEROMON_DIRECTION, PHEROMON_DIR_HOME, PHEROMON_DIR_EXPLO, PHEROMON_POSITIONS, POINTS_SMELL, \
+    POINT_SMELL, SMELL_EGG, SMELL_FOOD
+from intelligine.display.pygame.visualisation import SURFACE_PHEROMONE_EXPLORATION, SURFACE_PHEROMONE_HOME, \
+    SURFACE_SMELL_EGG, SURFACE_SMELL_FOOD
 
 
 class Pygame(XyzPygame):
     def __init__(self, config, context, synergy_manager):
         super().__init__(config, context, synergy_manager)
         self._is_display_pheromones = False
+        self._is_display_smells = False
 
     def receive(self, actions_done):
         super().receive(actions_done)
+
         if self._is_display_pheromones:
             pheromones_positions = self._context.metas.list.get(PHEROMON_POSITIONS,
                                                                 PHEROMON_POSITIONS,
                                                                 allow_empty=True)
             self._display_pheromones(pheromones_positions, self._context)
 
+        if self._is_display_smells:
+            smell_positions = self._context.metas.list.get(POINTS_SMELL,
+                                                           POINTS_SMELL,
+                                                           allow_empty=True)
+            self._display_smells(smell_positions, self._context)
+
     def _display_pheromones(self, pheromones_positions, context):
         pheromone_exploration_surface = self._object_visualizer.get_surface(SURFACE_PHEROMONE_EXPLORATION)
         pheromone_home_surface = self._object_visualizer.get_surface(SURFACE_PHEROMONE_HOME)
             except NoPheromone:
                 pass # No pheromone here
 
+    def _display_smells(self, smell_positions, context):
+        smell_egg_surface = self._object_visualizer.get_surface(SURFACE_SMELL_EGG)
+        smell_food_surface = self._object_visualizer.get_surface(SURFACE_SMELL_FOOD)
+
+        for point in smell_positions:
+            point_flavour = context.metas.value.get(POINT_SMELL, point, allow_empty=True, empty_value={})
+            if SMELL_EGG in point_flavour:
+                self.draw_surface(point, smell_egg_surface)
+            if SMELL_FOOD in point_flavour:
+                self.draw_surface(point, smell_food_surface)
+
     def _key_pressed(self, key):
-        if key == pygame.K_p:
-            if self._is_display_pheromones:
-                self._is_display_pheromones = False
-            else:
-                self._is_display_pheromones = True
+        self._is_display_pheromones = key == pygame.K_p
+        self._is_display_smells = key == pygame.K_s

intelligine/display/pygame/visualisation.py

 SURFACE_PHEROMONE_HOME = 'pheromone_home'
 SURFACE_PHEROMONE_EXPLORATION = 'pheromone_exploration'
 
+SURFACE_SMELL_EGG = 'smell_egg'
+SURFACE_SMELL_FOOD = 'smell_food'
+
 # TODO: Analyser les procedes ici pour proposer des outils dans le framework
 
 # ant = PygameImage.from_filepath(getcwd()+'/intelligine/display/pygame/image/ant.png')
 eggc7 = PygameImage.from_filepath(getcwd()+'/intelligine/display/pygame/image/egg_c7.png')
 phee = PygameImage.from_filepath(getcwd()+'/intelligine/display/pygame/image/phee.png')
 pheh = PygameImage.from_filepath(getcwd()+'/intelligine/display/pygame/image/pheh.png')
+
+smell = PygameImage.from_filepath(getcwd()+'/intelligine/display/pygame/image/smell.png')
 #
 # directions_ant = DirectionnedImage(ant)
 # directions_red_ant = DirectionnedImage(red_ant)
                 'default': pheh,
                 'callbacks': []
             },
+            SURFACE_SMELL_EGG: {
+                'default': smell,
+                'callbacks': []
+            },
+            SURFACE_SMELL_FOOD: {
+                'default': smell,
+                'callbacks': []
+            },
         }
     })
 

intelligine/mechanism/TraversableDistanceFromMechanism.py

+from synergine_xyz.mechanism.DistanceFromMechanism import DistanceFromMechanism
+
+
+class TraversableDistanceFromMechanism(DistanceFromMechanism):
+    """
+    Prepare list of traversable points around synergy object position. These point are associated with distance
+    of synergy object position.
+    """
+
+    def _get_maximum_distance(self, object_id, context):
+        # TODO (ds surcharge) Maintenir un rayon (calculé en fonction de la taille de la colonie + ratio en
+        #  fonction de ce qui est smelling)
+        # pour le moment ...valeur hardcode
+        return 6
+
+    def _point_is_computable(self, context, point):
+        return context.position_can_be_odorus(point)

intelligine/synergy/Rocks.py

+from intelligine.synergy.event.smell.SmellAction import SmellAction
 from synergine.synergy.collection.SynergyCollection import SynergyCollection
 
 
 class Rocks(SynergyCollection):
-    pass
+    """
+    TODO: Rename in Environment
+    """
+
+    def __init__(self, configuration):
+        super().__init__(configuration)
+        self._actions = [SmellAction]

intelligine/synergy/event/smell/SmellAction.py

+from intelligine.cst import POINT_SMELL, POINTS_SMELL
+from intelligine.synergy.event.smell.SmellEvent import SmellEvent
+from synergine.synergy.event.Action import Action
+
+
+class SmellAction(Action):
+
+    _listen = SmellEvent
+
+    def run(self, obj, context, synergy_manager):
+
+        points_distances = self._parameters['points_distances']
+        smell_type = obj.get_smell()
+
+        for smell_point in points_distances:
+
+            where_to_put_smells = context.metas.value.get(POINT_SMELL, smell_point, allow_empty=True, empty_value={})
+            current_point_smell = points_distances[smell_point]
+
+            if smell_type not in where_to_put_smells:
+                where_to_put_smells[smell_type] = current_point_smell
+            else:
+                where_to_put_smell = where_to_put_smells[smell_type]
+                if current_point_smell < where_to_put_smell:
+                    where_to_put_smells[smell_type] = where_to_put_smell
+
+            context.metas.value.set(POINT_SMELL, smell_point, where_to_put_smells)
+            context.metas.list.add(POINTS_SMELL, POINTS_SMELL, smell_point, assert_not_in=False)

intelligine/synergy/event/smell/SmellEvent.py

+from intelligine.cst import COL_SMELL
+from intelligine.mechanism.TraversableDistanceFromMechanism import TraversableDistanceFromMechanism
+from intelligine.synergy.event.Event import Event
+from intelligine.cst import SMELL_FOOD, SMELL_EGG
+from intelligine.synergy.object.StockedFood import StockedFood
+from intelligine.synergy.object.ant.Egg import Egg
+from synergine.core.exceptions import NotConcernedEvent
+
+
+class SmellEvent(Event):
+
+    _mechanism = TraversableDistanceFromMechanism
+    _concern = COL_SMELL
+    _each_cycle = 100
+    _first_cycle_force = True
+    _smell = {
+        StockedFood: SMELL_FOOD,
+        Egg: SMELL_EGG
+    }
+    """ Match between synergy class and smell type """
+
+    def _prepare(self, object_id, context, parameters={}):
+        if not parameters['points_distances']:
+            raise NotConcernedEvent()
+
+        return parameters

intelligine/synergy/object/Egg.py

 from intelligine.synergy.object.BaseBug import BaseBug
-from intelligine.cst import TRANSPORTABLE, TYPE_NURSERY, TYPE
+from intelligine.cst import TYPE_NURSERY, TYPE, SMELL_EGG
 
 
 class Egg(BaseBug):
         super().__init__(collection, context)
         context.metas.list.add(TYPE, self.get_id(), TYPE_NURSERY)
         self._life_points = 1
+        self._set_smell(SMELL_EGG)

intelligine/synergy/object/StockedFood.py

-from intelligine.cst import TYPE, TYPE_RESOURCE_EXPLOITABLE, COL_EATABLE
+from intelligine.cst import TYPE, TYPE_RESOURCE_EXPLOITABLE, COL_EATABLE, COL_SMELL, SMELL_FOOD
 from intelligine.synergy.object.Food import Food
 
 
         super().__init__(collection, context)
         context.metas.list.remove(TYPE, self.get_id(), TYPE_RESOURCE_EXPLOITABLE)
         self._add_col(COL_EATABLE)
+        self._add_col(COL_SMELL)
+        self._set_smell(SMELL_FOOD)

intelligine/synergy/object/SynergyObject.py

+from intelligine.cst import OBJ_SMELL
+from synergine_xyz.SynergyObject import SynergyObject as XyzSynergyObject
+
+
+class SynergyObject(XyzSynergyObject):
+
+    def __init__(self, collection, context):
+        super().__init__(collection, context)
+        self._smell = None
+
+    def _set_smell(self, smell_type):
+        self._smell = smell_type
+        self._context.metas.value.set(OBJ_SMELL, self.get_id(), smell_type)
+
+    def get_smell(self):
+        if not self._smell:
+            raise Exception('Smell type not defined')
+        return self._smell

intelligine/synergy/object/Transportable.py

-from synergine_xyz.SynergyObject import SynergyObject as XyzSynergyObject
 from intelligine.cst import TRANSPORTABLE, CARRIED
+from intelligine.synergy.object.SynergyObject import SynergyObject
 
 
-class Transportable(XyzSynergyObject):
+class Transportable(SynergyObject):
 
     def __init__(self, collection, context):
         super().__init__(collection, context)