add Tank

opencombat/gui/actor.py

         subject: Subject,
     ) -> None:
         super().__init__('actors/man.png', subject=subject, config=config)
+
+
+class HeavyVehicle(Actor):
+    animation_image_paths = {
+        ANIMATION_WALK: [
+            'actors/tank1.png',
+        ],
+        ANIMATION_CRAWL: [
+            'actors/tank1.png',
+        ]
+    }
+
+    def __init__(
+        self,
+        config: Config,
+        subject: Subject,
+    ) -> None:
+        super().__init__('actors/tank1.png', subject=subject, config=config)

opencombat/gui/base.py

 from opencombat.simulation.event import NoLongerVisibleOpponent
 from opencombat.simulation.event import FireEvent
 from opencombat.simulation.event import DieEvent
-from opencombat.simulation.subject import TileSubject as ManSubject
+from opencombat.simulation.subject import ManSubject
+from opencombat.simulation.subject import TankSubject
 from opencombat.gui.actor import Man as ManActor
+from opencombat.gui.actor import HeavyVehicle as HeavyVehicleActor
 
 
 class EditLayer(BaseEditLayer):
             self.subject_die,
         )
 
-        # configs / resources
-        self.move_duration_ref = float(self.config.resolve(
-            'game.move.walk_ref_time',
-        ))
-        self.move_fast_duration_ref = float(self.config.resolve(
-            'game.move.run_ref_time',
-        ))
-        self.move_crawl_duration_ref = float(self.config.resolve(
-            'game.move.crawl_ref_time',
-        ))
         self.dead_soldier_image = pyglet.resource.image(self.graphic_path_manager.path(
             'actors/man_d1.png',
         ))
             ManSubject,
             SubjectMapper(self.config, ManActor),
         )
+        self.subject_mapper_factory.register_mapper(
+            TankSubject,
+            SubjectMapper(self.config, HeavyVehicleActor),
+        )
 
     def before_run(self) -> None:
         from opencombat.gui.move import MoveActorInteraction
         if event.gui_action == UserAction.ORDER_MOVE:
             animation = ANIMATION_WALK
             cycle_duration = 2
-            move_duration = self.move_duration_ref
         elif event.gui_action == UserAction.ORDER_MOVE_FAST:
             animation = ANIMATION_WALK
             cycle_duration = 0.5
-            move_duration = self.move_fast_duration_ref
         elif event.gui_action == UserAction.ORDER_MOVE_CRAWL:
             animation = ANIMATION_CRAWL
             cycle_duration = 2
-            move_duration = self.move_crawl_duration_ref
         else:
-            raise NotImplementedError()
+            raise NotImplementedError(
+                'Gui action {} unknown'.format(event.gui_action)
+            )
 
+        move_duration = event.move_duration
         move_action = MoveTo(new_world_position, move_duration)
         actor.do(move_action)
         actor.do(Animate(animation, duration=move_duration, cycle_duration=cycle_duration))

opencombat/simulation/behaviour.py

 
 
 class MoveToBehaviour(BaseMoveToBehaviour):
-    def __init__(
-        self,
-        config: Config,
-        simulation: Simulation,
-        subject: Subject,
-    ) -> None:
-        super().__init__(config, simulation, subject)
-        self._walk_duration = float(self.config.resolve('game.move.walk_ref_time'))
-        self._run_duration = float(self.config.resolve('game.move.run_ref_time'))
-        self._crawl_duration = float(self.config.resolve('game.move.crawl_ref_time'))
-
     def is_terminated(self) -> bool:
         return COLLECTION_ALIVE not in self.subject.collections
 
     def _can_move_to_next_step(self, move_to_data: dict) -> bool:
         if move_to_data['gui_action'] == UserAction.ORDER_MOVE:
