remove move mode constants

intelligine/cst.py

 MOLECULES = IncrementedNamedInt.get('intelligine.molecules')
 
 # 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')
-MOVE_MODE_HOME = IncrementedNamedInt.get('intelligine.basebug.move.mode.home')
+MODE = IncrementedNamedInt.get('intelligine.basebug.move')
+MODE_EXPLO = IncrementedNamedInt.get('intelligine.basebug.move.explo')
+MODE_GOHOME = IncrementedNamedInt.get('intelligine.basebug.move.gohome')
+MODE_NURSE = IncrementedNamedInt.get('intelligine.basebug.move.nurse')
+MODE_HOME = IncrementedNamedInt.get('intelligine.basebug.move.home')
 
 MOVE_BYBASS = IncrementedNamedInt.get('intelligine.basebug.move.bypass')
 MOVE_BYBASS_DISTANCE = IncrementedNamedInt.get('intelligine.basebug.move.bypass.distance')

intelligine/simulation/object/brain/AntBrain.py

 from intelligine.simulation.object.brain.Brain import Brain
 from intelligine.simulation.object.brain.part.attack.AttackBrainPart import AttackBrainPart
 from intelligine.simulation.object.brain.part.move.AntMoveBrainPart import AntMoveBrainPart
-from intelligine.cst import MOVE_MODE, MOVE_MODE_EXPLO, MOVE_MODE_GOHOME, PHEROMON_DIR_EXPLO, \
-    BRAIN_PART_TAKE, BRAIN_PART_PUT, MOVE_MODE_NURSE, PHEROMON_DIR_NONE, BRAIN_PART_ATTACK, MOVE_MODE_HOME, \
+from intelligine.cst import MODE, MODE_EXPLO, MODE_GOHOME, PHEROMON_DIR_EXPLO, \
+    BRAIN_PART_TAKE, BRAIN_PART_PUT, MODE_NURSE, PHEROMON_DIR_NONE, BRAIN_PART_ATTACK, MODE_HOME, \
     SMELL_FOOD, SMELL_EGG
 from intelligine.cst import MOLECULE_SEARCHING
 from intelligine.cst import BRAIN_PART_MOVE
 
     def __init__(self, context, host):
         super().__init__(context, host)
-        self._movement_mode = MOVE_MODE_HOME
+        self._movement_mode = MODE_HOME
         self._distance_from_objective = 0  # TODO rename: distance_since_objective
         self._molecule_searching = PHEROMON_DIR_EXPLO
 
     def switch_to_mode(self, mode):
         self._movement_mode = mode
         self._update_molecule_gland(mode)
-        self._context.metas.value.set(MOVE_MODE, self._host.get_id(), mode)
+        self._context.metas.value.set(MODE, self._host.get_id(), mode)
         self._update_molecule_searching(mode)
 
     def _update_molecule_gland(self, mode):
-        if mode == MOVE_MODE_EXPLO:
+        if mode == MODE_EXPLO:
             molecule_direction_type = None
-        elif mode == MOVE_MODE_GOHOME:
+        elif mode == MODE_GOHOME:
             molecule_direction_type = PHEROMON_DIR_EXPLO
             self._distance_from_objective = 0
-        elif mode == MOVE_MODE_NURSE:
+        elif mode == MODE_NURSE:
             molecule_direction_type = None
-        elif mode == MOVE_MODE_HOME:
+        elif mode == MODE_HOME:
             molecule_direction_type = PHEROMON_DIR_EXPLO
         else:
             raise NotImplementedError()
             self._host.get_movement_molecule_gland().disable()
 
     def _update_molecule_searching(self, mode):
-        if mode == MOVE_MODE_EXPLO:
+        if mode == MODE_EXPLO:
             molecule_searching = PHEROMON_DIR_EXPLO
-        elif mode == MOVE_MODE_GOHOME:
+        elif mode == MODE_GOHOME:
             molecule_searching = PHEROMON_DIR_NONE
-        elif mode == MOVE_MODE_NURSE:
+        elif mode == MODE_NURSE:
             molecule_searching = PHEROMON_DIR_NONE
-        elif mode == MOVE_MODE_HOME:
+        elif mode == MODE_HOME:
             # TODO: Ca depend de ce que fait la fourmis, si s'occupe des oeufs, etc
             molecule_searching = self.get_part(BRAIN_PART_TAKE).get_smell_target()
         else:

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

 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
-from intelligine.cst import MOLECULE_SEARCHING, MOVE_MODE_EXPLO, MOVE_MODE_HOME, MOVE_MODE, MOVE_MODE_GOHOME, \
+from intelligine.cst import MOLECULE_SEARCHING, MODE_EXPLO, MODE_HOME, MODE, MODE_GOHOME, \
     EXPLORATION_VECTOR, MOLECULES_DIRECTION
 from intelligine.simulation.molecule.DirectionMolecule import DirectionMolecule
 
 
     @classmethod
     def get_direction(cls, context, object_id):
