Working home vector integration!

intelligine/display/Pygame.py

@@ -1,4 +1,5 @@
 from intelligine.core.exceptions import NoMolecule
+from intelligine.synergy.object.ant.Ant import Ant
 from synergine_xyz.display.Pygame import Pygame as XyzPygame
 import pygame
 from intelligine.cst import PHEROMON_DIR_HOME, PHEROMON_DIR_EXPLO, MOLECULES, \
@@ -13,6 +14,7 @@ class Pygame(XyzPygame):
         super().__init__(config, context, synergy_manager)
         self._is_display_molecules = False
         self._is_display_smells = False
+        self._draw_callbacks = []
 
     def receive(self, actions_done):
         super().receive(actions_done)
@@ -75,3 +77,20 @@ class Pygame(XyzPygame):
                 self._is_display_molecules = False
             else:
                 self._is_display_molecules = True
+
+    def draw_object(self, obj, point):
+        super().draw_object(obj, point)
+        # TODO: DEBUG
+        if isinstance(obj, Ant):
+            myfont = pygame.font.SysFont("monospace", 15)
+            label = myfont.render(str(obj.get_id()), 1, (255,255,0))
+            self._draw_callbacks.append(lambda: self._screen.blit(label, point))
+
+    def start_of_cycle(self):
+        super().start_of_cycle()
+        self._draw_callbacks = []
+
+    def end_of_cycle(self):
+        for draw_callback in self._draw_callbacks:
+            draw_callback()
+        super().end_of_cycle()

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

@@ -3,5 +3,11 @@ class BrainPart():
     def __init__(self, host_brain):
         self._host_brain = host_brain
 
+    def get_host_brain(self):
+        return self._host_brain
+
+    def get_host(self):
+        return self.get_host_brain().get_host()
+
     def done(self, obj, context):
         pass

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

@@ -1,7 +1,7 @@
 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
+from intelligine.synergy.event.move.direction import directions_modifiers, get_position_with_direction_decal
 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, \
@@ -147,4 +147,6 @@ class AntMoveBrainPart(MoveBrainPart):
             self._update_exploration_vector()
 
     def _start_new_exploration(self):
-        self._exploration_vector = (0, 0)
+        # On vient de rentrer dans le monde exterieur, le vecteur de départ pointe vers la case précedente
+        # qui est une case dans la forteresse.
+        self._exploration_vector = get_position_with_direction_decal(self.get_host().get_previous_direction())

intelligine/simulation/object/brain/part/move/AntStar/ByPass.py

@@ -0,0 +1,57 @@
+from antstar.GlueWallAntBrain import GlueWallAntBrain
+from intelligine.cst import EXPLORATION_VECTOR, MOVE_BYBASS, MOVE_BYBASS_DISTANCE, MOVE_BYBASS_MEMORY, MOVE_BYBASS_WALL, MOVE_BYBASS_RE_WALKING
+
+
+class ByPass(GlueWallAntBrain):
+
+    def __init__(self, host, home_vector, context, object_id):
+        """
+
+        Note: We broke Liskov principle here.
+
+        :param host:
+        :param home_vector:
+        :param context:
+        :param object_id:
+        :return:
+        """
+        super().__init__(host, home_vector)
+        self._context = context
+        self._object_id = object_id
+        self._memory_since_blocked = context.metas.value.get(MOVE_BYBASS_MEMORY, object_id, allow_empty=True,
+                                                             empty_value=[])
+        self._by_passing = context.metas.value.get(MOVE_BYBASS, object_id, allow_empty=True, empty_value=False)
+        self._distance_when_blocked = context.metas.value.get(MOVE_BYBASS_DISTANCE, object_id, allow_empty=True,
+                                                              empty_value=None)
+        self._current_wall_square_position = context.metas.value.get(MOVE_BYBASS_WALL,
+                                                                     object_id,
+                                                                     allow_empty=True,
+                                                                     empty_value=None)
+        self._is_re_walking = context.metas.value.get(MOVE_BYBASS_RE_WALKING,
+                                                      object_id,
+                                                      allow_empty=True,
+                                                      empty_value=False)
+
+    def _set_home_vector(self, home_vector):
+        super()._set_home_vector(home_vector)
+        self._context.metas.value.set(EXPLORATION_VECTOR, self._object_id, home_vector)
+
+    def _set_memory_since_blocked(self, memory_since_blocked):
+        super()._set_memory_since_blocked(memory_since_blocked)
+        self._context.metas.value.set(MOVE_BYBASS_MEMORY, self._object_id, memory_since_blocked)
+
+    def _set_by_passing(self, by_passing):
+        super()._set_by_passing(by_passing)
+        self._context.metas.value.set(MOVE_BYBASS, self._object_id, by_passing)
+
+    def _set_distance_when_blocked(self, distance):
+        super()._set_distance_when_blocked(distance)
+        self._context.metas.value.set(MOVE_BYBASS_DISTANCE, self._object_id, distance)
+
+    def _set_current_wall_square(self, position_of_square):
+        super()._set_current_wall_square(position_of_square)
+        self._context.metas.value.set(MOVE_BYBASS_WALL, self._object_id, position_of_square)
+
+    def _set_is_re_walking(self, is_re_walking):
+        super()._set_is_re_walking(is_re_walking)
+        self._context.metas.value.set(MOVE_BYBASS_RE_WALKING, self._object_id, is_re_walking)

intelligine/simulation/object/brain/part/move/AntStar/Host.py

@@ -0,0 +1,24 @@
+from intelligine.simulation.object.brain.part.move.AntStar.HostFeeler import HostFeeler
+from synergine_xyz.cst import POSITION
+
+
+class Host:
+
+    def __init__(self, context, object_id):
+        self._context = context
+        self._object_id = object_id
+        self._feeler = HostFeeler(context, object_id)
+        self._moved_to_direction = None
+
+    def get_position(self):
+        current_position = self._context.metas.value.get(POSITION, self._object_id)
+        return current_position[1], current_position[2]
+
+    def get_feeler(self):
+        return self._feeler
+
+    def move_to(self, direction):
+        self._moved_to_direction = direction
+
+    def get_moved_to_direction(self):
+        return self._moved_to_direction

intelligine/simulation/object/brain/part/move/AntStar/HostFeeler.py

@@ -0,0 +1,24 @@
+from intelligine.synergy.event.move.direction import get_position_with_direction_decal
+from synergine_xyz.cst import POSITION
+from synergine_xyz.geometry import distance_from_points
+
+
+class HostFeeler:
+
+    def __init__(self, context, object_id):
+        self._context = context
+        self._object_id = object_id
+        self._current_position = context.metas.value.get(POSITION, self._object_id)
+
+    def direction_is_free(self, direction_of_home):
+        position_will_be = get_position_with_direction_decal(direction_of_home, self._current_position)
+        return self._context.position_is_penetrable(position_will_be)
+
+    def position_is_free(self, position):
+        threed_position = (0, position[0], position[1])
+        points_distance = distance_from_points(threed_position, self._current_position)
+        if points_distance > 1:
+            raise Exception("Can't feel so far (%s to %s: %s)" % (str(self._current_position),
+                                                                  str(position),
+                                                                  str(points_distance)))
+        return self._context.position_is_penetrable(threed_position)