Removed code duplication by using macros.

src/karts/controller/ai_base_controller.hpp

@@ -85,20 +85,23 @@ public:
              AIBaseController(AbstractKart *kart);
     virtual ~AIBaseController() {};
     virtual void reset();
-    virtual bool disableSlipstreamBonus() const;
+    virtual bool disableSlipstreamBonus() const OVERRIDE;
-    virtual void crashed(const Material *m);
+    virtual void crashed(const Material *m) OVERRIDE;
     static  void enableDebug() {m_ai_debug = true; }
     static  void setTestAI(int n) {m_test_ai = n; }
     static  int  getTestAI() { return m_test_ai; }
-    virtual void crashed(const AbstractKart *k) {};
+    virtual void crashed(const AbstractKart *k) OVERRIDE {};
-    virtual void handleZipper(bool play_sound) {};
+    virtual void handleZipper(bool play_sound) OVERRIDE {};
-    virtual void finishedRace(float time) {};
+    virtual void finishedRace(float time) OVERRIDE {};
     virtual void collectedItem(const Item &item, int add_info=-1,
-                               float previous_energy=0) {};
+                               float previous_energy=0) OVERRIDE {};
-    virtual void setPosition(int p) {};
+    virtual void setPosition(int p) OVERRIDE {};
-    virtual bool isPlayerController() const { return false; }
+    virtual bool isPlayerController() const OVERRIDE { return false; }
-    virtual bool isLocalPlayerController() const { return false; }
+    virtual bool isLocalPlayerController() const OVERRIDE { return false; }
-    virtual void action(PlayerAction action, int value) {};
+    virtual bool action(PlayerAction action, int value, bool dry_run=false) OVERRIDE 
+    {
+        return true;
+    };
     virtual void skidBonusTriggered() {};
     // ------------------------------------------------------------------------
     /** Not used for AIs. */

src/karts/controller/controller.hpp

@@ -89,7 +89,7 @@ public:
     const std::string &getControllerName() const { return m_controller_name; }
     // ------------------------------------------------------------------------
     /** Default: ignore actions. Only PlayerController get them. */
-    virtual void action(PlayerAction action, int value) = 0;
+    virtual bool action(PlayerAction action, int value, bool dry_run=false) = 0;
     // ------------------------------------------------------------------------
     /** Callback whenever a new lap is triggered. Used by the AI
      *  to trigger a recomputation of the way to use.            */

src/karts/controller/ghost_controller.cpp

@@ -81,9 +81,10 @@ void GhostController::addReplayTime(float time)
 }   // addReplayTime
 
 //-----------------------------------------------------------------------------
-void GhostController::action(PlayerAction action, int value)
+bool GhostController::action(PlayerAction action, int value, bool dry_run)
 {
     // Watching replay use only
     if (action == PA_LOOK_BACK)
         m_controls->setLookBack(value!=0);
+    return true;
 }   // action

src/karts/controller/ghost_controller.hpp

@@ -55,7 +55,8 @@ public:
     virtual void setPosition(int p) OVERRIDE {}
     virtual bool isPlayerController() const OVERRIDE { return false; }
     virtual bool isLocalPlayerController() const OVERRIDE { return false; }
-    virtual void action(PlayerAction action, int value) OVERRIDE;
+    virtual bool action(PlayerAction action, int value,
+                        bool dry_run=false) OVERRIDE;
     virtual void skidBonusTriggered() OVERRIDE {}
     virtual void newLap(int lap) OVERRIDE {}
     virtual void saveState(BareNetworkString *buffer) const {};

src/karts/controller/local_player_controller.cpp

@@ -139,14 +139,18 @@ void LocalPlayerController::resetInputState()
  *                if between 1 and 32767, it indicates an analog value,
  *                and if it's 0 it indicates that the corresponding button
  *                was released.
+ *  \param dry_run If set it will return if this action will trigger a
+ *                 state change or not.
+ *  \return       True if dry_run==true and a state change would be triggered.
+ *                If dry_run==false, it returns true.
  */
-void LocalPlayerController::action(PlayerAction action, int value)
+bool LocalPlayerController::action(PlayerAction action, int value,
+                                   bool dry_run)
 {
     // If this event does not change the control state (e.g.
     // it's a (auto) repeat event), do nothing. This especially
     // optimises traffic to the server and other clients.
-    if (!actionChangesState(action, value))
+    if (!PlayerController::action(action, value, /*dry_run*/true)) return false;
-        return;
 
     // If this is a client, send the action to networking layer
     if (World::getWorld()->isNetworkWorld() && 
@@ -158,7 +162,7 @@ void LocalPlayerController::action(PlayerAction action, int value)
                                        action, value,
                                        m_steer_val_l, m_steer_val_r);
     }