-        move_mode = context.metas.value.get(MOVE_MODE, object_id)
-        if move_mode == MOVE_MODE_GOHOME:
+        move_mode = context.metas.value.get(MODE, object_id)
+        if move_mode == MODE_GOHOME:
             return cls._get_direction_with_exploration_vector(context, object_id)
         else:
             try:
         """
         movement_mode = self._host_brain.get_movement_mode()
 
-        if movement_mode == MOVE_MODE_GOHOME and self._on_home_smell(self._context, self._host.get_id()):
+        if movement_mode == MODE_GOHOME and self._on_home_smell(self._context, self._host.get_id()):
             self._arrived_at_home()
 
-        elif movement_mode == MOVE_MODE_HOME and not self._on_home_smell(self._context, self._host.get_id()):
+        elif movement_mode == MODE_HOME and not self._on_home_smell(self._context, self._host.get_id()):
             self._start_new_exploration()
 
-        elif movement_mode == MOVE_MODE_EXPLO and self._on_home_smell(self._context, self._host.get_id()):
+        elif movement_mode == MODE_EXPLO and self._on_home_smell(self._context, self._host.get_id()):
             self._init_exploration_vector()
 
         # TODO: sitch explo si rien a faire (rien a poser par exemple) et HOME
 
     def _apply_context(self):
         movement_mode = self._host_brain.get_movement_mode()
-        if movement_mode == MOVE_MODE_EXPLO or movement_mode == MOVE_MODE_GOHOME:
+        if movement_mode == MODE_EXPLO or movement_mode == MODE_GOHOME:
             self._update_exploration_vector()
 
     def _start_new_exploration(self):
         self._reinit_exploration_vector()
-        self._host_brain.switch_to_mode(MOVE_MODE_EXPLO)
+        self._host_brain.switch_to_mode(MODE_EXPLO)
 
     def _init_exploration_vector(self):
         # On vient de rentrer dans le monde exterieur, le vecteur de départ pointe vers la case précedente
         self._set_exploration_vector(init_exploration_vector)
 
     def _arrived_at_home(self):
-        self._host_brain.switch_to_mode(MOVE_MODE_HOME)
+        self._host_brain.switch_to_mode(MODE_HOME)
         ant_star = self._get_by_pass_brain(self._context, self._host.get_id())
         ant_star.erase()

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, MOVE_MODE_NURSE, TYPE_NURSERY, \
-    MOVE_MODE_HOME, TYPE_RESOURCE_EATABLE, TYPE, MOVE_MODE, MOVE_MODE_GOHOME
+from intelligine.cst import MODE_EXPLO, TYPE_RESOURCE_EXPLOITABLE, CARRIED, MODE_NURSE, TYPE_NURSERY, \
+    MODE_HOME, TYPE_RESOURCE_EATABLE, TYPE, MODE, 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_NURSE: [TYPE_NURSERY],
-        MOVE_MODE_HOME: [TYPE_RESOURCE_EATABLE],
-        MOVE_MODE_GOHOME: []
+        MODE_NURSE: [TYPE_NURSERY],
+        MODE_HOME: [TYPE_RESOURCE_EATABLE],
+        MODE_GOHOME: []
     }
 
     _types_matches = {
         # 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 ?
-            self._host.get_brain().switch_to_mode(MOVE_MODE_EXPLO)
+            self._host.get_brain().switch_to_mode(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, TYPE_RESOURCE_EXPLOITABLE, \
-    MOVE_MODE_GOHOME, MOVE_MODE_NURSE, TYPE_NURSERY
+from intelligine.cst import MODE_EXPLO, TYPE_RESOURCE_EXPLOITABLE, \
+    MODE_GOHOME, MODE_NURSE, TYPE_NURSERY
 
 
 class AntTakeBrainPart(TakeBrainPart):
 
     # TODO: methode __init_ pour la classe ? Pour surcharger ici.
     _mode_matches = {
-        MOVE_MODE_EXPLO: [TYPE_RESOURCE_EXPLOITABLE],
-        MOVE_MODE_NURSE: [TYPE_NURSERY],
-        MOVE_MODE_GOHOME: []
+        MODE_EXPLO: [TYPE_RESOURCE_EXPLOITABLE],
+        MODE_NURSE: [TYPE_NURSERY],
+        MODE_GOHOME: []
     }
 
     def __init__(self, host_brain):
         # TODO: qqch plus generique ... (attention aux eggs)
         if isinstance(take_object, Resource):
             self._smell_target = self._host_brain.get_smell_for_object_taken(take_object)
-            self._host.get_brain().switch_to_mode(MOVE_MODE_GOHOME)
+            self._host.get_brain().switch_to_mode(MODE_GOHOME)
             self._host.get_movement_molecule_gland().appose()

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

-from intelligine.cst import MOVE_MODE, TYPE
+from intelligine.cst import MODE, TYPE
 from intelligine.simulation.object.brain.part.BrainPart import BrainPart
 
 
 
     @classmethod
     def _match_with_mode(cls, context, object_id, concerned_object_id):
-        move_mode = context.metas.value.get(MOVE_MODE, object_id)
+        move_mode = context.metas.value.get(MODE, object_id)
         for takable_type in cls._mode_matches[move_mode]:
             if context.metas.list.have(TYPE, concerned_object_id, takable_type, allow_empty=True):
                 return True

intelligine/synergy/object/ant/Ant.py

 from intelligine.core.exceptions import MoleculeException
 from intelligine.synergy.object.Bug import Bug
 from intelligine.cst import CARRYING, TRANSPORTER, ATTACKER, COL_TRANSPORTER, COL_TRANSPORTER_NOT_CARRYING, \
-    COL_FIGHTER, MOVE_MODE_EXPLO, MOVE_MODE_GOHOME, BODY_PART_PHEROMONE_GLAND, TYPE, TYPE_ANT, \
-    COL_TRANSPORTER_CARRYING, MOVE_MODE_NURSE, MOVE_MODE_HOME
+    COL_FIGHTER, MODE_EXPLO, MODE_GOHOME, BODY_PART_PHEROMONE_GLAND, TYPE, TYPE_ANT, \
+    COL_TRANSPORTER_CARRYING, MODE_NURSE, MODE_HOME
 from intelligine.synergy.object.Food import Food
 from intelligine.simulation.object.molecule.MovementMoleculeGland import MovementMoleculeGland
 from intelligine.simulation.object.brain.AntBrain import AntBrain
                                                            COL_TRANSPORTER_NOT_CARRYING,
                                                            COL_FIGHTER])
         self._carried = None
-        self._brain.switch_to_mode(MOVE_MODE_EXPLO)
+        self._brain.switch_to_mode(MODE_EXPLO)
         context.metas.list.add(TYPE, self.get_id(), TYPE_ANT)
 
     def die(self):
         obj.set_is_carried(True, self)
         # TODO: pour le moment hardcode, a gerer dans AntTakeBrainPart (callback en fct de ce qui est depose)
         if isinstance(obj, Food):
-            self.get_brain().switch_to_mode(MOVE_MODE_GOHOME)
+            self.get_brain().switch_to_mode(MODE_GOHOME)
             self.get_movement_molecule_gland().appose()
 
     def is_carrying(self):

intelligine/tests/simulation/mode/TestChangeMode.py

 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, MOVE_MODE_HOME, PHEROMON_DIR_NONE
+from intelligine.cst import MODE_EXPLO, MODE_GOHOME, MODE, MODE_HOME, PHEROMON_DIR_NONE
 from intelligine.cst import PHEROMON_DIR_EXPLO
 
 
 
     @staticmethod
     def _force_move(self_move_action, object_id, context):
-        object_movement_mode = context.metas.value.get(MOVE_MODE, object_id)
-        if object_movement_mode == MOVE_MODE_GOHOME or object_movement_mode == MOVE_MODE_HOME:
+        object_movement_mode = context.metas.value.get(MODE, object_id)
+        if object_movement_mode == MODE_GOHOME or object_movement_mode == MODE_HOME:
             return SOUTH
         return NORTH
 
     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.assertEquals(MODE_EXPLO, self.ant.get_brain().get_movement_mode())
         self.assertFalse(self.ant.is_carrying())
 
         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.assertEquals(MODE_EXPLO, self.ant.get_brain().get_movement_mode())
         self.assertFalse(self.ant.is_carrying())
 
         # Ant has take Food piece
         molecule = self.ant.get_movement_molecule_gland().get_molecule()
         # Now it appose exploration molecule
         self.assertEquals((PHEROMON_DIR_EXPLO, 0), (molecule.get_type(), molecule.get_distance()))
-        self.assertEquals(MOVE_MODE_GOHOME, self.ant.get_brain().get_movement_mode())
+        self.assertEquals(MODE_GOHOME, self.ant.get_brain().get_movement_mode())
         self.assertEquals(PHEROMON_DIR_EXPLO, self.ant.get_movement_molecule_gland().get_molecule_type())
 
         self._run_and_get_core(32)
         self.assertEquals((0, 0, -6), self.ant.get_position())
         self.assertTrue(self.ant.is_carrying())
-        self.assertEquals(MOVE_MODE_HOME, self.ant.get_brain().get_movement_mode())
+        self.assertEquals(MODE_HOME, self.ant.get_brain().get_movement_mode())
 
         self._run_and_get_core(33)
         self.assertEquals((0, 0, -5), self.ant.get_position())
         self.assertTrue(self.ant.is_carrying())
-        self.assertEquals(MOVE_MODE_HOME, self.ant.get_brain().get_movement_mode())
+        self.assertEquals(MODE_HOME, self.ant.get_brain().get_movement_mode())
 
         self._run_and_get_core(34)
         self.assertEquals((0, 0, -4), self.ant.get_position())
-        self.assertEquals(MOVE_MODE_HOME, self.ant.get_brain().get_movement_mode())
+        self.assertEquals(MODE_HOME, self.ant.get_brain().get_movement_mode())
 
         self._run_and_get_core(37)
         self.assertEquals((0, 0, -1), self.ant.get_position())