Test switch to exploration when ant is on colony point

intelligine/synergy/Colony.py

@@ -8,8 +8,11 @@ from intelligine.synergy.event.CycleAction import CycleAction
 
 class Colony(SynergyCollection):
 
-
     def __init__(self, configuration):
         super().__init__(configuration)
         self._actions = [MoveAction, NearAttackableAction, TakeableAction, PutableAction,
-                         CycleAction]
+                         CycleAction]
+        self._start_position = configuration.get_start_position()
+
+    def get_start_position(self):
+        return self._start_position

intelligine/synergy/ColonyConfiguration.py

@@ -10,6 +10,10 @@ class ColonyConfiguration(Configuration):
     _ant_class = Ant
     _ant_count = 50
 
+    @classmethod
+    def get_start_position(cls):
+        return cls._start_position
+
     def get_start_objects(self, collection, context):
       context.metas.value.set(POSITION, collection.get_id(), self._start_position)
 

intelligine/synergy/event/move/MoveAction.py

@@ -120,7 +120,7 @@ class MoveAction(Action):
             self._appose_pheromone(obj, context)
 
             # TEST: le temps de tout tester
-            if self._move_to_point == (0, 5, 5) and obj.is_carrying():
+            if self._move_to_point == obj.get_colony().get_start_position() and obj.is_carrying():
                 obj_transported = obj.get_carried()
                 obj_transported.set_carried_by(None)
                 obj.put_carry(obj_transported, (-1, 0, 0))

intelligine/synergy/object/ant/Ant.py

@@ -76,4 +76,7 @@ class Ant(Bug):
                                       self.get_position(),
                                       self.get_movement_pheromone_gland().get_movement_molecules())
         except BestPheromoneHere as best_pheromone_here:
-            pass
+            pass
+
+    def get_colony(self):
+        return self.get_collection()

intelligine/tests/simulation/mode/Base.py

@@ -0,0 +1,5 @@
+from synergine.test.TestSimulation import TestSimulation as BaseTestSimulation
+
+
+class Base(BaseTestSimulation):
+    pass

intelligine/tests/simulation/mode/TestChangeMode.py

