rename arround in around

TODO

    * Changement de mode (explo;go home)
  * Pheromones: Mettre en place un systeme objet qui permet de donner aux Obj leur comportement pheromone. Au lieu de le deduire a la mano (aujourd'hui un MoveAction le fait pour tous, or cela doit dependre de l'obj)
  * Nettoyer le code des pheromones: Refactoriser
- * Mechanisme qui donne les pheromones arround
+ * Mechanisme qui donne les pheromones around
  * Mettre au propre la logique qui dit que l'objet peut etre pose (meme type si larve; zone de depot si Food, etc)
  * Appliquer la disparition des pheromones
 
 
 Future:
  * Chambres
-
+ *
 
 Warning:
  * Lorsque une f trp un objet, le PutableEvent observe chaque tours. C parce que la fourmis rentre dans la COL

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

 
     @staticmethod
     def _get_direction_of_pheromone(context, point, pheromone_type):
-        search_pheromone_in_points = context.get_arround_points_of(point, distance=1)
+        search_pheromone_in_points = context.get_around_points_of(point, distance=1)
         try:
             best_pheromone_direction = DirectionPheromone.get_best_pheromone_direction_in(context,
                                                                                           point,

intelligine/simulation/pheromone/DirectionPheromone.py

 
         point_intensity = pheromone_info[1]
         point_distance = pheromone_info[0]
-        arround_points = context.get_arround_points_of(point)
+        around_points = context.get_around_points_of(point)
 
-        arround_pheromones_points = []
-        for arround_point in arround_points:
-            arround_pheromone_info = context.pheromones().get_info(arround_point,
+        around_pheromones_points = []
+        for around_point in around_points:
+            around_pheromone_info = context.pheromones().get_info(around_point,
                                                                    [PHEROMON_DIRECTION, pheromone_type],
                                                                    allow_empty=True,
                                                                    empty_value={})
-            if arround_pheromone_info and arround_pheromone_info[0] < point_distance:
-                arround_pheromones_points.append((arround_point, arround_pheromone_info))
+            if around_pheromone_info and around_pheromone_info[0] < point_distance:
+                around_pheromones_points.append((around_point, around_pheromone_info))
 
-        if not arround_pheromones_points:
+        if not around_pheromones_points:
             raise NoPheromone()
 
-        shuffle(arround_pheromones_points)
-        arround_pheromones_sorted = sorted(arround_pheromones_points, key=lambda x: x[1][1], reverse=True)
-        max_intensity = arround_pheromones_sorted[0][1][1]
+        shuffle(around_pheromones_points)
+        around_pheromones_sorted = sorted(around_pheromones_points, key=lambda x: x[1][1], reverse=True)
+        max_intensity = around_pheromones_sorted[0][1][1]
 
-        arround_pheromones_max = []
-        for arround_pheromone_sorted in arround_pheromones_sorted:
-            if arround_pheromone_sorted[1][1] == max_intensity:
-                arround_pheromones_max.append(arround_pheromone_sorted)
+        around_pheromones_max = []
+        for around_pheromone_sorted in around_pheromones_sorted:
+            if around_pheromone_sorted[1][1] == max_intensity:
+                around_pheromones_max.append(around_pheromone_sorted)
 
-        arround_pheromones_sorted_by_distance = sorted(arround_pheromones_max, key=lambda x: x[1][0], reverse=False)
+        around_pheromones_sorted_by_distance = sorted(around_pheromones_max, key=lambda x: x[1][0], reverse=False)
 
-        go_to_point = arround_pheromones_sorted_by_distance[0][0]
+        go_to_point = around_pheromones_sorted_by_distance[0][0]
 
         direction_degrees = get_degree_from_north(point, go_to_point)
         direction = get_direction_for_degrees(direction_degrees)
 
     @staticmethod
     def get_best_pheromone_direction_in(context, reference_point, points, pheromone_type):
-        arround_pheromones_points = []
-        for arround_point in points:
-            arround_pheromone_info = context.pheromones().get_info(arround_point,
+        around_pheromones_points = []
+        for around_point in points:
+            around_pheromone_info = context.pheromones().get_info(around_point,
                                                                    [PHEROMON_DIRECTION, pheromone_type],
                                                                    allow_empty=True,
                                                                    empty_value={})
-            if arround_pheromone_info:
-                arround_pheromones_points.append((arround_point, arround_pheromone_info))
+            if around_pheromone_info:
+                around_pheromones_points.append((around_point, around_pheromone_info))
 
-        if not arround_pheromones_points:
+        if not around_pheromones_points:
             raise NoPheromone()
 
-        shuffle(arround_pheromones_points)
-        arround_pheromones_sorted = sorted(arround_pheromones_points, key=lambda x: x[1][1], reverse=True)
-        go_to_point = arround_pheromones_sorted[0][0]
+        shuffle(around_pheromones_points)
+        around_pheromones_sorted = sorted(around_pheromones_points, key=lambda x: x[1][1], reverse=True)
+        go_to_point = around_pheromones_sorted[0][0]
 
         direction_degrees = get_degree_from_north(reference_point, go_to_point)
         direction = get_direction_for_degrees(direction_degrees)

intelligine/synergy/event/transport/PutableAction.py

         obj_transportable_pos = obj_transportable.get_position()
         if self._is_available_position(context, obj_transportable_pos):
             return obj_transportable_pos
-        poss_arround_target = context.get_arround_points_of_point(obj_transportable_pos)
-        poss_arround_obj = context.get_arround_points_of_point(obj.get_position())
+        poss_around_target = context.get_around_points_of_point(obj_transportable_pos)
+        poss_around_obj = context.get_around_points_of_point(obj.get_position())
         # For each position between target and current transporter
-        for pos_arround_target in poss_arround_target:
-            if pos_arround_target in poss_arround_obj:
-                if self._is_available_position(context, pos_arround_target):
-                    return pos_arround_target
+        for pos_around_target in poss_around_target:
+            if pos_around_target in poss_around_obj:
+                if self._is_available_position(context, pos_around_target):
+                    return pos_around_target
         raise ActionAborted()
 
     def _is_available_position(self, context, position):

intelligine/tests/simulation/pheromone/TestDirection.py

         :return:
         """
         self._set_up_pheromones(pheromones, re_init=re_init)
-        around_points = self._context.get_arround_points_of(reference_point)
+        around_points = self._context.get_around_points_of(reference_point)
         direction_tested = DirectionPheromone.get_best_pheromone_direction_in(self._context,
                                                                               reference_point,
                                                                               around_points,