wip on movements

intelligine/cst.py

 MOVE_MODE_NURSE = IncrementedNamedInt.get('intelligine.basebug.move.mode.nurse')
 MOVE_MODE_HOME = IncrementedNamedInt.get('intelligine.basebug.move.mode.home')
 
+MOVE_BYBASS = IncrementedNamedInt.get('intelligine.basebug.move.bypass')
+MOVE_BYBASS_DISTANCE = IncrementedNamedInt.get('intelligine.basebug.move.bypass.distance')
+MOVE_BYBASS_MEMORY = IncrementedNamedInt.get('intelligine.basebug.move.bypass.memory')
+MOVE_BYBASS_WALL = IncrementedNamedInt.get('intelligine.basebug.move.bypass.wall')
+MOVE_BYBASS_RE_WALKING = IncrementedNamedInt.get('intelligine.basebug.move.bypass.re_walking')
+
 TYPE = IncrementedNamedInt.get('intelligine.object.type')
 TYPE_RESOURCE_EXPLOITABLE = IncrementedNamedInt.get('intelligine.object.type.resource.transformable')
+TYPE_RESOURCE_EATABLE = IncrementedNamedInt.get('intelligine.object.type.resource.eatable')
 TYPE_NURSERY = IncrementedNamedInt.get('intelligine.object.type.nursery')
 TYPE_ANT = IncrementedNamedInt.get('intelligine.object.type.ant')
 

intelligine/display/Pygame.py

                 pass # No molecule here
 
             try:
-                point_flavour.get_molecule(category=MOLECULES_DIRECTION, type=PHEROMON_DIR_EXPLO)
+                molecule = point_flavour.get_molecule(category=MOLECULES_DIRECTION, type=PHEROMON_DIR_EXPLO)
                 self.draw_surface(point, molecule_exploration_surface)
+
+                adapted_point = self._get_real_pixel_position_of_position(point)
+                myfont = pygame.font.SysFont("monospace", 15)
+                label = myfont.render(str(molecule.get_distance()), 1, (128,255,128))
+                self._screen.blit(label, adapted_point)
+
             except NoMolecule:
                 pass # No molecule here
 
                 self.draw_surface(point, smell_food_surface)
 
                 adapted_point = self._get_real_pixel_position_of_position(point)
+                adapted_point = (adapted_point[0]+10, adapted_point[1]+10)
                 myfont = pygame.font.SysFont("monospace", 15)
                 label = myfont.render(str(molecule.get_distance()), 1, (255,255,0))
                 self._screen.blit(label, adapted_point)

intelligine/simulation/object/brain/AntBrain.py

         self._movement_mode = mode
         self._update_molecule_gland(mode)
         self._context.metas.value.set(MOVE_MODE, self._host.get_id(), mode)
-        self._distance_from_objective = 0
         self._update_molecule_searching(mode)
 
     def _update_molecule_gland(self, mode):
             molecule_direction_type = PHEROMON_DIR_HOME
         elif mode == MOVE_MODE_GOHOME:
             molecule_direction_type = PHEROMON_DIR_EXPLO
+            self._distance_from_objective = 0
         elif mode == MOVE_MODE_NURSE:
             molecule_direction_type = None
         elif mode == MOVE_MODE_HOME:
-            molecule_direction_type = None
+            molecule_direction_type = PHEROMON_DIR_EXPLO
         else:
             raise NotImplementedError()
 

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

-from intelligine.simulation.molecule.DirectionMolecule import DirectionMolecule
+from intelligine.simulation.object.brain.part.move.AntStar.ByPass import ByPass
+from intelligine.simulation.object.brain.part.move.AntStar.Host import Host
 from intelligine.simulation.object.brain.part.move.MoveBrainPart import MoveBrainPart
-from intelligine.synergy.event.move.direction import directions_modifiers, get_direction_for_degrees
+from intelligine.synergy.event.move.direction import directions_modifiers
 from synergine_xyz.cst import POSITION
 from intelligine.core.exceptions import NoMolecule, NoTypeInMolecule