-    PlayerController::action(action, value);
+    return PlayerController::action(action, value, /*dry_run*/false);
 }   // action
 
 //-----------------------------------------------------------------------------

src/karts/controller/local_player_controller.hpp

@@ -60,7 +60,8 @@ public:
                                        StateManager::ActivePlayer *player);
                 ~LocalPlayerController();
     void         update            (float) OVERRIDE;
-    void         action            (PlayerAction action, int value) OVERRIDE;
+    bool         action            (PlayerAction action, int value,
+                                    bool dry_run=false) OVERRIDE;
     virtual void handleZipper      (bool play_sound) OVERRIDE;
     void         collectedItem     (const Item &item, int add_info=-1,
                                     float previous_energy=0) OVERRIDE;

src/karts/controller/player_controller.cpp

@@ -78,115 +78,6 @@ void PlayerController::resetInputState()
     m_controls->reset();
 }   // resetInputState
 
-// ----------------------------------------------------------------------------
-/** Returns true if the specified action and value will trigger a state
- *  change. If a new action from the player does not cause a state change,
- *  there is no need to forward that action to the server (or other clients).
- *  NOTE: this function must close mirror action(), make sure both functions
- *  are changed in synch.
- *  \param action  The action to be executed.
- *  \param value   If 32768, it indicates a digital value of 'fully set'
- *                 if between 1 and 32767, it indicates an analog value,
- *                 and if it's 0 it indicates that the corresponding button
- *                 was released.
- *  \return
- */
- bool PlayerController::actionChangesState(PlayerAction action, int value)
-{
-     switch (action)
-     {
-     case PA_STEER_LEFT:
-         if (m_steer_val_l != value) return true;
-         if (value)
-         {
-             if (m_steer_val != value) return true;
-             return (m_controls->getSkidControl() == KartControl::SC_NO_DIRECTION);
-         }
-         else
-             return m_steer_val != m_steer_val_r;
-
-         break;
-     case PA_STEER_RIGHT:
-         if (m_steer_val_r != -value) return true;
-         if (value)
-         {
-             if(m_steer_val != -value) return true;
-             return m_controls->getSkidControl() == KartControl::SC_NO_DIRECTION;
-         }
-         else
-             return m_steer_val != m_steer_val_l;
-
-         break;
-     case PA_ACCEL:
-         if (m_prev_accel != value) return true;
-         if (value && !(m_penalty_time > 0.0f))
-         {
-             if (m_controls->getAccel() != value / 32768.f) return true;
-             if (m_controls->getBrake()) return true;
-             return m_controls->getNitro() != m_prev_nitro;
-         }
-         else
-         {
-             if (m_controls->getAccel() != 0           ) return true;
-             if (m_controls->getBrake() != m_prev_brake) return true;
-             return m_controls->getNitro();
-         }
-         break;
-     case PA_BRAKE:
-         if (m_prev_brake != (value != 0) ) return true;
-         // let's consider below that to be a deadzone
-         if (value > 32768 / 2)
-         {
-             if (!m_controls->getBrake()    ) return true;
-             if (m_controls->getAccel() != 0) return true;
-             return m_controls->getNitro();
-         }
-         else
-         {
-             if (m_controls->getBrake()                         ) return true;
-             if (m_controls->getAccel() != m_prev_accel/32768.0f) return true;
-             // Nitro still depends on whether we're accelerating
-             return m_controls->getNitro() != m_prev_nitro && m_prev_accel;
-         }
-         break;
-     case PA_NITRO:
-         // This basically keeps track whether the button still is being pressed
-         if (m_prev_nitro != (value != 0)) return true;
-         // Enable nitro only when also accelerating
-         return m_controls->getNitro() != ( (value != 0) &&
-                                            m_controls->getAccel() );
-         break;
-     case PA_RESCUE:
-         return m_controls->getRescue() != (value != 0);
-         break;
-     case PA_FIRE:
-         return m_controls->getFire() != (value != 0);
-         break;
-     case PA_LOOK_BACK:
-         return m_controls->getLookBack() != (value != 0);
-         break;
-     case PA_DRIFT:
-         if (value == 0)
-             return m_controls->getSkidControl() != KartControl::SC_NONE;
-         else
-         {
-             if (m_steer_val == 0)
-                 return m_controls->getSkidControl() != KartControl::SC_NO_DIRECTION;
-             else
-                 return m_controls->getSkidControl() != (m_steer_val<0
-                                                     ?  KartControl::SC_RIGHT
-                                                     :  KartControl::SC_LEFT  );
-         }
-         break;
-     case PA_PAUSE_RACE:
-         if (value != 0) StateManager::get()->escapePressed();
-         break;
-     default:
-         break;
-     }
-     return true;
-}   // actionChangesState
-
 // ----------------------------------------------------------------------------
 /** This function interprets a kart action and value, and set the corresponding
  *  entries in the kart control data structure. This function handles esp.
@@ -194,103 +85,147 @@ void PlayerController::resetInputState()
  *  releasing right, the steering must switch to left again. Similarly it
  *  handles 'press left, press right, release left' (in which case still
  *  right must be selected). Similarly for braking and acceleration.
- *  NOTE: this function must close mirror action(), make sure both functions
+ *  This function can be run in two modes: first, if 'dry_run' is set,
- *  are changed in synch.
+ *  it will return true if this action will cause a state change. This
+ *  is sued in networking to avoid sending events to the server (and then
+ *  to other clients) if they are just (e.g. auto) repeated events/
  *  \param action  The action to be executed.
  *  \param value   If 32768, it indicates a digital value of 'fully set'
  *                 if between 1 and 32767, it indicates an analog value,
  *                 and if it's 0 it indicates that the corresponding button
  *                 was released.
+ *  \param dry_run If set, it will only test if the parameter will trigger
+ *                 a state change. If not set, the appropriate actions
+ *                 (i.e. input state change) will be done.
+ *  \return        If dry_run is set, will return true if this action will
+ *                 cause a state change. If dry_run is not set, will return
+ *                 false.
  */
