update code of egg missions

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 !
 
 Future:
  * Chambres

config.py

 from intelligine.synergy.Simulation import Simulation
 from intelligine.display.Pygame import Pygame
 from intelligine.display.pygame.visualisation import visualisation as pygame_visualisation
-#from intelligine.sandbox.colored.colors_colonys import collections
+from intelligine.sandbox.colored.colors_colonys import collections
 # TODO: influencer avec argument python
-from intelligine.sandbox.exploration.collections import collections
+#from intelligine.sandbox.exploration.collections import collections
 
 """
  TODO:

intelligine/core/exceptions.py

     def get_best_distance(self):
         return self._best_distance
 
+class PheromoneGlandDisabled(PheromoneException):
+    pass
+
 
 class BrainException(Exception):
     pass

intelligine/cst.py

 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')
+TYPE_NURSERY = IncrementedNamedInt.get('intelligine.object.type.nursery')
 
 LAST_PHERMONES_POINTS = IncrementedNamedInt.get('intelligine.last_pheromones_points')
 
 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')
 

intelligine/sandbox/colored/RedColonyConfiguration.py

 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

 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
             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/part/move/AntMoveBrainPart.py

 
     @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

 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 = {
         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

 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 !
     _mode_matches = {
         MOVE_MODE_EXPLO: [TYPE_RESOURCE_TRANSFORMABLE],
+        MOVE_MODE_NURSE: [TYPE_NURSERY]
     }
 
     @classmethod

intelligine/simulation/object/pheromone/PheromoneGland.py

-from intelligine.core.exceptions import BestPheromoneHere
+from intelligine.core.exceptions import BestPheromoneHere, PheromoneGlandDisabled
 from intelligine.simulation.pheromone.DirectionPheromone import DirectionPheromone
 
 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
         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/synergy/object/Egg.py

 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

-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, \
 
     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()