-from intelligine.cst import MOLECULE_SEARCHING, MOVE_MODE_EXPLO, \
-    MOVE_MODE_HOME, MOVE_MODE, MOVE_MODE_GOHOME, EXPLORATION_VECTOR, POINTS_SMELL, MOLECULES, MOLECULES_DIRECTION, \
-    SMELL_FOOD, SMELL_EGG
+from intelligine.cst import MOLECULE_SEARCHING, MOVE_MODE_EXPLO, MOVE_MODE_HOME, MOVE_MODE, MOVE_MODE_GOHOME, \
+    EXPLORATION_VECTOR, MOLECULES_DIRECTION, SMELL_FOOD, SMELL_EGG
 from intelligine.simulation.molecule.DirectionMolecule import DirectionMolecule
-from synergine_xyz.geometry import get_degree_from_north
 
 
 class AntMoveBrainPart(MoveBrainPart):
         search_molecule_in_points = context.get_around_points_of_point(point)
         try:
             best_molecule_direction = DirectionMolecule.get_best_molecule_direction_in(context,
-                                                                                          point,
-                                                                                          search_molecule_in_points,
-                                                                                          molecule_type)
+                                                                                       point,
+                                                                                       search_molecule_in_points,
+                                                                                       molecule_type)
             return best_molecule_direction
         except NoMolecule as err:
             raise err
 
-    @staticmethod
-    def _get_direction_with_exploration_vector(context, object_id):
-        current_position = context.metas.value.get(POSITION, object_id)
-        exploration_vector = context.metas.value.get(EXPLORATION_VECTOR, object_id)
-        # TODO: inverser (math)
-        home_vector = (exploration_vector[0] - (exploration_vector[0]*2),
-                       exploration_vector[1] - (exploration_vector[1]*2))
-        home_position = (0, current_position[1]+home_vector[0], current_position[2]+home_vector[1])
-        degree_from_north = get_degree_from_north(current_position, home_position)
-        direction_for_home_vector = get_direction_for_degrees(degree_from_north)
+    @classmethod
+    def _get_direction_with_exploration_vector(cls, context, object_id):
+        ant_star = cls._get_by_pass_brain(context, object_id)
+        ant_star.advance()
+        ant_star.has_moved()
+        return ant_star.get_host().get_moved_to_direction()
 
-        return direction_for_home_vector
+    @classmethod
+    def _get_by_pass_brain(cls, context, object_id):
+        # We use an adaptation of AntStar
+        exploration_vector = context.metas.value.get(EXPLORATION_VECTOR, object_id)
+        home_vector = (-exploration_vector[0], -exploration_vector[1])
+        ant_host = Host(context, object_id)
+        return ByPass(ant_host, home_vector, context, object_id)
 
     # TODO: obj pas necessaire, il est dans _host
     def done(self, obj, context):
 
         if movement_mode == MOVE_MODE_GOHOME and self._on_home_smell(context, obj.get_id()):
             self._host_brain.switch_to_mode(MOVE_MODE_HOME)
+            ant_star = self._get_by_pass_brain(context, obj.get_id())
+            ant_star.erase()
             # TODO: on change les molecule recherché (Food => SmellFood, definis dans Take, en fct de ce qui est take)
 
         elif movement_mode == MOVE_MODE_HOME and not self._on_home_smell(context, obj.get_id()):
             self._host_brain.switch_to_mode(MOVE_MODE_EXPLO)
             self._start_new_exploration()
 
+        elif movement_mode == MOVE_MODE_EXPLO and self._on_home_smell(context, obj.get_id()):
+            self._start_new_exploration()  # TODO: rename en reinit_explo
+
         # TODO: sitch explo si rien a faire (rien a poser par exemple) et HOME
 
         # TODO: Poser sur StockedFood
         self._set_exploration_vector((self._exploration_vector[0] + just_move_vector[1],
                                       self._exploration_vector[1] + just_move_vector[2]))
 
-
     def _apply_context(self, obj, context):
         movement_mode = self._host_brain.get_movement_mode()
         if movement_mode == MOVE_MODE_EXPLO or movement_mode == MOVE_MODE_GOHOME:

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

 from intelligine.core.exceptions import CantFindWhereToPut