-void PlayerController::action(PlayerAction action, int value)
+bool PlayerController::action(PlayerAction action, int value, bool dry_run)
 {
     Log::info("action", "t %f action %d value %d val_l %d val_r %d val %d",
         World::getWorld()->getTime(), action, value,
         m_steer_val_l, m_steer_val_r, m_steer_val);
+
+    /** If dry_run (parameter) is true, this macro tests if this action would
+     *  trigger a state change in the specified variable (without actually
+     *  doing it). If it will trigger a state change, the marco will trigger
+     *  immediatley a return to the caller. If dry_run is false, it will only
+     *  assign the new value to the variable (and not return to the user
+     *  early). The do-while(0) helps using this macro e.g. in the 'then'
+     *  clause of an if statement. */
+#define SET_OR_TEST(var, value)                \
+    do                                         \
+    {                                          \
+        if(dry_run)                            \
+        {                                      \
+            if (var != (value) ) return true;  \
+        }                                      \
+        else                                   \
+        {                                      \
+            var = value;                       \
+        }                                      \
+    } while(0)
+
+    /** Basically the same as the above macro, but is uses getter/setter
+     *  funcitons. The name of the setter/getter is set'name'(value) and
+     *  get'name'(). */
+#define SET_OR_TEST_GETTER(name, value)                           \
+    do                                                            \
+    {                                                             \
+        if(dry_run)                                               \
+        {                                                         \
+            if (m_controls->get##name() != (value) ) return true; \
+        }                                                         \
+        else                                                      \
+        {                                                         \
+            m_controls->set##name(value);                         \
+        }                                                         \
+    } while(0)
+
     switch (action)
     {
     case PA_STEER_LEFT:
-        m_steer_val_l = value;
+        SET_OR_TEST(m_steer_val_l, value);
         if (value)
         {
-          m_steer_val = value;
+            SET_OR_TEST(m_steer_val, value);
-          if(m_controls->getSkidControl()==KartControl::SC_NO_DIRECTION)
+            if (m_controls->getSkidControl() == KartControl::SC_NO_DIRECTION)
-              m_controls->setSkidControl(KartControl::SC_LEFT);
+                SET_OR_TEST_GETTER(SkidControl, KartControl::SC_LEFT);
         }
         else
-          m_steer_val = m_steer_val_r;
+            SET_OR_TEST(m_steer_val, m_steer_val_r);
-
         break;
     case PA_STEER_RIGHT:
-        m_steer_val_r = -value;
+        SET_OR_TEST(m_steer_val_r, -value);
         if (value)
         {
-            m_steer_val = -value;
+            SET_OR_TEST(m_steer_val, -value);
-            if(m_controls->getSkidControl()==KartControl::SC_NO_DIRECTION)
+            if (m_controls->getSkidControl() == KartControl::SC_NO_DIRECTION)
-                m_controls->setSkidControl(KartControl::SC_RIGHT);
+                SET_OR_TEST_GETTER(SkidControl, KartControl::SC_RIGHT);
         }
         else
-          m_steer_val = m_steer_val_l;
+            SET_OR_TEST(m_steer_val, m_steer_val_l);
 
         break;
     case PA_ACCEL:
-        m_prev_accel = value;
+        SET_OR_TEST(m_prev_accel, value);
         if (value && !(m_penalty_time > 0.0f))
         {
-            m_controls->setAccel(value/32768.0f);
+            SET_OR_TEST_GETTER(Accel, value/32768.0f);
-            m_controls->setBrake(false);
+            SET_OR_TEST_GETTER(Brake, false);
-            m_controls->setNitro(m_prev_nitro);
+            SET_OR_TEST_GETTER(Nitro, m_prev_nitro);
         }
         else
         {
-            m_controls->setAccel(0.0f);
+            SET_OR_TEST_GETTER(Accel, 0.0f);
-            m_controls->setBrake(m_prev_brake);
+            SET_OR_TEST_GETTER(Brake, m_prev_brake);
-            m_controls->setNitro(false);
+            SET_OR_TEST_GETTER(Nitro, false);
         }
         break;
     case PA_BRAKE:
-        m_prev_brake = value!=0;
+        SET_OR_TEST(m_prev_brake, value!=0);
         // let's consider below that to be a deadzone
         if(value > 32768/2)
         {
-            m_controls->setBrake(true);
+            SET_OR_TEST_GETTER(Brake, true);
-            m_controls->setAccel(0.0f);
+            SET_OR_TEST_GETTER(Accel, 0.0f);
-            m_controls->setNitro(false);
+            SET_OR_TEST_GETTER(Nitro, false);
         }
         else
         {
-            m_controls->setBrake(false);
+            SET_OR_TEST_GETTER(Brake, false);
-            m_controls->setAccel(m_prev_accel/32768.0f);
+            SET_OR_TEST_GETTER(Accel, m_prev_accel/32768.0f);
             // Nitro still depends on whether we're accelerating
-            m_controls->setNitro(m_prev_nitro && m_prev_accel);
+            SET_OR_TEST_GETTER(Nitro, m_prev_nitro && m_prev_accel);
         }
         break;
     case PA_NITRO:
         // This basically keeps track whether the button still is being pressed
-        m_prev_nitro = (value != 0);
+        SET_OR_TEST(m_prev_nitro, value != 0 );
         // Enable nitro only when also accelerating
-        m_controls->setNitro( ((value!=0) && m_controls->getAccel()) );
+        SET_OR_TEST_GETTER(Nitro, ((value!=0) && m_controls->getAccel()) );
         break;
     case PA_RESCUE:
-        m_controls->setRescue(value!=0);
+        SET_OR_TEST_GETTER(Rescue, value!=0);
         break;
     case PA_FIRE:
-        m_controls->setFire(value!=0);
+        SET_OR_TEST_GETTER(Fire, value!=0);
         break;
     case PA_LOOK_BACK:
-        m_controls->setLookBack(value!=0);
+        SET_OR_TEST_GETTER(LookBack, value!=0);
         break;
     case PA_DRIFT:
-        if(value==0)
+        if (value == 0)
-            m_controls->setSkidControl(KartControl::SC_NONE);
+            SET_OR_TEST_GETTER(SkidControl, KartControl::SC_NONE);
         else
         {
-            if(m_steer_val==0)
+            if (m_steer_val == 0)
-                m_controls->setSkidControl(KartControl::SC_NO_DIRECTION);
+                SET_OR_TEST_GETTER(SkidControl, KartControl::SC_NO_DIRECTION);
             else
-                m_controls->setSkidControl(m_steer_val<0
+                SET_OR_TEST_GETTER(SkidControl, m_steer_val<0
-                                           ? KartControl::SC_RIGHT
+                                                ? KartControl::SC_RIGHT
-                                           : KartControl::SC_LEFT  );
+                                                : KartControl::SC_LEFT  );
         }
         break;
     case PA_PAUSE_RACE:
@@ -299,7 +234,10 @@ void PlayerController::action(PlayerAction action, int value)
     default:
        break;
     }
-
+    if (dry_run) return false;
+    return true;
+#undef SET_OR_TEST
+#undef SET_OR_TEST_GETTER
 }   // action
 
 //-----------------------------------------------------------------------------

src/karts/controller/player_controller.hpp

@@ -44,8 +44,8 @@ public:
                  PlayerController(AbstractKart *kart);
     virtual     ~PlayerController  ();
     virtual void update            (float) OVERRIDE;
-    virtual void action            (PlayerAction action, int value) OVERRIDE;
+    virtual bool action            (PlayerAction action, int value,
-    virtual bool actionChangesState(PlayerAction action, int value);
+                                    bool dry_run = false           ) OVERRIDE;
     virtual void actionFromNetwork(PlayerAction action, int value,
                                    int value_l, int value_r);
     virtual void skidBonusTriggered() OVERRIDE;