@@ -0,0 +1,128 @@
+from os import getcwd
+from sys import path as ppath
+from intelligine.core.exceptions import NoPheromone
+
+ppath.insert(1,getcwd()+'/modules')
+
+
+from intelligine.synergy.object.Food import Food
+from intelligine.tests.simulation.mode.Base import Base
+from intelligine.synergy.Colony import Colony
+from intelligine.synergy.Simulation import Simulation
+from intelligine.synergy.ColonyConfiguration import ColonyConfiguration
+from intelligine.synergy.event.move.MoveAction import MoveAction
+from intelligine.synergy.event.move.direction import NORTH, SOUTH
+from intelligine.tests.src.event.MoveAction import MoveAction as TestMoveAction
+from synergine.synergy.collection.SynergyCollection import SynergyCollection
+from synergine.synergy.collection.Configuration import Configuration
+from intelligine.core.Context import Context
+from intelligine.cst import MOVE_MODE_EXPLO, MOVE_MODE_GOHOME, MOVE_MODE
+from intelligine.cst import PHEROMON_DIR_HOME, PHEROMON_DIR_EXPLO
+
+
+class TestChangeMode(Base):
+
+    def __init__(self, methodName='runTest'):
+        super().__init__(methodName)
+        self.ant = None
+        self.food = None
+        self._force_move = self._force_move
+
+    @staticmethod
+    def _force_move(self_move_action, context, object_point):
+        object_movement_mode = context.metas.value.get(MOVE_MODE, self_move_action._object_id)
+        if object_movement_mode == MOVE_MODE_GOHOME:
+            return SOUTH
+        return NORTH
+
+    def _get_set_up_simulation(self):
+        return Simulation([self._get_colony(), self._get_foods()])
+
+    def _get_colony(self):
+        test_case = self
+        class TestColony(Colony):
+            def __init__(self, configuration):
+                super().__init__(configuration)
+                self._actions.remove(MoveAction)
+                TestMoveAction.force_direction = test_case._force_move
+                self._actions.append(TestMoveAction)
+        return TestColony(self._get_colony_configuration())
+
+    def _get_colony_configuration(self):
+        test_case = self
+        class TestColonyConfiguration(ColonyConfiguration):
+            _start_position = (0, 0, 0)
+            _ant_count = 1
+            def get_start_objects(self, collection, context):
+                ants = super().get_start_objects(collection, context)
+                test_case.ant = ants[0]
+                return ants
+        return TestColonyConfiguration()
+
+    def _get_foods(self):
+        class Foods(SynergyCollection):
+            pass
+        return Foods(self._get_food_configuration())
+
+    def _get_food_configuration(self):
+        test_case = self
+        class FoodConfiguration(Configuration):
+            def get_start_objects(self, collection, context):
+                food = Food(collection, context)
+                food.set_position((0, 0, -3))
+                test_case.food = food
+                return [food]
+        return FoodConfiguration()
+
+    def _get_core_configuration(self, cycles, main_process=True):
+        config = super()._get_core_configuration(cycles, main_process)
+        config.update({
+            'app': {
+                'classes': {
+                    'Context': Context
+                }
+            }
+        })
+        return config
+
+    def test_from_exploration_to_go_home(self):
+        self._run_and_get_core(0)
+        self.assertEquals((0, 0, 0), self.ant.get_position())
+        self.assertEquals(MOVE_MODE_EXPLO, self.ant.get_brain().get_movement_mode())
+
+        self._run_and_get_core(1)
+        self.assertEquals((0, 0, -1), self.ant.get_position())
+        self.assertEquals(MOVE_MODE_EXPLO, self.ant.get_brain().get_movement_mode())
+
+        self._run_and_get_core(2)
+        self.assertEquals((0, 0, -2), self.ant.get_position())
+        self.assertEquals((PHEROMON_DIR_HOME, 2),
+                          self.ant.get_movement_pheromone_gland().get_movement_molecules())
+
+        # Ant has take Food piece
+        self._run_and_get_core(3)
+        self.assertEquals((0, 0, -3), self.ant.get_position())
+
+        self.assertTrue(self.ant.is_carrying())
+        self.assertIsNotNone(self.ant.get_carried())
+        self.assertEquals(self.food.__class__, self.ant.get_carried().__class__)
+        self.assertEquals(MOVE_MODE_GOHOME, self.ant.get_brain().get_movement_mode())
+        # Now it appose exploration pheromone
+        self.assertEquals((PHEROMON_DIR_EXPLO, 0),
+                          self.ant.get_movement_pheromone_gland().get_movement_molecules())
+
+        self._run_and_get_core(4)
+        self.assertEquals((0, 0, -2), self.ant.get_position())
+
+        self._run_and_get_core(5)
+        self.assertEquals((0, 0, -1), self.ant.get_position())
+
+        self._run_and_get_core(6)
+        self.assertEquals((0, 0, 0), self.ant.get_position())
+
+        # Ant has put his food piece
+        self._run_and_get_core(7)
+        self.assertEquals((0, 0, -1), self.ant.get_position())
+
+        self.assertFalse(self.ant.is_carrying())
+        self.assertEquals(MOVE_MODE_EXPLO, self.ant.get_brain().get_movement_mode())

intelligine/tests/simulation/pheromone/TestDirection.py

@@ -2,8 +2,7 @@ from os import getcwd
 from sys import path as ppath
 from intelligine.core.exceptions import NoPheromone
 
-ppath.insert(1,getcwd()+'/modules') # TODO: win32 compatibilite (python path)
-# TODO: load et launch des tests auto (avec bootstrap contenant ci dessus)
+ppath.insert(1,getcwd()+'/modules')
 
 from intelligine.tests.simulation.pheromone.Base import Base
 from intelligine.simulation.pheromone.DirectionPheromone import DirectionPheromone

intelligine/tests/src/event/MoveAction.py

@@ -0,0 +1,13 @@
+from intelligine.synergy.event.move.MoveAction import MoveAction as BaseMoveAction
+from intelligine.synergy.event.move.direction import NORTH
+
+
+class MoveAction(BaseMoveAction):
+
+    force_direction = lambda self, context, object_point: NORTH
+
+    def _get_direction_with_pheromones(self, context, object_point):
+        return self.force_direction(context, object_point)
+
+    # def _get_random_direction(self, context):
+    #     return self.force_direction