-from intelligine.cst import MOVE_MODE_EXPLO, TYPE_RESOURCE_EXPLOITABLE, CARRIED
+from intelligine.cst import MOVE_MODE_EXPLO, TYPE_RESOURCE_EXPLOITABLE, CARRIED, MOVE_MODE_NURSE, TYPE_NURSERY, \
+    MOVE_MODE_HOME, TYPE_RESOURCE_EATABLE, TYPE, MOVE_MODE, MOVE_MODE_GOHOME
 from intelligine.simulation.object.brain.part.transport.TransportBrainPart import TransportBrainPart
 from intelligine.synergy.object.Food import Food
 from synergine_xyz.cst import POSITION, POSITIONS
 
     # TODO: methode __nit_ pour la classe ?
     _mode_matches = {
-        MOVE_MODE_EXPLO: [TYPE_RESOURCE_EXPLOITABLE],
+        MOVE_MODE_NURSE: [TYPE_NURSERY],
+        MOVE_MODE_HOME: [TYPE_RESOURCE_EATABLE],
+        MOVE_MODE_GOHOME: []
+    }
+
+    _types_matches = {
+        TYPE_RESOURCE_EXPLOITABLE: [TYPE_RESOURCE_EATABLE]
     }
 
     @classmethod
     def can_put(cls, context, object_id, object_near_id):
-        object_carried_id = context.metas.value.get(CARRIED, object_id)
-        #  Pour le moment on considere qu'un objet peut-etre depose a cote d'un objet qui a un type identique
-        return cls._objects_have_same_type(context, object_carried_id, object_near_id)
+        # Si l'objet à coté fait partie des objets concernés par le mode du porteur
+        if cls._match_with_mode(context, object_id, object_near_id):
+            # Et si les objet sont rangeable enssemble:
+            object_carried_id = context.metas.value.get(CARRIED, object_id)
+            return cls._objects_types_match(context, object_carried_id, object_near_id)
+        return False
 
     @classmethod
     def get_put_position(cls, context, object_id, object_near_id):
     def done(self, obj, puted_object, context):
         # TODO: Il faut refact/logique qqpart pour ca !! Genre Brain.done(PUT, ??)
         if isinstance(puted_object, Food):
+            # TODO: Quel mode ? On vient de poser (ps forcement dans la colonie) cls._mode_swicth ?
             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/TransportBrainPart.py

 class TransportBrainPart(BrainPart):
 
     _mode_matches = {}
+    _types_matches = {}
 
     @classmethod
     def _match_with_mode(cls, context, object_id, concerned_object_id):
         return False
 
     @classmethod
-    def _objects_have_same_type(cls, context, object_carried_id, object_to_put_id):
-        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):
-                return True
-        return False
+    def _objects_types_match(cls, context, object_a_id, object_b_id):
+        """
+
+        Retourne vrai si un des type de l'objet b se trouve dans la lise de type définis dans _types_matches pour
+        l'un des types de l'objet a.
+
+        :param context:
+        :param object_a_id:
+        :param object_b_id:
+        :return: bool
+        """
+        object_a_types = context.metas.list.get(TYPE, object_a_id)
+        object_b_types = context.metas.list.get(TYPE, object_b_id)
+
+        for object_a_type in object_a_types:
+            if object_a_type in cls._types_matches:
+                wanted_types = cls._types_matches[object_a_type]
+                for object_b_type in object_b_types:
+                    if object_b_type in wanted_types:
+                        return True
+
+        return False

intelligine/synergy/event/move/direction.py

 directions_under_level = (1, 2, 3, 4, 5, 6, 7, 8, 9)
 directions_same_level = (10, 11, 12, 13, 15, 16, 17, 18)
 directions_upper_level = (19, 20, 21, 22, 23, 24, 25, 26, 27)
+
+directions_by_levels = (directions_under_level, directions_same_level, directions_upper_level)
+
 directions_modifiers = {
     # (z, x, y)
     1: (-1, -1, -1),

intelligine/synergy/object/StockedFood.py

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

requirements.txt

 synergine>=0.0.1
 synergine_xyz>=0.0.1
+git+https://github.com/buxx/AntStar.git

tests_requirements.txt

 git+http://github.com/buxx/synergine.git
 git+http://github.com/buxx/synergine_xyz.git
+git+https://github.com/buxx/AntStar.git