Merge branch 'dev/refact'

TODO

@@ -8,6 +8,8 @@ TODO:
 
  * Mechanisme qui donne les pheromones around ?
  * Appliquer la disparition des pheromones
+ * Les move mode sont arbitraire. On sais (cf. livre Ameisen) qu'elles se spécialisent avec l'expérience de reussite/echec. Voir coment implémenter ça !
+ * Display: la maj de ce qui est envoye aux terminaux: penser aux donnees comme les pheromones
 
 Future:
  * Chambres

config.py

@@ -6,20 +6,6 @@ from intelligine.display.pygame.visualisation import visualisation as pygame_vis
 # TODO: influencer avec argument python
 from intelligine.sandbox.exploration.collections import collections
 
-"""
- TODO:
- * AttackAction :: comment choisir entre les actions ?
-
- * pheromones:
-   cf. doc papier
-   + Pour le "pt de ressource": Poser un objet qui, lorsque on applique la position:
-     L'objet doit pouvoir occuper plusieurs positions (gros objet)
-     Il a donc * une position de reference
-               * une liste de positions occupe
-               * dans les metas cette liste de position contient la reference de l'objet
-               *
-
-"""
 
 config = {
     'app': {

intelligine/core/exceptions.py

@@ -42,6 +42,9 @@ class BestPheromoneHere(PheromoneException):
     def get_best_distance(self):
         return self._best_distance
 
+class PheromoneGlandDisabled(PheromoneException):
+    pass
+
 
 class BrainException(Exception):
     pass
@@ -51,6 +54,14 @@ class BrainPartAlreadyExist(BrainException):
     pass
 
 
+class BodyException(Exception):
+    pass
+
+
+class BodyPartAlreadyExist(BodyException):
+    pass
+
+
 class DirectionException(Exception):
     pass
 

intelligine/cst.py

@@ -15,18 +15,20 @@ CANT_PUT_STILL = IncrementedNamedInt.get('intelligine.cantput.still')
 ACTION_DIE = IncrementedNamedInt.get('intelligine.basebug.action.die')
 PHEROMONE_SEARCHING = IncrementedNamedInt.get('intelligine.pheromone_searching')
 
+# TODO: Renommer "move_mode" en "mode"
 MOVE_MODE = IncrementedNamedInt.get('intelligine.basebug.move.mode')
 MOVE_MODE_EXPLO = IncrementedNamedInt.get('intelligine.basebug.move.mode.explo')
 MOVE_MODE_GOHOME = IncrementedNamedInt.get('intelligine.basebug.move.mode.gohome')
+MOVE_MODE_NURSE = IncrementedNamedInt.get('intelligine.basebug.move.mode.nurse')
 
 TYPE = IncrementedNamedInt.get('intelligine.object.type')
 TYPE_RESOURCE_TRANSFORMABLE = IncrementedNamedInt.get('intelligine.object.type.resource.transformable')
-
-LAST_PHERMONES_POINTS = IncrementedNamedInt.get('intelligine.last_pheromones_points')
+TYPE_NURSERY = IncrementedNamedInt.get('intelligine.object.type.nursery')
 
 PHEROMON_POSITIONS = IncrementedNamedInt.get('intelligine.phero.positions')
 PHEROMON_INFOS = IncrementedNamedInt.get('intelligine.phero.infos')
 PHEROMON_DIRECTION = IncrementedNamedInt.get('intelligine.phero.direction')
+PHEROMON_DIR_NONE = IncrementedNamedInt.get('intelligine.phero.direction.none')
 PHEROMON_DIR_EXPLO = IncrementedNamedInt.get('intelligine.phero.direction.explo')
 PHEROMON_DIR_HOME = IncrementedNamedInt.get('intelligine.phero.direction.home')
 
@@ -40,4 +42,8 @@ COL_TRANSPORTER_NOT_CARRYING = IncrementedNamedInt.get('intelligine.col.transpor
 BRAIN_SCHEMA = IncrementedNamedInt.get('intelligine.brain_schema')
 BRAIN_PART_MOVE = IncrementedNamedInt.get('intelligine.brain.part.move')
 BRAIN_PART_TAKE = IncrementedNamedInt.get('intelligine.brain.part.take')
-BRAIN_PART_PUT = IncrementedNamedInt.get('intelligine.brain.part.put')
+BRAIN_PART_PUT = IncrementedNamedInt.get('intelligine.brain.part.put')
+BRAIN_PART_ATTACK = IncrementedNamedInt.get('intelligine.brain.part.attack')
+
+BODY_SCHEMA = IncrementedNamedInt.get('intelligine.body_schema')
+BODY_PART_PHEROMONE_GLAND = IncrementedNamedInt.get('intelligine.body.part.pheromone_gland')

intelligine/sandbox/colored/RedColonyConfiguration.py

@@ -1,17 +1,21 @@
 from intelligine.synergy.ColonyConfiguration import ColonyConfiguration
 from intelligine.sandbox.colored.RedAnt import RedAnt
 from intelligine.synergy.object.ant.Egg import Egg
-from intelligine.cst import COLONY
+from intelligine.cst import COLONY, MOVE_MODE_NURSE
 
 
 class RedColonyConfiguration(ColonyConfiguration):
 
     _start_position = (0, 20, 70)
     _ant_class = RedAnt
+    _ant_count = 50
 
     def get_start_objects(self, collection, context):
         objects = super().get_start_objects(collection, context)
 
+        for ant in objects:
+            ant._brain.switch_to_mode(MOVE_MODE_NURSE)
+
         for x in range(50):
           for y in range(1, 50):
             if x % 3 == 0 and y % 3 == 0:

intelligine/simulation/object/brain/AntBrain.py

@@ -1,7 +1,7 @@
 from intelligine.simulation.object.brain.Brain import Brain
 from intelligine.simulation.object.brain.part.move.AntMoveBrainPart import AntMoveBrainPart
 from intelligine.cst import MOVE_MODE, MOVE_MODE_EXPLO, MOVE_MODE_GOHOME, PHEROMON_DIR_HOME, PHEROMON_DIR_EXPLO, \
-    BRAIN_PART_TAKE, BRAIN_PART_PUT
+    BRAIN_PART_TAKE, BRAIN_PART_PUT, MOVE_MODE_NURSE, PHEROMON_DIR_NONE
 from intelligine.cst import PHEROMONE_SEARCHING
 from intelligine.cst import BRAIN_PART_MOVE
 from intelligine.simulation.object.brain.part.transport.AntPutBrainPart import AntPutBrainPart
@@ -10,29 +10,19 @@ from intelligine.simulation.object.brain.part.transport.AntTakeBrainPart import
 
 class AntBrain(Brain):
 
-    _brain_part_move_class = AntMoveBrainPart
-    _brain_part_take_class = AntTakeBrainPart
-    _brain_part_put_class = AntPutBrainPart
+    # TODO: methode __init_ pour la classe ? Pour surcharger ici.
+    _brain_parts = {
+        BRAIN_PART_MOVE: AntMoveBrainPart,
+        BRAIN_PART_TAKE: AntTakeBrainPart,
+        BRAIN_PART_PUT: AntPutBrainPart
+    }
 
     def __init__(self, context, host):
         super().__init__(context, host)
-        # TODO: Gerer les BrainPart avec un dictionnaire ?
-        self._set_brain_part(BRAIN_PART_MOVE, self._get_move_brain_part_instance())
-        self._set_brain_part(BRAIN_PART_TAKE, self._get_take_brain_part_instance())
-        self._set_brain_part(BRAIN_PART_PUT, self._get_put_brain_part_instance())
         self._movement_mode = MOVE_MODE_EXPLO
         self._distance_from_objective = 0  # TODO rename: distance_since_objective
         self._pheromone_searching = PHEROMON_DIR_EXPLO
 
-    def _get_move_brain_part_instance(self):
-        return self._brain_part_move_class()
-
-    def _get_take_brain_part_instance(self):
-        return self._brain_part_take_class()
-
-    def _get_put_brain_part_instance(self):
-        return self._brain_part_put_class()
-
     def switch_to_mode(self, mode):
         self._movement_mode = mode
         self._update_pheromone_gland(mode)
@@ -45,15 +35,24 @@ class AntBrain(Brain):
             pheromone_direction_type = PHEROMON_DIR_HOME
         elif mode == MOVE_MODE_GOHOME:
             pheromone_direction_type = PHEROMON_DIR_EXPLO
+        elif mode == MOVE_MODE_NURSE:
+            pheromone_direction_type = None
         else:
             raise NotImplementedError()
-        self._host.get_movement_pheromone_gland().set_pheromone_type(pheromone_direction_type)
+
+        if pheromone_direction_type:
+            self._host.get_movement_pheromone_gland().set_pheromone_type(pheromone_direction_type)
+            self._host.get_movement_pheromone_gland().enable()
+        else:
+            self._host.get_movement_pheromone_gland().disable()
 
     def _update_pheromone_searching(self, mode):
         if mode == MOVE_MODE_EXPLO:
             pheromone_searching = PHEROMON_DIR_EXPLO
         elif mode == MOVE_MODE_GOHOME:
             pheromone_searching = PHEROMON_DIR_HOME
+        elif mode == MOVE_MODE_NURSE:
+            pheromone_searching = PHEROMON_DIR_NONE
         else:
             raise NotImplementedError()
         self._pheromone_searching = pheromone_searching

intelligine/simulation/object/brain/Brain.py

@@ -4,13 +4,18 @@ from intelligine.cst import BRAIN_SCHEMA
 
 class Brain():
 
-    _brain_part_class = {}
+    _brain_parts = {}
 
     def __init__(self, context, host):
         self._context = context
         self._host = host
         self._schema = {}
         self._parts = {}
+        self._init_parts()
+
+    def _init_parts(self):
+        for brain_part_name in self._brain_parts:
+            self._set_brain_part(brain_part_name, self._brain_parts[brain_part_name](self))
 
     def _set_brain_part(self, name, brain_part, replace=False):
         if name in self._parts and not replace:
@@ -25,4 +30,6 @@ class Brain():
         self._schema = {}
         for part_name in self._parts:
             self._schema[part_name] = self._parts[part_name].__class__
+        # TODO: N'est-ce pas un schema appartenant a la classe ? Ne suffirai t-il pas de stocker ce schema par classe
+        # plutôt que par objet ?
         self._context.metas.value.set(BRAIN_SCHEMA, self._host.get_id(), self._schema)

intelligine/simulation/object/brain/part/BrainPart.py

@@ -1,4 +1,7 @@
 class BrainPart():
 
+    def __init__(self, host_brain):
+        self._host_brain = host_brain
+
     def done(self, obj, context):
         pass

intelligine/simulation/object/brain/part/move/AntMoveBrainPart.py

@@ -49,5 +49,6 @@ class AntMoveBrainPart(MoveBrainPart):
 
     @staticmethod
     def _appose_pheromone(obj):
-        obj.get_movement_pheromone_gland().appose()
+        if obj.get_movement_pheromone_gland().is_enabled():
+            obj.get_movement_pheromone_gland().appose()
 

intelligine/simulation/object/brain/part/transport/AntPutBrainPart.py

@@ -1,11 +1,11 @@
 from intelligine.core.exceptions import CantFindWhereToPut
-from intelligine.simulation.object.brain.part.transport.TakeBrainPart import TakeBrainPart
-from intelligine.cst import MOVE_MODE_EXPLO, MOVE_MODE, TYPE_RESOURCE_TRANSFORMABLE, TYPE, CARRIED, \
-    COL_TRANSPORTER_NOT_CARRYING, COL_TRANSPORTER_CARRYING
+from intelligine.cst import MOVE_MODE_EXPLO, TYPE_RESOURCE_TRANSFORMABLE, CARRIED
+from intelligine.simulation.object.brain.part.transport.TransportBrainPart import TransportBrainPart
+from intelligine.synergy.object.Food import Food
 from xyzworld.cst import POSITION, POSITIONS
 
 
-class AntPutBrainPart(TakeBrainPart):
+class AntPutBrainPart(TransportBrainPart):
 
     # TODO: methode __nit_ pour la classe ?
     _mode_matches = {
@@ -52,6 +52,9 @@ class AntPutBrainPart(TakeBrainPart):
         return False
 
     def done(self, obj, puted_object, context):
-        # TODO: Depose au -1 pour des raisons de test. Plus tard ce sera des tas comme un autre !
-        puted_object.set_position((-1, 0, 0))
-        obj.get_brain().switch_to_mode(MOVE_MODE_EXPLO)
+        # TODO: Il faut refact/logique qqpart pour ca !! Genre Brain.done(PUT, ??)
+        if isinstance(puted_object, Food):
+            obj.get_brain().switch_to_mode(MOVE_MODE_EXPLO)
+            # TODO: TEST Depose au -1 pour des raisons de test. Plus tard ce sera des tas comme un autre !
+            puted_object.set_position((-1, 0, 0))
+

intelligine/simulation/object/brain/part/transport/AntTakeBrainPart.py

@@ -1,14 +1,15 @@
 from intelligine.simulation.object.brain.part.transport.TakeBrainPart import TakeBrainPart
 from intelligine.synergy.object.ressource.Ressource import Resource
 from intelligine.cst import MOVE_MODE_EXPLO, MOVE_MODE, TYPE_RESOURCE_TRANSFORMABLE, \
-    TYPE, MOVE_MODE_GOHOME, PHEROMON_DIR_EXPLO
+    TYPE, MOVE_MODE_GOHOME, PHEROMON_DIR_EXPLO, MOVE_MODE_NURSE, TYPE_NURSERY
 
 
 class AntTakeBrainPart(TakeBrainPart):
 
-    # TODO: methode __nit_ pour la classe ? vt mieux surcharger !
+    # TODO: methode __init_ pour la classe ? Pour surcharger ici.
     _mode_matches = {
         MOVE_MODE_EXPLO: [TYPE_RESOURCE_TRANSFORMABLE],
+        MOVE_MODE_NURSE: [TYPE_NURSERY]
     }
 
     @classmethod
@@ -20,6 +21,4 @@ class AntTakeBrainPart(TakeBrainPart):
         # TODO: Ranger ca ? Truc plus dynamique/configurable ?
         if isinstance(take_object, Resource):
             obj.get_brain().switch_to_mode(MOVE_MODE_GOHOME)
-            # TODO: set_last_pheromone_point ca devrait pas etre dans get_movement_pheromone_gland().appose() ?
-            obj.set_last_pheromone_point(PHEROMON_DIR_EXPLO, obj.get_position())
             obj.get_movement_pheromone_gland().appose()

intelligine/simulation/object/brain/part/transport/TransportBrainPart.py

@@ -16,9 +16,6 @@ class TransportBrainPart(BrainPart):
 
     @classmethod
     def _objects_have_same_type(cls, context, object_carried_id, object_to_put_id):
-        # BUG: On considere ici que c une liste de type pour obj. J'ai fait l'inverse.
-        # Une listde de objid pour un type.
-        # TODO: Il faut inverser !
         object_carried_types = context.metas.list.get(TYPE, object_carried_id)
         for object_carried_type in object_carried_types:
             if context.metas.list.have(TYPE, object_to_put_id, object_carried_type):

intelligine/simulation/object/pheromone/PheromoneGland.py

@@ -1,4 +1,4 @@
-from intelligine.core.exceptions import BestPheromoneHere
+from intelligine.core.exceptions import BestPheromoneHere, PheromoneGlandDisabled
 from intelligine.simulation.pheromone.DirectionPheromone import DirectionPheromone
 
 class PheromoneGland():
@@ -7,6 +7,7 @@ class PheromoneGland():
         self._pheromone_type = None
         self._host = host
         self._context = context
+        self._enabled = False
 
     def set_pheromone_type(self, pheromone_type):
         self._pheromone_type = pheromone_type
@@ -20,9 +21,21 @@ class PheromoneGland():
         raise NotImplementedError()
 
     def appose(self):
+        if not self._enabled:
+            raise PheromoneGlandDisabled()
+
         try:
             DirectionPheromone.appose(self._context,
                                       self._host.get_position(),
                                       self.get_pheromone())
         except BestPheromoneHere as best_pheromone_here:
-            self._host.get_brain().set_distance_from_objective(best_pheromone_here.get_best_distance())
+            self._host.get_brain().set_distance_from_objective(best_pheromone_here.get_best_distance())
+
+    def disable(self):
+        self._enabled = False
+
+    def enable(self):
+        self._enabled = True
+
+    def is_enabled(self):
+        return self._enabled

intelligine/simulation/pheromone/DirectionPheromone.py

@@ -12,23 +12,15 @@ class DirectionPheromone():
         context.pheromones().increment_with_pheromone(point, pheromone)
         context.metas.list.add(PHEROMON_POSITIONS, PHEROMON_POSITIONS, point, assert_not_in=False)
 
-    @staticmethod
-    def get_direction_for_point(context, point, pheromone_type):
+    @classmethod
+    def get_direction_for_point(cls, context, point, pheromone_type):
         flavour = context.pheromones().get_flavour(point)
         pheromone = flavour.get_pheromone(category=PHEROMON_DIRECTION, type=pheromone_type)
 
         distance = pheromone.get_distance()
-        around_points = context.get_around_points_of(point)
-        # TODO: Cet algo around a mettre ailleurs
-        around_pheromones_points = []
-        for around_point in around_points:
-            flavour = context.pheromones().get_flavour(around_point)
-            try:
-                around_pheromone = flavour.get_pheromone(category=PHEROMON_DIRECTION, type=pheromone_type)
-                if around_pheromone.get_distance() < distance:
-                    around_pheromones_points.append((around_point, around_pheromone))
-            except NoPheromone:
-                pass  # No pheromone, ok continue to sniff around
+        around_pheromone_filter = lambda around_pheromone: around_pheromone.get_distance() < distance
+        around_pheromones_points = cls._get_around_pheromones(context, point, pheromone_type,
+                                                              pheromone_filter=around_pheromone_filter)
 
         if not around_pheromones_points:
             raise NoPheromone()
@@ -54,6 +46,22 @@ class DirectionPheromone():
         return direction
 
     @staticmethod
+    def _get_around_pheromones(context, reference_point, pheromone_type,
+                               pheromone_filter=lambda around_pheromone: True):
+        around_points = context.get_around_points_of(reference_point)
+        around_pheromones_points = []
+        for around_point in around_points:
+            flavour = context.pheromones().get_flavour(around_point)
+            try:
+                around_pheromone = flavour.get_pheromone(category=PHEROMON_DIRECTION, type=pheromone_type)
+                if pheromone_filter(around_pheromone):
+                    around_pheromones_points.append((around_point, around_pheromone))
+            except NoPheromone:
+                pass  # No pheromone, ok continue to sniff around
+
+        return around_pheromones_points
+
+    @staticmethod
     def get_best_pheromone_direction_in(context, reference_point, points, pheromone_type):
         around_pheromones_points = []
         for around_point in points:

intelligine/synergy/event/attack/NearAttackableEvent.py

@@ -2,7 +2,7 @@ from intelligine.core.exceptions import NearNothingFound
 from synergine.core.exceptions import NotConcernedEvent
 from intelligine.synergy.event.src.NearEvent import NearEvent
 from xyzworld.mechanism.ArroundMechanism import ArroundMechanism
-from intelligine.cst import ATTACKABLE, COLONY, COL_FIGHTER
+from intelligine.cst import ATTACKABLE, COLONY, COL_FIGHTER, BRAIN_PART_ATTACK
 
 
 class NearAttackableEvent(NearEvent):
@@ -24,4 +24,8 @@ class NearAttackableEvent(NearEvent):
         except NearNothingFound:
             raise NotConcernedEvent()
 
+        brain_part = self._get_brain_part(context, object_id, BRAIN_PART_ATTACK)
+        if not brain_part.can_attack(context, object_id, parameters[self._near_name][0]):
+            raise NotConcernedEvent()
+
         return parameters

intelligine/synergy/event/transport/PutableEvent.py

@@ -30,7 +30,7 @@ class PutableEvent(NearEvent):
             raise NotConcernedEvent()
 
         object_near_id = parameters[self._near_name][0]
-        brain_part = self._get_brain_part(object_id, context)
+        brain_part = self._get_brain_part(context, object_id, BRAIN_PART_PUT)
 
         if not brain_part.can_put(context, object_id, object_near_id):
             raise NotConcernedEvent()
@@ -48,14 +48,7 @@ class PutableEvent(NearEvent):
     def _can_put(object_id, context):
         return not context.metas.value.get(CANT_PUT_STILL, object_id, allow_empty=True)
 
-    @staticmethod
-    def _get_brain_part(object_id, context):
-        # TODO: refatc au dessus ?
-        object_brain_schema = context.metas.value.get(BRAIN_SCHEMA, object_id)
-        return object_brain_schema[BRAIN_PART_PUT]
-
-    @staticmethod
-    def _object_can_put(object_id, context, object_to_put_id):
-        object_brain_schema = context.metas.value.get(BRAIN_SCHEMA, object_id)
-        object_take_brain_part = object_brain_schema[BRAIN_PART_PUT]
+    @classmethod
+    def _object_can_put(cls, object_id, context, object_to_put_id):
+        object_take_brain_part = cls._get_brain_part(context, object_id, BRAIN_PART_PUT)
         return object_take_brain_part.can_put(context, object_id, object_to_put_id)

intelligine/synergy/event/transport/TakeableEvent.py

@@ -35,8 +35,7 @@ class TakeableEvent(NearEvent):
     def _can_carry(object_id, context):
         return not context.metas.value.get(CANT_CARRY_STILL, object_id, allow_empty=True)
 
-    @staticmethod
-    def _object_can_take(object_id, context, object_to_take_id):
-        object_brain_schema = context.metas.value.get(BRAIN_SCHEMA, object_id)
-        object_take_brain_part = object_brain_schema[BRAIN_PART_TAKE]
+    @classmethod
+    def _object_can_take(cls, object_id, context, object_to_take_id):
+        object_take_brain_part = cls._get_brain_part(context, object_id, BRAIN_PART_TAKE)
         return object_take_brain_part.can_take(context, object_id, object_to_take_id)

intelligine/synergy/object/BaseBug.py

@@ -1,3 +1,4 @@
+from intelligine.core.exceptions import BodyPartAlreadyExist
 from intelligine.synergy.object.Transportable import Transportable
 from intelligine.cst import ALIVE, ATTACKABLE, COL_ALIVE
 from intelligine.simulation.object.brain.Brain import Brain
@@ -5,6 +6,8 @@ from intelligine.simulation.object.brain.Brain import Brain
 
 class BaseBug(Transportable):
 
+    _body_parts = {}
+
     def __init__(self, collection, context):
         super().__init__(collection, context)
         context.metas.states.add_list(self.get_id(), [ALIVE, ATTACKABLE])
@@ -12,6 +15,20 @@ class BaseBug(Transportable):
         self._life_points = 10
         self._movements_count = -1
         self._brain = self._get_brain_instance()
+        self._parts = {}
+        self._init_parts()
+
+    def _init_parts(self):
+        for body_part_name in self._body_parts:
+            self._set_body_part(body_part_name, self._body_parts[body_part_name](self, self._context))
+
+    def _set_body_part(self, name, body_part, replace=False):
+        if name in self._parts and not replace:
+            raise BodyPartAlreadyExist()
+        self._parts[name] = body_part
+
+    def get_body_part(self, name):
+        return self._parts[name]
 
     def hurted(self, points):
         self._life_points -= points

intelligine/synergy/object/Egg.py

@@ -1,10 +1,12 @@
 from intelligine.synergy.object.BaseBug import BaseBug
-from intelligine.cst import TRANSPORTABLE
+from intelligine.cst import TRANSPORTABLE, TYPE_NURSERY, TYPE
 
 
 class Egg(BaseBug):
 
     def __init__(self, collection, context):
         super().__init__(collection, context)
+        context.metas.list.add(TYPE, self.get_id(), TYPE_NURSERY)
+        # TODO: ?? TRANSPORTABLE ne devrait pas ette du cote de Transportable ?
         context.metas.states.add(self.get_id(), TRANSPORTABLE)
         self._life_points = 1

intelligine/synergy/object/ant/Ant.py

@@ -1,10 +1,7 @@
-from intelligine.core.exceptions import BestPheromoneHere
-from intelligine.simulation.pheromone.DirectionPheromone import DirectionPheromone
+from intelligine.core.exceptions import PheromoneException
 from intelligine.synergy.object.Bug import Bug
-from intelligine.cst import CARRYING, TRANSPORTER, ATTACKER, \
-                            COL_TRANSPORTER, COL_TRANSPORTER_NOT_CARRYING, \
-                            COL_FIGHTER, MOVE_MODE_EXPLO, MOVE_MODE_GOHOME, \
-                            PHEROMON_DIR_EXPLO, LAST_PHERMONES_POINTS, CARRIED
+from intelligine.cst import CARRYING, TRANSPORTER, ATTACKER, COL_TRANSPORTER, COL_TRANSPORTER_NOT_CARRYING, \
+    COL_FIGHTER, MOVE_MODE_EXPLO, MOVE_MODE_GOHOME, CARRIED, BODY_PART_PHEROMONE_GLAND
 from intelligine.synergy.object.Food import Food
 from intelligine.simulation.object.pheromone.MovementPheromoneGland import MovementPheromoneGland
 from intelligine.simulation.object.brain.AntBrain import AntBrain
@@ -12,76 +9,63 @@ from intelligine.simulation.object.brain.AntBrain import AntBrain
 
 class Ant(Bug):
 
+    _body_parts = {
+        BODY_PART_PHEROMONE_GLAND: MovementPheromoneGland
+    }
+
     def __init__(self, collection, context):
         super().__init__(collection, context)
         context.metas.states.add_list(self.get_id(), [TRANSPORTER, ATTACKER])
         context.metas.collections.add_list(self.get_id(), [COL_TRANSPORTER,
                                                            COL_TRANSPORTER_NOT_CARRYING,
                                                            COL_FIGHTER])
-        self._carried = []
-        self._last_pheromones_points = {}
-        # TODO: Faire un body_part schema pour ces trucs la
-        self._movement_pheromone_gland = MovementPheromoneGland(self, self._context)
+        self._carried = None
         self._brain.switch_to_mode(MOVE_MODE_EXPLO)
 
     def _get_brain_instance(self):
         return AntBrain(self._context, self)
 
     def get_movement_pheromone_gland(self):
-        return self._movement_pheromone_gland
+        return self.get_body_part(BODY_PART_PHEROMONE_GLAND)
 
     def put_carry(self, obj, position=None):
         if position is None:
             position = self._get_position()
-        self._carried.remove(obj)
+        self._carried = None
         obj.set_position(position)
         self._context.metas.states.remove(self.get_id(), CARRYING)
 
     def get_carried(self):
-        # TODO: cas ou plusieurs ?
-        return self._carried[0]
+        return self._carried
 
     def carry(self, obj):
-        self._carried.append(obj)
+        self._carried = obj
         self._context.metas.states.add(self.get_id(), CARRYING)
-        #  TODO: On gere une liste de carried (mais pas juste la dessous). Ne gerer qu'un objet carried ?
         self._context.metas.value.set(CARRIED, self.get_id(), obj.get_id())
-        # TODO: pour le moment hardcode
+        # TODO: pour le moment hardcode, a gerer dans AntTakeBrainPart (callback en fct de ce qui est depose)
         if isinstance(obj, Food):
             self.get_brain().switch_to_mode(MOVE_MODE_GOHOME)
-            self.set_last_pheromone_point(PHEROMON_DIR_EXPLO, obj.get_position())
             self.get_movement_pheromone_gland().appose()
 
     def is_carrying(self):
-        if len(self._carried):
+        if self._carried:
             return True
         return False
 
-    # TODO: Est-ce ici que doit etre ce code ?
     def set_position(self, position):
         if self._position is not None and position != self._position:
             self._brain.host_moved()
         super().set_position(position)
         if self.is_carrying():
-            for obj_carried in self._carried:
-                obj_carried.set_position(position)
-
-    # TODO: N'est plus utiliser ! delete it !
-    def get_last_pheromone_point(self, pheromone_name):
-        if pheromone_name in self._last_pheromones_points:
-            return self._last_pheromones_points[pheromone_name]
-        return self._start_position
-
-    def set_last_pheromone_point(self, pheromone_name, position):
-        self._last_pheromones_points[pheromone_name] = position
-        self._context.metas.value.set(LAST_PHERMONES_POINTS, self.get_id(), self._last_pheromones_points)
+            self._carried.set_position(position)
 
     def initialize(self):
         super().initialize()
-        try:
-            self.get_movement_pheromone_gland().appose()
-        except BestPheromoneHere as best_pheromone_here:
-            pass
+        if self.get_movement_pheromone_gland().is_enabled():
+            try:
+                self.get_movement_pheromone_gland().appose()
+            except PheromoneException:
+                pass
 
     def get_colony(self):
         return self.get_collection()

intelligine/synergy/object/ant/Pheromon.py

@@ -1,13 +1,13 @@
 from xyzworld.SynergyObject import SynergyObject as XyzSynergyObject
 
 
+# TODO: ne doit plus exister. Il est la pour le display uniquement. (pheromones ne sont pas des entites)
 class Pheromon(XyzSynergyObject):
 
     def __init__(self, collection, context):
         super().__init__(collection, context)
         self._direction = None
 
-    # TODO: direction ailleurs non ?
     def set_direction(self, direction):
         self._direction = direction
 

intelligine/synergy/object/ant/PheromonExploration.py

@@ -1,5 +1,6 @@
 from intelligine.synergy.object.ant.Pheromon import Pheromon
 
 
+# TODO: ne doit plus exister. Il est la pour le display uniquement. (pheromones ne sont pas des entites)
 class PheromonExploration(Pheromon):
     pass

intelligine/synergy/object/ant/PheromonHome.py

@@ -1,5 +1,6 @@
 from intelligine.synergy.object.ant.Pheromon import Pheromon
 
 
+# TODO: ne doit plus exister. Il est la pour le display uniquement. (pheromones ne sont pas des entites)
 class PheromonHome(Pheromon):
     pass

run.py

@@ -2,15 +2,6 @@ from os import getcwd
 from sys import path as ppath
 ppath.insert(1,getcwd()+'/modules') # TODO: win32 compatibilite (python path)
 
-
-"""
-TODO:
- * Objects "dur" (terre); ne pas les avoir dans les objet a calculer sans cesse (INERTE)
- * SlightyTurn
-"""
-
-
-
 from synergine.core.Core import Core
 from config import config