-            return time.time() - move_to_data['last_intention_time'] >= self._walk_duration
+            return time.time() - move_to_data['last_intention_time'] >= \
+                   self.subject.walk_duration
+        if move_to_data['gui_action'] == UserAction.ORDER_MOVE_FAST:
+            return time.time() - move_to_data['last_intention_time'] >= \
+                   self.subject.run_duration
+        if move_to_data['gui_action'] == UserAction.ORDER_MOVE_CRAWL:
+            return time.time() - move_to_data['last_intention_time'] >= \
+                   self.subject.crawl_duration
+
+        raise NotImplementedError(
+            'Gui action {} unknown'.format(move_to_data['gui_action'])
+        )
+
+    def get_move_duration(self, move_to_data: dict) -> float:
+        if move_to_data['gui_action'] == UserAction.ORDER_MOVE:
+            return self.subject.walk_duration
         if move_to_data['gui_action'] == UserAction.ORDER_MOVE_FAST:
-            return time.time() - move_to_data['last_intention_time'] >= self._run_duration
+            return self.subject.run_duration
         if move_to_data['gui_action'] == UserAction.ORDER_MOVE_CRAWL:
-            return time.time() - move_to_data['last_intention_time'] >= self._crawl_duration
+            return self.subject.crawl_duration
+
+        raise NotImplementedError(
+            'Gui action {} unknown'.format(move_to_data['gui_action'])
+        )
+
+    def finalize_event(self, move_to_data: dict, event: Event) -> None:
+        event.move_duration = self.get_move_duration(move_to_data)
 
 
 class LookAroundBehaviour(AliveSubjectBehaviour):

opencombat/simulation/subject.py

     visible_opponent_ids = shared.create_self('visible_opponent_ids', lambda: [])
     combat_mode = shared.create_self('combat_mode', COMBAT_MODE_DEFENSE)
     behaviour_selector_class = TileBehaviourSelector
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._walk_ref_time = float(self.config.resolve('game.move.walk_ref_time'))
+        self._run_ref_time = float(self.config.resolve('game.move.run_ref_time'))
+        self._crawl_ref_time = float(self.config.resolve('game.move.crawl_ref_time'))
+
+    @property
+    def global_move_coeff(self) -> float:
+        return 1
+
+    @property
+    def run_duration(self) -> float:
+        return self._run_ref_time * self.global_move_coeff
+
+    @property
+    def walk_duration(self) -> float:
+        return self._walk_ref_time * self.global_move_coeff
+
+    @property
+    def crawl_duration(self) -> float:
+        return self._crawl_ref_time * self.global_move_coeff
+
+
+class ManSubject(TileSubject):
+    pass
+
+class TankSubject(TileSubject):
+    @property
+    def global_move_coeff(self) -> float:
+        return 3

run.py

 from opencombat.const import DE_COLOR
 from opencombat.const import URSS_COLOR
 from opencombat.const import FLAG_URSS
-from opencombat.simulation.subject import TileSubject
+from opencombat.simulation.subject import ManSubject
+from opencombat.simulation.subject import TankSubject
 from opencombat.simulation.base import TileStrategySimulation
 from opencombat.simulation.base import TileStrategySubjects
 from opencombat.terminal.base import CocosTerminal
     subjects = TileStrategySubjects(simulation=simulation)
 
     for position in ((10, 2), (11, 3), (11, 4), (12, 5),):
-        man = TileSubject(
+        man = ManSubject(
             config=config,
             simulation=simulation,
             position=position,
         subjects.append(man)
 
     for position in ((30, 15), (31, 16), (32, 17), (33, 18),):
-        man = TileSubject(
+        man = ManSubject(
+            config=config,
+            simulation=simulation,
+            position=position,
+            properties={
+                SELECTION_COLOR_RGB: URSS_COLOR,
+                FLAG: FLAG_URSS,
+                SIDE: 'ALLIES',
+            }
+        )
+        subjects.append(man)
+
+    for position in ((38, 24),):
+        man = TankSubject(
             config=config,
             simulation=simulation,
             position=position,