diff --git a/src/config/stk_config.cpp b/src/config/stk_config.cpp
index 6ceed8378..99c5be912 100644
--- a/src/config/stk_config.cpp
+++ b/src/config/stk_config.cpp
@@ -127,7 +127,7 @@ void STKConfig::load(const std::string &filename)
     }
 
     CHECK_NEG(m_max_karts,                 "<karts max=..."             );
-    CHECK_NEG(m_item_switch_time,          "item-switch-time"           );
+    CHECK_NEG(m_item_switch_ticks,         "item switch-time"           );
     CHECK_NEG(m_bubblegum_counter,         "bubblegum disappear counter");
     CHECK_NEG(m_explosion_impulse_objects, "explosion-impulse-objects"  );
     CHECK_NEG(m_max_skidmarks,             "max-skidmarks"              );
@@ -140,7 +140,7 @@ void STKConfig::load(const std::string &filename)
     CHECK_NEG(m_delay_finish_time,         "delay-finish-time"          );
     CHECK_NEG(m_music_credit_time,         "music-credit-time"          );
     CHECK_NEG(m_leader_time_per_kart,      "leader time-per-kart"       );
-    CHECK_NEG(m_penalty_time,              "penalty-time"               );
+    CHECK_NEG(m_penalty_ticks,             "penalty-time"               );
     CHECK_NEG(m_max_display_news,          "max-display-news"           );
     CHECK_NEG(m_replay_max_time,           "replay max-time"            );
     CHECK_NEG(m_replay_delta_angle,        "replay delta-angle"         );
@@ -167,10 +167,11 @@ void STKConfig::init_defaults()
     m_bomb_time                  = m_bomb_time_increase        =
         m_explosion_impulse_objects = m_music_credit_time      =
         m_delay_finish_time      = m_skid_fadeout_time         =
-        m_near_ground            = m_item_switch_time          =
-        m_smooth_angle_limit     = m_penalty_time              =
-        m_default_track_friction = m_default_moveable_friction =
-        UNDEFINED;
+        m_near_ground            = 
+        m_smooth_angle_limit     = m_default_track_friction    =
+        m_default_moveable_friction =    UNDEFINED;
+    m_item_switch_ticks          = -100;
+    m_penalty_ticks              = -100;
     m_physics_fps                = -100;
     m_bubblegum_counter          = -100;
     m_shield_restrict_weapos     = false;
@@ -266,7 +267,9 @@ void STKConfig::getAllData(const XMLNode * root)
 
     if (const XMLNode *startup_node= root->getNode("startup"))
     {
-        startup_node->get("penalty", &m_penalty_time );
+        float f;
+        startup_node->get("penalty", &f);
+        m_penalty_ticks = time2Ticks(f);
     }
 
     if (const XMLNode *news_node= root->getNode("news"))
@@ -347,7 +350,9 @@ void STKConfig::getAllData(const XMLNode * root)
     if(const XMLNode *switch_node= root->getNode("switch"))
     {
         switch_node->get("items", &m_switch_items    );
-        switch_node->get("time",  &m_item_switch_time);
+        float f;
+        if( switch_node->get("time",  &f) )
+            m_item_switch_ticks = stk_config->time2Ticks(f);
     }
 
     if(const XMLNode *bubblegum_node= root->getNode("bubblegum"))
diff --git a/src/config/stk_config.hpp b/src/config/stk_config.hpp
index 8635995c0..473bd42e9 100644
--- a/src/config/stk_config.hpp
+++ b/src/config/stk_config.hpp
@@ -70,13 +70,13 @@ public:
     float m_bomb_time;                 /**<Time before a bomb explodes.        */
     float m_bomb_time_increase;        /**<Time added to bomb timer when it's
                                            passed on.                          */
-    float m_item_switch_time;          /**< Time items will be switched.       */
+    int   m_item_switch_ticks;          /**< Time items will be switched.       */
     int   m_bubblegum_counter;         /**< How many times bubble gums must be
                                             driven over before they disappear. */
     bool  m_shield_restrict_weapos;    /**<Wether weapon usage is punished. */
     float m_explosion_impulse_objects; /**<Impulse of explosion on moving
                                             objects, e.g. road cones, ...      */
-    float m_penalty_time;              /**< Penalty time when starting too
+    int   m_penalty_ticks;              /**< Penalty time when starting too
                                             early.                             */
     float m_delay_finish_time;         /**<Delay after a race finished before
                                            the results are displayed.          */
diff --git a/src/graphics/explosion.cpp b/src/graphics/explosion.cpp
index 4d5967bb1..6c2e95291 100644
--- a/src/graphics/explosion.cpp
+++ b/src/graphics/explosion.cpp
@@ -20,6 +20,7 @@
 
 #include "audio/sfx_base.hpp"
 #include "audio/sfx_manager.hpp"
+#include "config/stk_config.hpp"
 #include "config/user_config.hpp"
 #include "graphics/irr_driver.hpp"
 #include "graphics/material.hpp"
@@ -31,14 +32,15 @@
 #include "race/race_manager.hpp"
 #include "utils/vec3.hpp"
 
-const float burst_time = 0.1f;
 
 /** Creates an explosion effect. */
 Explosion::Explosion(const Vec3& coord, const char* explosion_sound, const char * particle_file)
                      : HitSFX(coord, explosion_sound)
 {
     // short emision time, explosion, not constant flame
-    m_remaining_time  = burst_time;
+
+    m_explosion_ticks = stk_config->time2Ticks(2.0f);
+    m_remaining_ticks = stk_config->time2Ticks(0.1f);
     m_emission_frames = 0;
 
 #ifndef SERVER_ONLY
@@ -84,22 +86,22 @@ Explosion::~Explosion()
  *  \param dt Time step size.
  *  \return true If the explosion is finished.
  */
-bool Explosion::updateAndDelete(float dt)
+bool Explosion::updateAndDelete(int ticks)
 {
     // The explosion sfx is shorter than the particle effect,
     // so no need to save the result of the update call.
-    HitSFX::updateAndDelete(dt);
+    HitSFX::updateAndDelete(ticks);
 
     m_emission_frames++;
-    m_remaining_time -= dt;
+    m_remaining_ticks -= ticks;
 
     // Do nothing more if the animation is still playing
-    if (m_remaining_time>0) return false;
+    if (m_remaining_ticks>0) return false;
 
     // Otherwise check that the sfx has finished, otherwise the
     // sfx will get aborted 'in the middle' when this explosion
     // object is removed.
-    if (m_remaining_time > -explosion_time)
+    if (m_remaining_ticks > -m_explosion_ticks)
     {
 #ifndef SERVER_ONLY
         // if framerate is very low, emit for at least a few frames, in case
@@ -122,3 +124,4 @@ bool Explosion::updateAndDelete(float dt)
 
     return false;  // not finished
 }   // updateAndDelete
+
diff --git a/src/graphics/explosion.hpp b/src/graphics/explosion.hpp
index 4dbf2fdb3..a24bd0129 100644
--- a/src/graphics/explosion.hpp
+++ b/src/graphics/explosion.hpp
@@ -21,6 +21,7 @@
 #define HEADER_EXPLOSION_HPP
 
 #include "graphics/hit_sfx.hpp"
+#include "utils/cpp2011.hpp"
 #include "utils/no_copy.hpp"
 
 namespace irr
@@ -33,23 +34,26 @@ class Vec3;
 class SFXBase;
 class ParticleEmitter;
 
-const float explosion_time = 2.0f;
-
 /**
   * \ingroup graphics
   */
 class Explosion : public HitSFX
 {
 private:
-    float            m_remaining_time;
+    int              m_remaining_ticks;
     int              m_emission_frames;
     ParticleEmitter* m_emitter;
+    int              m_explosion_ticks;
+
 
 public:
          Explosion(const Vec3& coord, const char* explosion_sound, const char * particle_file );
         ~Explosion();
-    bool updateAndDelete(float delta_t);
-    bool hasEnded () { return  m_remaining_time <= -explosion_time;  }
+    bool updateAndDelete(int ticks) OVERRIDE;
+    bool hasEnded () 
+    {
+        return  m_remaining_ticks <= -m_explosion_ticks; 
+    }
 
 } ;
 
diff --git a/src/graphics/hit_effect.hpp b/src/graphics/hit_effect.hpp
index 39cbbdea9..112febd81 100644
--- a/src/graphics/hit_effect.hpp
+++ b/src/graphics/hit_effect.hpp
@@ -43,7 +43,7 @@ public:
     /** Updates a hit effect. Called once per frame.
      *  \param dt Time step size.
      *  \return True if the hit effect is finished and can be removed. */
-    virtual bool updateAndDelete(float dt) = 0;
+    virtual bool updateAndDelete(int ticks) = 0;
 
     // ------------------------------------------------------------------------
     /** Sets that this SFX affects a player kart, which can be used to
diff --git a/src/graphics/hit_sfx.cpp b/src/graphics/hit_sfx.cpp
index 0fb3157c8..be1c3121f 100644
--- a/src/graphics/hit_sfx.cpp
+++ b/src/graphics/hit_sfx.cpp
@@ -61,7 +61,7 @@ void HitSFX::setLocalPlayerKartHit()
  *  \param dt Time step size.
  *  \return true If the explosion is finished.
  */
-bool HitSFX::updateAndDelete(float dt)
+bool HitSFX::updateAndDelete(int ticks)
 {
     SFXBase::SFXStatus status = m_sfx->getStatus();
     return status!= SFXBase::SFX_PLAYING;
diff --git a/src/graphics/hit_sfx.hpp b/src/graphics/hit_sfx.hpp
index b30343ea9..7b6c6d90a 100644
--- a/src/graphics/hit_sfx.hpp
+++ b/src/graphics/hit_sfx.hpp
@@ -36,7 +36,7 @@ private:
 public:
          HitSFX(const Vec3& coord, const char* explosion_sound);
         ~HitSFX();
-    virtual bool updateAndDelete(float dt) OVERRIDE;
+    virtual bool updateAndDelete(int ticks) OVERRIDE;
     virtual void setLocalPlayerKartHit() OVERRIDE;
 
 };   // HitSFX
diff --git a/src/graphics/material.cpp b/src/graphics/material.cpp
index 7cce73b28..ffde5d9b4 100644
--- a/src/graphics/material.cpp
+++ b/src/graphics/material.cpp
@@ -152,7 +152,9 @@ Material::Material(const XMLNode *node, bool deprecated)
     node->get("ignore",              &m_ignore             );
 
     node->get("max-speed",           &m_max_speed_fraction );
-    node->get("slowdown-time",       &m_slowdown_time      );
+    float f = stk_config->ticks2Time(m_slowdown_ticks);
+    node->get("slowdown-time",       &f                    );
+    m_slowdown_ticks = stk_config->time2Ticks(f);
     node->get("colorizable",         &m_colorizable        );
     node->get("colorization-factor", &m_colorization_factor);
     node->get("hue-settings",        &m_hue_settings       );
@@ -484,7 +486,7 @@ void Material::init()
     m_colorization_factor       = 0.0f;
     m_colorization_mask         = "";
     m_max_speed_fraction        = 1.0f;
-    m_slowdown_time             = 1.0f;
+    m_slowdown_ticks            = stk_config->time2Ticks(1.0f);
     m_sfx_name                  = "";
     m_sfx_min_speed             = 0.0f;
     m_sfx_max_speed             = 30;
diff --git a/src/graphics/material.hpp b/src/graphics/material.hpp
index e09a188f0..19f2deb81 100644
--- a/src/graphics/material.hpp
+++ b/src/graphics/material.hpp
@@ -155,7 +155,7 @@ private:
     RandomGenerator m_random_hue;
 
     /** How much the top speed is reduced per second. */
-    float            m_slowdown_time;
+    int              m_slowdown_ticks;
 
     /** Maximum speed at which no more slow down occurs. */
     float            m_max_speed_fraction;
@@ -287,7 +287,7 @@ public:
     /** Returns how long it will take for a slowdown to take effect.
      *  It is the time it takes till the full slowdown applies to
      *  karts. So a short time will slowdown a kart much faster. */
-    float getSlowDownTime() const { return m_slowdown_time;          }
+    int getSlowDownTicks() const { return m_slowdown_ticks;          }
     // ------------------------------------------------------------------------
     /** Returns true if this material is under some other mesh and therefore
      *  requires another raycast to find the surface it is under (used for
diff --git a/src/graphics/slip_stream.cpp b/src/graphics/slip_stream.cpp
index a9997db4d..9c4efcf3d 100644
--- a/src/graphics/slip_stream.cpp
+++ b/src/graphics/slip_stream.cpp
@@ -63,7 +63,7 @@ SlipStream::SlipStream(AbstractKart* kart) : MovingTexture(0, 0), m_kart(kart)
     }
 #endif
 
-    m_slipstream_time      = 0.0f;
+    m_slipstream_ticks = 0;
 
     float length = m_kart->getKartProperties()->getSlipstreamLength();
     float kw     = m_kart->getKartWidth();
@@ -122,8 +122,8 @@ SlipStream::~SlipStream()
 /** Called at re-start of a race. */
 void SlipStream::reset()
 {
-    m_slipstream_mode = SS_NONE;
-    m_slipstream_time = 0;
+    m_slipstream_mode  = SS_NONE;
+    m_slipstream_ticks = 0;
 
     // Reset a potential max speed increase
     m_kart->increaseMaxSpeed(MaxSpeed::MS_INCREASE_SLIPSTREAM, 0, 0, 0, 0);
@@ -188,7 +188,7 @@ SP::SPMesh* SlipStream::createMesh(Material* material)
         ("custom_alpha", [this](SP::SPUniformAssigner* ua)->void
         {
             // In sp shader it's assigned reverse by 1.0 - custom_alpha
-            ua->setValue(1.0f - m_slipstream_time);
+            ua->setValue(1.0f - stk_config->ticks2Time(m_slipstream_ticks));
         });
 
     std::vector<uint16_t> indices;
@@ -289,8 +289,8 @@ void SlipStream::setIntensity(float f, const AbstractKart *kart)
 */
 bool SlipStream::isSlipstreamReady() const
 {
-    return m_slipstream_time>
-        m_kart->getKartProperties()->getSlipstreamCollectTime();
+    return m_slipstream_ticks>
+        m_kart->getKartProperties()->getSlipstreamCollectTicks();
 }   // isSlipstreamReady
 
 //-----------------------------------------------------------------------------
@@ -309,7 +309,7 @@ void SlipStream::updateSlipstreamPower()
                                 kp->getSlipstreamMaxSpeedIncrease(),
                                 kp->getSlipstreamAddPower(),
                                 kp->getSlipstreamDuration(),
-                                kp->getSlipstreamFadeOutTime());
+                                kp->getSlipstreamFadeOutTicks());
     }
 }   // upateSlipstreamPower
 
@@ -341,7 +341,7 @@ void SlipStream::setDebugColor(const video::SColor &color)
 /** Update, called once per timestep.
  *  \param dt Time step size.
  */
-void SlipStream::update(float dt)
+void SlipStream::update(int ticks)
 {
     const KartProperties *kp = m_kart->getKartProperties();
 
@@ -350,12 +350,12 @@ void SlipStream::update(float dt)
         || m_kart->isGhostKart())
         return;
 
-    MovingTexture::update(dt);
+    MovingTexture::update(stk_config->ticks2Time(ticks));
 
     if(m_slipstream_mode==SS_USE)
     {
-        m_slipstream_time -= dt;
-        if(m_slipstream_time<0) m_slipstream_mode=SS_NONE;
+        m_slipstream_ticks -= ticks;
+        if(m_slipstream_ticks<0) m_slipstream_mode=SS_NONE;
     }
 
     updateSlipstreamPower();
@@ -463,28 +463,33 @@ void SlipStream::update(float dt)
             {
                 m_slipstream_mode = SS_USE;
                 m_kart->handleZipper();
-                m_slipstream_time = kp->getSlipstreamCollectTime();
+                m_slipstream_ticks = kp->getSlipstreamCollectTicks();
                 return;
             }
         }
-        m_slipstream_time -=dt;
-        if(m_slipstream_time<0) m_slipstream_mode = SS_NONE;
+        m_slipstream_ticks -= ticks;
+        if(m_slipstream_ticks<0) m_slipstream_mode = SS_NONE;
         setIntensity(0, NULL);
         return;
     }   // if !is_sstreaming
 
     if(UserConfigParams::m_slipstream_debug &&
         m_kart->getController()->isLocalPlayerController())
-        m_target_kart->getSlipstream()->setDebugColor(video::SColor(255, 0, 255, 0));
+        m_target_kart->getSlipstream()
+                     ->setDebugColor(video::SColor(255, 0, 255, 0));
     // Accumulate slipstream credits now
-    m_slipstream_time = m_slipstream_mode==SS_NONE ? dt
-                                                   : m_slipstream_time+dt;
+    
+    if (m_slipstream_mode == SS_NONE)
+        m_slipstream_ticks = ticks;
+    else
+        m_slipstream_ticks += ticks;
+
     if(isSlipstreamReady())
         m_kart->setSlipstreamEffect(9.0f);
-    setIntensity(m_slipstream_time, m_target_kart);
+    setIntensity(stk_config->ticks2Time(m_slipstream_ticks), m_target_kart);
 
     m_slipstream_mode = SS_COLLECT;
-    if (m_slipstream_time > kp->getSlipstreamCollectTime())
+    if (m_slipstream_ticks > kp->getSlipstreamCollectTicks())
     {
         setIntensity(1.0f, m_target_kart);
     }
diff --git a/src/graphics/slip_stream.hpp b/src/graphics/slip_stream.hpp
index c151137f1..1136b87f7 100644
--- a/src/graphics/slip_stream.hpp
+++ b/src/graphics/slip_stream.hpp
@@ -61,7 +61,7 @@ private:
     float              m_length;
 
     /** The time a kart was in slipstream. */
-    float         m_slipstream_time;
+    int           m_slipstream_ticks;
 
     /** Slipstream mode: either nothing happening, or the kart is collecting
      *  'slipstream credits', or the kart is using accumulated credits. */
@@ -80,7 +80,7 @@ public:
                  SlipStream  (AbstractKart* kart);
     virtual     ~SlipStream  ();
     void         reset();
-    virtual void update(float dt);
+    virtual void update(int ticks);
     void         setIntensity(float f, const AbstractKart* kart);
     void         updateSlipstreamPower();
     bool         isSlipstreamReady() const;
diff --git a/src/graphics/weather.cpp b/src/graphics/weather.cpp
index f462bb591..257237f29 100644
--- a/src/graphics/weather.cpp
+++ b/src/graphics/weather.cpp
@@ -30,7 +30,7 @@ Weather::Weather()
 {
     m_thunder_sound = NULL;
     m_weather_sound = NULL;
-    m_lightning = 0.0f;
+    m_lightning = 0;
     
     if (Track::getCurrentTrack()->getWeatherLightning())
     {
@@ -44,7 +44,7 @@ Weather::Weather()
     }
 
     RandomGenerator g;
-    m_next_lightning = (float)g.get(35);
+    m_next_lightning = stk_config->time2Ticks((float)g.get(35));
 }   // Weather
 
 // ----------------------------------------------------------------------------
@@ -60,7 +60,7 @@ Weather::~Weather()
 
 // ----------------------------------------------------------------------------
 
-void Weather::update(float dt)
+void Weather::update(int ticks)
 {
     if (!Track::getCurrentTrack()->getWeatherLightning())
         return;
@@ -68,9 +68,9 @@ void Weather::update(float dt)
     if (World::getWorld()->getRaceGUI() == NULL)
         return;
         
-    m_next_lightning -= dt;
+    m_next_lightning -= ticks;
 
-    if (m_next_lightning < 0.0f)
+    if (m_next_lightning < 0)
     {
         startLightning();
 
@@ -80,12 +80,12 @@ void Weather::update(float dt)
         }
 
         RandomGenerator g;
-        m_next_lightning = 35 + (float)g.get(35);
+        m_next_lightning = stk_config->time2Ticks(35.0f + (float)g.get(35));
     }
     
-    if (m_lightning > 0.0f)
+    if (m_lightning > 0)
     {
-        m_lightning -= dt;
+        m_lightning -= ticks;
     }
 }   // update
 
@@ -100,11 +100,20 @@ void Weather::playSound()
     }
 }
 
+// ----------------------------------------------------------------------------
+/** Set the flag that a lightning should be shown. */
+void Weather::startLightning()
+{
+    m_lightning = stk_config->time2Ticks(1.0f);
+}   // startLightning
+
+// ----------------------------------------------------------------------------
 irr::core::vector3df Weather::getIntensity()
 {
-    irr::core::vector3df value = {0.7f * m_lightning, 
-                                  0.7f * m_lightning, 
-                                  0.7f * std::min(1.0f, m_lightning * 1.5f)};
+    float light = stk_config->ticks2Time(m_lightning);
+    irr::core::vector3df value = {0.7f * light, 
+                                  0.7f * light, 
+                                  0.7f * std::min(1.0f, light * 1.5f)};
                                  
     return value;
-}
+}   // getIntensity
diff --git a/src/graphics/weather.hpp b/src/graphics/weather.hpp
index aaaf26b56..735692678 100644
--- a/src/graphics/weather.hpp
+++ b/src/graphics/weather.hpp
@@ -26,8 +26,11 @@ class SFXBase;
 
 class Weather : public AbstractSingleton<Weather>
 {
-    float m_next_lightning;
-    float m_lightning;
+    /** Counts ticks till the next lighting appears. */
+    int m_next_lightning;
+
+    /** Counts the ticks for displaying the current lighting. */
+    int m_lightning;
 
     SFXBase* m_thunder_sound;
     SFXBase* m_weather_sound;
@@ -36,14 +39,13 @@ public:
              Weather();
     virtual ~Weather();
 
-    void update(float dt);
+    void update(int ticks);
     void playSound();
-    
-    /** Set the flag that a lightning should be shown. */
-    void startLightning() { m_lightning = 1.0f; }
-    bool shouldLightning() { return m_lightning > 0.0f; }
-    
+    void startLightning();
     irr::core::vector3df getIntensity();
-};
+
+    bool shouldLightning() { return m_lightning > 0; }
+    
+};   // class Weather
 
 #endif
diff --git a/src/items/attachment.cpp b/src/items/attachment.cpp
index b1d4ab268..ec080e044 100644
--- a/src/items/attachment.cpp
+++ b/src/items/attachment.cpp
@@ -366,8 +366,9 @@ void Attachment::hitBanana(Item *item, int new_attachment)
         // default time. This is necessary to avoid that a kart lands on the
         // same banana again once the explosion animation is finished, giving
         // the kart the same penalty twice.
-        float f = std::max(item->getDisableTime(), kp->getExplosionDuration() + 2.0f);
-        item->setDisableTime(f);
+        int ticks = std::max(item->getDisableTicks(), 
+                             stk_config->time2Ticks(kp->getExplosionDuration() + 2.0f));
+        item->setDisableTicks(ticks);
         break;
         }
     case ATTACH_ANVIL:
@@ -490,7 +491,7 @@ void Attachment::handleCollisionWithKart(AbstractKart *other)
 }   // handleCollisionWithKart
 
 //-----------------------------------------------------------------------------
-void Attachment::update(float dt)
+void Attachment::update(int ticks)
 {
     if(m_type==ATTACH_NOTHING) return;
 
@@ -499,7 +500,7 @@ void Attachment::update(float dt)
     if (m_type == ATTACH_BOMB && m_kart->getKartAnimation() != NULL)
         return;
 
-    m_ticks_left--;  // dt always physics time step
+    m_ticks_left -= ticks;
 
 
     bool is_shield = m_type == ATTACH_BUBBLEGUM_SHIELD ||
@@ -526,6 +527,7 @@ void Attachment::update(float dt)
         m_node->setVisible(mod > ticks_per_flash);
     }
 
+    float dt = stk_config->ticks2Time(ticks);
     if (m_node_scale < m_wanted_node_scale)
     {
         m_node_scale += dt*1.5f;
@@ -537,7 +539,7 @@ void Attachment::update(float dt)
 
     if(m_plugin)
     {
-        bool discard = m_plugin->updateAndTestFinished(dt);
+        bool discard = m_plugin->updateAndTestFinished(ticks);
         if(discard)
         {
             clear();  // also removes the plugin
diff --git a/src/items/attachment.hpp b/src/items/attachment.hpp
index 1036c4f42..6bcd190b9 100644
--- a/src/items/attachment.hpp
+++ b/src/items/attachment.hpp
@@ -112,7 +112,7 @@ public:
          ~Attachment();
     void  clear ();
     void  hitBanana(Item *item, int new_attachment=-1);
-    void  update (float dt);
+    void  update(int ticks);
     void  handleCollisionWithKart(AbstractKart *other);
     void  set (AttachmentType type, int ticks,
                AbstractKart *previous_kart=NULL);
diff --git a/src/items/attachment_plugin.hpp b/src/items/attachment_plugin.hpp
index a6c792819..e7372cdd8 100644
--- a/src/items/attachment_plugin.hpp
+++ b/src/items/attachment_plugin.hpp
@@ -52,7 +52,7 @@ public:
     // ------------------------------------------------------------------------
     /** Updates a plugin. This is called once each time frame. If the
      *  function returns true, the attachment is discarded. */
-    virtual bool updateAndTestFinished(float dt) = 0;
+    virtual bool updateAndTestFinished(int ticks) = 0;
 
     // ------------------------------------------------------------------------
     /** Called when the animation of the Attachment's node is done. */
diff --git a/src/items/bowling.cpp b/src/items/bowling.cpp
index 7f52f3654..f2e5ab2c2 100644
--- a/src/items/bowling.cpp
+++ b/src/items/bowling.cpp
@@ -76,7 +76,7 @@ Bowling::Bowling(AbstractKart *kart)
     getBody()->setCollisionFlags(flag);
 
     // should not live forever, auto-destruct after 20 seconds
-    m_max_lifespan = 20;
+    m_max_lifespan = stk_config->time2Ticks(20);
 
     m_roll_sfx = SFXManager::get()->createSoundSource("bowling_roll");
     m_roll_sfx->play();
@@ -118,9 +118,9 @@ void Bowling::init(const XMLNode &node, scene::IMesh *bowling)
  *  \param dt Time step size.
  *  \returns True of this object should be removed.
  */
-bool Bowling::updateAndDelete(float dt)
+bool Bowling::updateAndDelete(int ticks)
 {
-    bool can_be_deleted = Flyable::updateAndDelete(dt);
+    bool can_be_deleted = Flyable::updateAndDelete(ticks);
     if(can_be_deleted)
         return true;
 
diff --git a/src/items/bowling.hpp b/src/items/bowling.hpp
index 600a21947..a75d82414 100644
--- a/src/items/bowling.hpp
+++ b/src/items/bowling.hpp
@@ -53,7 +53,7 @@ public:
              Bowling(AbstractKart* kart);
     virtual ~Bowling();
     static  void init(const XMLNode &node, scene::IMesh *bowling);
-    virtual bool updateAndDelete(float dt);
+    virtual bool updateAndDelete(int ticks);
     virtual bool hit(AbstractKart* kart, PhysicalObject* obj=NULL);
     virtual HitEffect *getHitEffect() const;
 
diff --git a/src/items/flyable.cpp b/src/items/flyable.cpp
index 36b3bca1e..3b0702f7c 100644
--- a/src/items/flyable.cpp
+++ b/src/items/flyable.cpp
@@ -70,7 +70,7 @@ Flyable::Flyable(AbstractKart *kart, PowerupManager::PowerupType type,
     m_animation                    = NULL;
     m_mass                         = mass;
     m_adjust_up_velocity           = true;
-    m_time_since_thrown            = 0;
+    m_ticks_since_thrown           = 0;
     m_position_offset              = Vec3(0,0,0);
     m_owner_has_temporary_immunity = true;
     m_do_terrain_info              = true;
@@ -377,17 +377,17 @@ void Flyable::setAnimation(AbstractKartAnimation *animation)
  *  \param dt Time step size.
  *  \returns True if this object can be deleted.
  */
-bool Flyable::updateAndDelete(float dt)
+bool Flyable::updateAndDelete(int ticks)
 {
     if (hasAnimation())
     {
-        m_animation->update(dt);
-        Moveable::update(dt);
+        m_animation->update(stk_config->ticks2Time(ticks));
+        Moveable::update(ticks);
         return false;
     }   // if animation
 
-    m_time_since_thrown += dt;
-    if(m_max_lifespan > -1 && m_time_since_thrown > m_max_lifespan)
+    m_ticks_since_thrown += ticks;
+    if(m_max_lifespan > -1 && m_ticks_since_thrown > m_max_lifespan)
         hit(NULL);
 
     if(m_has_hit_something) return true;
@@ -465,7 +465,7 @@ bool Flyable::updateAndDelete(float dt)
         setVelocity(v);
     }   // if m_adjust_up_velocity
 
-    Moveable::update(dt);
+    Moveable::update(ticks);
 
     return false;
 }   // updateAndDelete
@@ -478,8 +478,8 @@ bool Flyable::updateAndDelete(float dt)
 bool Flyable::isOwnerImmunity(const AbstractKart* kart_hit) const
 {
     return m_owner_has_temporary_immunity &&
-           kart_hit == m_owner            &&
-           m_time_since_thrown < 2.0f;
+        kart_hit == m_owner            &&
+        m_ticks_since_thrown < stk_config->time2Ticks(2.0f);
 }   // isOwnerImmunity
 
 // ----------------------------------------------------------------------------
diff --git a/src/items/flyable.hpp b/src/items/flyable.hpp
index 3b46b7ae6..c1f1fe426 100644
--- a/src/items/flyable.hpp
+++ b/src/items/flyable.hpp
@@ -127,11 +127,11 @@ protected:
 
     /** Time since thrown. used so a kart can't hit himself when trying
      *  something, and also to put some time limit to some collectibles */
-    float             m_time_since_thrown;
+    int               m_ticks_since_thrown;
 
     /** Set to something > -1 if this flyable should auto-destrcut after
-     *  a while. */
-    float             m_max_lifespan;
+     *  that may ticks. */
+    int                m_max_lifespan;
 
     /** If set to true, the kart that throwns this flyable can't collide
      *  with it for a short time. */
@@ -167,7 +167,7 @@ public:
     virtual     ~Flyable     ();
     static void  init        (const XMLNode &node, scene::IMesh *model,
                               PowerupManager::PowerupType type);
-    virtual bool              updateAndDelete(float);
+    virtual bool              updateAndDelete(int ticks);
     virtual void              setAnimation(AbstractKartAnimation *animation);
     virtual HitEffect*        getHitEffect() const;
     bool                      isOwnerImmunity(const AbstractKart *kart_hit) const;
diff --git a/src/items/item.cpp b/src/items/item.cpp
index dc3f7512a..e64f29ee2 100644
--- a/src/items/item.cpp
+++ b/src/items/item.cpp
@@ -118,8 +118,8 @@ void Item::initItem(ItemType type, const Vec3 &xyz)
     m_item_id           = -1;
     m_collected         = false;
     m_original_type     = ITEM_NONE;
-    m_deactive_time     = 0;
-    m_time_till_return  = 0.0f;  // not strictly necessary, see isCollected()
+    m_deactive_ticks    = 0;
+    m_ticks_till_return = 0;  // not strictly necessary, see isCollected()
     m_emitter           = NULL;
     m_rotate            = (type!=ITEM_BUBBLEGUM) && (type!=ITEM_TRIGGER);
     switch(m_type)
@@ -265,8 +265,8 @@ Item::~Item()
 void Item::reset()
 {
     m_collected         = false;
-    m_time_till_return  = 0.0f;
-    m_deactive_time     = 0.0f;
+    m_ticks_till_return = 0;
+    m_deactive_ticks    = 0;
     switch(m_type)
     {
     case ITEM_BUBBLEGUM:
@@ -296,24 +296,24 @@ void Item::reset()
  */
 void Item::setParent(AbstractKart* parent)
 {
-    m_event_handler = parent;
-    m_emitter       = parent;
-    m_deactive_time = 1.5f;
+    m_event_handler  = parent;
+    m_emitter        = parent;
+    m_deactive_ticks = stk_config->time2Ticks(1.5f);
 }   // setParent
 
 //-----------------------------------------------------------------------------
 /** Updated the item - rotates it, takes care of items coming back into
  *  the game after it has been collected.
- *  \param dt Time step size.
+ *  \param ticks Number of physics time steps - should be 1.
  */
-void Item::update(float dt)
+void Item::update(int ticks)
 {
-    if(m_deactive_time > 0) m_deactive_time -= dt;
+    if(m_deactive_ticks > 0) m_deactive_ticks -= ticks;
 
     if(m_collected)
     {
-        m_time_till_return -= dt;
-        if(m_time_till_return<0)
+        m_ticks_till_return -= ticks;
+        if(m_ticks_till_return<0)
         {
             m_collected=false;
 
@@ -322,13 +322,14 @@ void Item::update(float dt)
                 m_node->setScale(core::vector3df(1,1,1));
             }
         }   // time till return <0 --> is fully visible again
-        else if ( m_time_till_return <=1.0f )
+        else if ( m_ticks_till_return <= stk_config->time2Ticks(1.0f) )
         {
             if (m_node != NULL)
             {
                 // Make it visible by scaling it from 0 to 1:
                 m_node->setVisible(true);
-                m_node->setScale(core::vector3df(1,1,1)*(1-m_time_till_return));
+                float t = stk_config->ticks2Time(m_ticks_till_return);
+                m_node->setScale(core::vector3df(1,1,1)*(1-t));
             }
         }   // time till return < 1
     }   // if collected
@@ -337,8 +338,11 @@ void Item::update(float dt)
 
         if(!m_rotate || m_node == NULL) return;
         // have it rotate
-        if(!RewindManager::get()->isRewinding())
+        if (!RewindManager::get()->isRewinding())
+        {
+            float dt = stk_config->ticks2Time(ticks);
             m_rotation_angle += dt * M_PI;
+        }
         if (m_rotation_angle > M_PI * 2) m_rotation_angle -= M_PI * 2;
 
         btMatrix3x3 m;
@@ -364,7 +368,7 @@ void Item::collected(const AbstractKart *kart, float t)
     m_event_handler = kart;
     if(m_type==ITEM_EASTER_EGG)
     {
-        m_time_till_return=99999;
+        m_ticks_till_return=stk_config->time2Ticks(99999);
         EasterEggHunt *world = dynamic_cast<EasterEggHunt*>(World::getWorld());
         assert(world);
         world->collectedEasterEgg(kart);
@@ -379,16 +383,16 @@ void Item::collected(const AbstractKart *kart, float t)
         // Deactivates the item for a certain amount of time. It is used to
         // prevent bubble gum from hitting a kart over and over again (in each
         // frame) by giving it time to drive away.
-        m_deactive_time = 0.5f;
+        m_deactive_ticks = stk_config->time2Ticks(0.5f);
         // Set the time till reappear to -1 seconds --> the item will
         // reappear immediately.
-        m_time_till_return = -1;
+        m_ticks_till_return = -1;
     }
     else
     {
         // Note if the time is negative, in update the m_collected flag will
         // be automatically set to false again.
-        m_time_till_return = t;
+        m_ticks_till_return = stk_config->time2Ticks(t);
         if (m_node != NULL)
         {
             m_node->setVisible(false);
@@ -402,7 +406,7 @@ void Item::collected(const AbstractKart *kart, float t)
 
     if (dynamic_cast<ThreeStrikesBattle*>(World::getWorld()) != NULL)
     {
-        m_time_till_return *= 3;
+        m_ticks_till_return *= 3;
     }
 }   // isCollected
 
diff --git a/src/items/item.hpp b/src/items/item.hpp
index aaa454a15..0c0db0edf 100644
--- a/src/items/item.hpp
+++ b/src/items/item.hpp
@@ -111,7 +111,7 @@ private:
     bool          m_collected;
 
     /** Time till a collected item reappears. */
-    float         m_time_till_return;
+    int           m_ticks_till_return;
 
     /** Scene node of this item. */
     LODNode *m_node;
@@ -131,7 +131,7 @@ private:
     bool          m_rotate;
 
     /** Optionally set this if this item was laid by a particular kart. in
-     *  this case the 'm_deactive_time' will also be set - see below. */
+     *  this case the 'm_deactive_ticks' will also be set - see below. */
     const AbstractKart   *m_event_handler;
 
     /** Kart that emitted this item if any */
@@ -139,7 +139,7 @@ private:
 
     /** Optionally if item was placed by a kart, a timer can be used to
      *  temporarly deactivate collision so a kart is not hit by its own item */
-    float         m_deactive_time;
+    int           m_deactive_ticks;
 
     /** Counts how often an item is used before it disappears. Used for
      *  bubble gum to make them disappear after a while. A value >0
@@ -176,7 +176,7 @@ public:
                   Item(const Vec3& xyz, float distance,
                        TriggerItemListener* trigger);
     virtual       ~Item ();
-    void          update  (float delta);
+    void          update(int ticks);
     virtual void  collected(const AbstractKart *kart, float t=2.0f);
     void          setParent(AbstractKart* parent);
     void          reset();
@@ -195,7 +195,7 @@ public:
      */
     bool hitKart(const Vec3 &xyz, const AbstractKart *kart=NULL) const
     {
-        if (m_event_handler == kart && m_deactive_time > 0)
+        if (m_event_handler == kart && m_deactive_ticks > 0)
             return false;
         Vec3 lc = quatRotate(m_original_rotation, xyz - m_xyz);
         // Don't be too strict if the kart is a bit above the item
@@ -216,7 +216,7 @@ protected:
     bool hitLine(const core::line3df &line,
                   const AbstractKart *kart=NULL) const
     {
-        if(m_event_handler==kart && m_deactive_time >0) return false;
+        if(m_event_handler==kart && m_deactive_ticks >0) return false;
 
         Vec3 closest = line.getClosestPoint(m_xyz.toIrrVector());
         return hitKart(closest, kart);
@@ -251,10 +251,10 @@ public:
      *  details.
      *  \param f Time till the item can be used again.
      */
-    void          setDisableTime(float f) { m_time_till_return = f; }
+    void          setDisableTicks(int t) { m_ticks_till_return = t; }
     // ------------------------------------------------------------------------
     /** Returns the time the item is disabled for. */
-    float         getDisableTime() const { return m_time_till_return; }
+    int           getDisableTicks() const { return m_ticks_till_return; }
     // ------------------------------------------------------------------------
     /** Returns the XYZ position of the item. */
     const Vec3&   getXYZ() const { return m_xyz; }
diff --git a/src/items/item_manager.cpp b/src/items/item_manager.cpp
index 591b83804..76a73d9d4 100644
--- a/src/items/item_manager.cpp
+++ b/src/items/item_manager.cpp
@@ -156,7 +156,7 @@ void ItemManager::removeTextures()
  *  of each race. */
 ItemManager::ItemManager()
 {
-    m_switch_time = -1.0f;
+    m_switch_ticks = -1;
     // The actual loading is done in loadDefaultItems
 
     // Prepare the switch to array, which stores which item should be
@@ -266,7 +266,7 @@ Item* ItemManager::newItem(Item::ItemType type, const Vec3& xyz,
 
     insertItem(item);
     if(parent != NULL) item->setParent(parent);
-    if(m_switch_time>=0)
+    if(m_switch_ticks>=0)
     {
         Item::ItemType new_type = m_switch_to[item->getType()];
         item->switchTo(new_type, m_item_mesh[(int)new_type],
@@ -354,14 +354,14 @@ void  ItemManager::checkItemHit(AbstractKart* kart)
 void ItemManager::reset()
 {
     // If items are switched, switch them back first.
-    if(m_switch_time>=0)
+    if(m_switch_ticks>=0)
     {
         for(AllItemTypes::iterator i =m_all_items.begin();
                                    i!=m_all_items.end(); i++)
         {
             if(*i) (*i)->switchBack();
         }
-        m_switch_time = -1.0f;
+        m_switch_ticks = -1;
 
     }
 
@@ -388,36 +388,36 @@ void ItemManager::reset()
         }
     }  // whilem_all_items.end() i
 
-    m_switch_time = -1;
+    m_switch_ticks = -1;
 }   // reset
 
 //-----------------------------------------------------------------------------
 /** Updates all items, and handles switching items back if the switch time
  *  is over.
- *  \param dt Time step.
+ *  \param ticks Number of physics time steps - should be 1.
  */
-void ItemManager::update(float dt)
+void ItemManager::update(int ticks)
 {
     // If switch time is over, switch all items back
-    if(m_switch_time>=0)
+    if(m_switch_ticks>=0)
     {
-        m_switch_time -= dt;
-        if(m_switch_time<0)
+        m_switch_ticks -= ticks;
+        if(m_switch_ticks<0)
         {
             for(AllItemTypes::iterator i =m_all_items.begin();
                 i!=m_all_items.end();  i++)
             {
                 if(*i) (*i)->switchBack();
             }   // for m_all_items
-        }   // m_switch_time < 0
-    }   // m_switch_time>=0
+        }   // m_switch_ticks < 0
+    }   // m_switch_ticks>=0
 
     for(AllItemTypes::iterator i =m_all_items.begin();
         i!=m_all_items.end();  i++)
     {
         if(*i)
         {
-            (*i)->update(dt);
+            (*i)->update(ticks);
             if( (*i)->isUsedUp())
             {
                 deleteItem( *i );
@@ -472,16 +472,16 @@ void ItemManager::switchItems()
 
         Item::ItemType new_type = m_switch_to[(*i)->getType()];
 
-        if(m_switch_time<0)
+        if(m_switch_ticks<0)
             (*i)->switchTo(new_type, m_item_mesh[(int)new_type], m_item_lowres_mesh[(int)new_type]);
         else
             (*i)->switchBack();
     }   // for m_all_items
 
-    // if the items are already switched (m_switch_time >=0)
-    // then switch back, and set m_switch_time to -1 to indicate
+    // if the items are already switched (m_switch_ticks >=0)
+    // then switch back, and set m_switch_ticks to -1 to indicate
     // that the items are now back to normal.
-    m_switch_time = m_switch_time < 0 ? stk_config->m_item_switch_time : -1;
+    m_switch_ticks = m_switch_ticks < 0 ? stk_config->m_item_switch_ticks : -1;
 
 }   // switchItems
 
diff --git a/src/items/item_manager.hpp b/src/items/item_manager.hpp
index cba0bb814..25ec3883b 100644
--- a/src/items/item_manager.hpp
+++ b/src/items/item_manager.hpp
@@ -90,7 +90,7 @@ private:
 
     /** Remaining time that items should remain switched. If the
      *  value is <0, it indicates that the items are not switched atm. */
-    float m_switch_time;
+    int m_switch_ticks;
 
     void  insertItem(Item *item);
     void  deleteItem(Item *item);
@@ -106,7 +106,7 @@ public:
                                     AbstractKart* parent=NULL);
     Item*          newItem         (const Vec3& xyz, float distance,
                                     TriggerItemListener* listener);
-    void           update          (float delta);
+    void           update          (int ticks);
     void           checkItemHit    (AbstractKart* kart);
     void           reset           ();
     void           collectedItem   (Item *item, AbstractKart *kart,
diff --git a/src/items/plunger.cpp b/src/items/plunger.cpp
index d72615fd5..65501a6d8 100644
--- a/src/items/plunger.cpp
+++ b/src/items/plunger.cpp
@@ -122,24 +122,24 @@ void Plunger::init(const XMLNode &node, scene::IMesh *plunger_model)
  *  \param dt Time step size.
  *  \returns True of this object should be removed.
  */
-bool Plunger::updateAndDelete(float dt)
+bool Plunger::updateAndDelete(int ticks)
 {
     // In keep-alive mode, just update the rubber band
     if(m_keep_alive >= 0)
     {
-        m_keep_alive -= dt;
+        m_keep_alive -= ticks;
         if(m_keep_alive<=0)
         {
             setHasHit();
             return true;
         }
-        if(m_rubber_band != NULL) m_rubber_band->update(dt);
+        if(m_rubber_band != NULL) m_rubber_band->update(ticks);
         return false;
     }
 
     // Else: update the flyable and rubber band
-    bool ret = Flyable::updateAndDelete(dt);
-    if(m_rubber_band != NULL) m_rubber_band->update(dt);
+    bool ret = Flyable::updateAndDelete(ticks);
+    if(m_rubber_band != NULL) m_rubber_band->update(ticks);
 
     return ret;
 
@@ -179,11 +179,12 @@ bool Plunger::hit(AbstractKart *kart, PhysicalObject *obj)
     }
     else
     {
-        m_keep_alive = m_owner->getKartProperties()->getPlungerBandDuration();
+        m_keep_alive = stk_config->time2Ticks(m_owner->getKartProperties()
+                                             ->getPlungerBandDuration()    );
 
-        // Make this object invisible by placing it faaar down. Not that if this
-        // objects is simply removed from the scene graph, it might be auto-deleted
-        // because the ref count reaches zero.
+        // Make this object invisible by placing it faaar down. Not that if
+        // this objects is simply removed from the scene graph, it might be
+        // auto-deleted because the ref count reaches zero.
         scene::ISceneNode *node = getNode();
         if(node)
         {
diff --git a/src/items/plunger.hpp b/src/items/plunger.hpp
index e8cdb7815..91283a3c2 100644
--- a/src/items/plunger.hpp
+++ b/src/items/plunger.hpp
@@ -40,8 +40,10 @@ class Plunger : public Flyable
 private:
     /** The rubber band attached to a plunger. */
     RubberBand  *m_rubber_band;
-    /** Timer to keep the plunger alive while the rubber band is working. */
-    float        m_keep_alive;
+
+    /** Ticks to keep the plunger alive while the rubber band is working. */
+    int         m_keep_alive;
+
     btVector3    m_initial_velocity;
 
     bool m_reverse_mode;
@@ -49,7 +51,7 @@ public:
                  Plunger(AbstractKart *kart);
                 ~Plunger();
     static  void init(const XMLNode &node, scene::IMesh* missile);
-    virtual bool updateAndDelete(float dt);
+    virtual bool updateAndDelete(int ticks);
     virtual void hitTrack ();
     virtual bool hit      (AbstractKart *kart, PhysicalObject *obj=NULL);
 
@@ -57,7 +59,7 @@ public:
     /** Sets the keep-alive value. Setting it to 0 will remove the plunger
      *  at the next update - which is used if the rubber band snaps.
      */
-    void         setKeepAlive(float t) {m_keep_alive = t;}
+    void setKeepAlive(int ticks) {m_keep_alive = ticks;}
     // ------------------------------------------------------------------------
     /** No hit effect when it ends. */
     virtual HitEffect *getHitEffect() const {return NULL; }
diff --git a/src/items/projectile_manager.cpp b/src/items/projectile_manager.cpp
index 709ca4135..9ea86c4c4 100644
--- a/src/items/projectile_manager.cpp
+++ b/src/items/projectile_manager.cpp
@@ -63,9 +63,9 @@ void ProjectileManager::cleanup()
 
 // -----------------------------------------------------------------------------
 /** General projectile update call. */
-void ProjectileManager::update(float dt)
+void ProjectileManager::update(int ticks)
 {
-    updateServer(dt);
+    updateServer(ticks);
 
     HitEffects::iterator he = m_active_hit_effects.begin();
     while(he!=m_active_hit_effects.end())
@@ -77,7 +77,7 @@ void ProjectileManager::update(float dt)
             he = next;
         }
         // Update this hit effect. If it can be removed, remove it.
-        else if((*he)->updateAndDelete(dt))
+        else if((*he)->updateAndDelete(ticks))
         {
             delete *he;
             HitEffects::iterator next = m_active_hit_effects.erase(he);
@@ -90,12 +90,12 @@ void ProjectileManager::update(float dt)
 
 // -----------------------------------------------------------------------------
 /** Updates all rockets on the server (or no networking). */
-void ProjectileManager::updateServer(float dt)
+void ProjectileManager::updateServer(int ticks)
 {
     Projectiles::iterator p = m_active_projectiles.begin();
     while(p!=m_active_projectiles.end())
     {
-        bool can_be_deleted = (*p)->updateAndDelete(dt);
+        bool can_be_deleted = (*p)->updateAndDelete(ticks);
         if(can_be_deleted)
         {
             HitEffect *he = (*p)->getHitEffect();
diff --git a/src/items/projectile_manager.hpp b/src/items/projectile_manager.hpp
index 8fcdb0c4e..0f2da9399 100644
--- a/src/items/projectile_manager.hpp
+++ b/src/items/projectile_manager.hpp
@@ -52,13 +52,13 @@ private:
      *  being shown or have a sfx playing. */
     HitEffects       m_active_hit_effects;
 
-    void             updateServer(float dt);
+    void             updateServer(int ticks);
 public:
                      ProjectileManager() {}
                     ~ProjectileManager() {}
     void             loadData         ();
     void             cleanup          ();
-    void             update           (float dt);
+    void             update           (int ticks);
     Flyable*         newProjectile    (AbstractKart *kart,
                                        PowerupManager::PowerupType type);
     void             Deactivate       (Flyable *p) {}
diff --git a/src/items/rubber_ball.cpp b/src/items/rubber_ball.cpp
index 11a51f1a4..d65929f43 100644
--- a/src/items/rubber_ball.cpp
+++ b/src/items/rubber_ball.cpp
@@ -42,7 +42,7 @@ float RubberBall::m_st_squash_duration;
 float RubberBall::m_st_squash_slowdown;
 float RubberBall::m_st_target_distance;
 float RubberBall::m_st_target_max_angle;
-float RubberBall::m_st_delete_time;
+int   RubberBall::m_st_delete_ticks;
 float RubberBall::m_st_max_height_difference;
 float RubberBall::m_st_fast_ping_distance;
 float RubberBall::m_st_early_target_factor;
@@ -75,7 +75,7 @@ RubberBall::RubberBall(AbstractKart *kart)
 
     // Do not adjust the up velocity
     setAdjustUpVelocity(false);
-    m_max_lifespan       = 9999;
+    m_max_lifespan       = stk_config->time2Ticks(9999);
     m_target             = NULL;
     m_aiming_at_target   = false;
     m_fast_ping          = false;
@@ -89,7 +89,7 @@ RubberBall::RubberBall(AbstractKart *kart)
     m_previous_xyz       = m_owner->getXYZ();
     m_previous_height    = 2.0f;  //
     // A negative value indicates that the timer is not active
-    m_delete_timer       = -1.0f;
+    m_delete_ticks       = -1;
     m_tunnel_count       = 0;
 
     LinearWorld *world = dynamic_cast<LinearWorld*>(World::getWorld());
@@ -173,13 +173,13 @@ void RubberBall::computeTarget()
         {
             // If the firing kart itself is the first kart (that is
             // still driving), prepare to remove the rubber ball
-            if(m_target==m_owner && m_delete_timer < 0)
+            if(m_target==m_owner && m_delete_ticks < 0)
             {
 #ifdef PRINT_BALL_REMOVE_INFO
                 Log::debug("[RubberBall]",
                            "ball %d removed because owner is target.", m_id);
 #endif
-                m_delete_timer = m_st_delete_time;
+                m_delete_ticks = m_st_delete_ticks;
             }
             return;
         }
@@ -192,7 +192,7 @@ void RubberBall::computeTarget()
     Log::debug("[RubberBall]" "ball %d removed because no more active target.",
                m_id);
 #endif
-    m_delete_timer = m_st_delete_time;
+    m_delete_ticks = m_st_delete_ticks;
     m_target       = m_owner;
 }   // computeTarget
 
@@ -268,7 +268,7 @@ void RubberBall::init(const XMLNode &node, scene::IMesh *rubberball)
     m_st_min_interpolation_distance = 30.0f;
     m_st_target_distance            = 50.0f;
     m_st_target_max_angle           = 25.0f;
-    m_st_delete_time                = 10.0f;
+    m_st_delete_ticks               = stk_config->time2Ticks(10.0f);
     m_st_max_height_difference      = 10.0f;
     m_st_fast_ping_distance         = 50.0f;
     m_st_early_target_factor        =  1.0f;
@@ -288,8 +288,10 @@ void RubberBall::init(const XMLNode &node, scene::IMesh *rubberball)
     if(!node.get("target-distance", &m_st_target_distance))
         Log::warn("powerup",
                   "No target-distance specified for rubber ball.");
-    if(!node.get("delete-time", &m_st_delete_time))
+    float f;
+    if(!node.get("delete-time", &f))
         Log::warn("powerup", "No delete-time specified for rubber ball.");
+    m_st_delete_ticks = stk_config->time2Ticks(f);
     if(!node.get("target-max-angle", &m_st_target_max_angle))
         Log::warn("powerup", "No target-max-angle specified for rubber ball.");
     m_st_target_max_angle *= DEGREE_TO_RAD;
@@ -318,17 +320,17 @@ void RubberBall::init(const XMLNode &node, scene::IMesh *rubberball)
  *  \param dt Time step size.
  *  \returns True if the rubber ball should be removed.
  */
-bool RubberBall::updateAndDelete(float dt)
+bool RubberBall::updateAndDelete(int ticks)
 {
     LinearWorld *world = dynamic_cast<LinearWorld*>(World::getWorld());
     // FIXME: what does the rubber ball do in case of battle mode??
     if(!world) return true;
 
     
-    if(m_delete_timer>0)
+    if(m_delete_ticks>0)
     {
-        m_delete_timer -= dt;
-        if(m_delete_timer<=0)
+        m_delete_ticks -= 1;
+        if(m_delete_ticks<=0)
         {
             hit(NULL);
 #ifdef PRINT_BALL_REMOVE_INFO
@@ -343,7 +345,7 @@ bool RubberBall::updateAndDelete(float dt)
         // Flyable will call update() of the animation to 
         // update the ball's position.
         m_previous_xyz = getXYZ();
-        return Flyable::updateAndDelete(dt);
+        return Flyable::updateAndDelete(ticks);
     }
 
     // Update the target in case that the first kart was overtaken (or has
@@ -355,9 +357,9 @@ bool RubberBall::updateAndDelete(float dt)
     // since it still needs to be adjusted for the height of the terrain.
     Vec3 next_xyz;
     if(m_aiming_at_target)
-        moveTowardsTarget(&next_xyz, dt);
+        moveTowardsTarget(&next_xyz, ticks);
     else
-        interpolate(&next_xyz, dt);
+        interpolate(&next_xyz, ticks);
 
     // If the ball is close to the ground, we have to start the raycast
     // slightly higher (to avoid that the ball tunnels through the floor).
@@ -374,7 +376,7 @@ bool RubberBall::updateAndDelete(float dt)
     // Flyable::update for rubber balls.
     TerrainInfo::update(next_xyz + getNormal()*vertical_offset, -getNormal());
 
-    m_height_timer += dt;
+    m_height_timer += stk_config->ticks2Time(ticks);
     float height    = updateHeight()+m_extend.getY()*0.5f;
     
     if(UserConfigParams::logFlyable())
@@ -426,7 +428,7 @@ bool RubberBall::updateAndDelete(float dt)
     // Determine new distance along track
     TrackSector::update(next_xyz);
 
-    return Flyable::updateAndDelete(dt);
+    return Flyable::updateAndDelete(ticks);
 }   // updateAndDelete
 
 // ----------------------------------------------------------------------------
@@ -434,9 +436,9 @@ bool RubberBall::updateAndDelete(float dt)
  *  once the rubber ball is close to its target. It restricts the angle by
  *  which the rubber ball can change its direction per frame.
  *  \param next_xyz The position the ball should move to.
- *  \param dt Time step size.
+ *  \param ticks Number of physics steps - should be 1.
  */
-void RubberBall::moveTowardsTarget(Vec3 *next_xyz, float dt)
+void RubberBall::moveTowardsTarget(Vec3 *next_xyz, int ticks)
 {
     // If the rubber ball is already close to a target, i.e. aiming
     // at it directly, stop interpolating, instead fly straight
@@ -447,7 +449,11 @@ void RubberBall::moveTowardsTarget(Vec3 *next_xyz, float dt)
     if(diff.length2()==0)
         *next_xyz = getXYZ() - getNormal()*m_previous_height;
     else
-        *next_xyz = getXYZ() - getNormal()*m_previous_height +(dt*m_speed / diff.length())*diff;
+    {
+        float dt = stk_config->ticks2Time(ticks);
+        *next_xyz = getXYZ() - getNormal()*m_previous_height
+                             + (dt*m_speed / diff.length())*diff;
+    }
 
     // If ball is close to the target, then explode
     if (diff.length() < m_target->getKartLength()) 
@@ -467,10 +473,11 @@ void RubberBall::moveTowardsTarget(Vec3 *next_xyz, float dt)
  *  \param next_xyz Returns the new position.
  *  \param The time step size.
  */
-void RubberBall::interpolate(Vec3 *next_xyz, float dt)
+void RubberBall::interpolate(Vec3 *next_xyz, int ticks)
 {
     // If we have reached or overshot the next control point, move to the
     // the next section of the spline
+    float dt = stk_config->ticks2Time(ticks);
     m_t += m_t_increase * dt;
     if(m_t > 1.0f)
     {
@@ -673,7 +680,7 @@ void RubberBall::updateDistanceToTarget()
         // original target, and start deleting it.
         if(m_distance_to_target > 0.9f * Track::getCurrentTrack()->getTrackLength())
         {
-            m_delete_timer = m_st_delete_time;
+            m_delete_ticks = m_st_delete_ticks;
 #ifdef PRINT_BALL_REMOVE_INFO
             Log::debug("[RubberBall]", "ball %d lost target (overtook?).",
                         m_id);
diff --git a/src/items/rubber_ball.hpp b/src/items/rubber_ball.hpp
index c48130ee2..b2eb8e6fb 100644
--- a/src/items/rubber_ball.hpp
+++ b/src/items/rubber_ball.hpp
@@ -23,6 +23,7 @@
 
 #include "items/flyable.hpp"
 #include "tracks/track_sector.hpp"
+#include "utils/cpp2011.hpp"
 
 class AbstractKart;
 class SFXBase;
@@ -79,7 +80,7 @@ private:
     /** If the ball overtakes its target or starts to aim at the kart which
      *  originally shot the rubber ball, after this amount of time the
      *  ball will be deleted. */
-    static float m_st_delete_time;
+    static int m_st_delete_ticks;
 
     /** Timer before another rubber ball can be picked up. This is to ensure
      *  that there are not too many rubber balls on the track in races with many
@@ -166,7 +167,7 @@ private:
      *  originally shot the rubber ball, after a certain amount of time the
      *  ball will be deleted. This timer tracks this time. If it is < 0
      *  it indicates that the ball is targeting another kart atm. */
-    float        m_delete_timer;
+    int          m_delete_ticks;
 
     /** The current maximum height of the ball. This value will be
      *  reduced if the ball gets closer to the target. */
@@ -192,8 +193,8 @@ private:
                                          float *f=NULL);
     void         getNextControlPoint();
     float        updateHeight();
-    void         interpolate(Vec3 *next_xyz, float dt);
-    void         moveTowardsTarget(Vec3 *next_xyz, float dt);
+    void         interpolate(Vec3 *next_xyz, int ticks);
+    void         moveTowardsTarget(Vec3 *next_xyz, int ticks);
     void         initializeControlPoints(const Vec3 &xyz);
     float        getTunnelHeight(const Vec3 &next_xyz, 
                                      const float vertical_offset) const;
@@ -202,7 +203,7 @@ public:
                  RubberBall  (AbstractKart* kart);
     virtual     ~RubberBall();
     static  void init(const XMLNode &node, scene::IMesh *rubberball);
-    virtual bool updateAndDelete(float dt);
+    virtual bool updateAndDelete(int ticks) OVERRIDE;
     virtual bool hit(AbstractKart* kart, PhysicalObject* obj=NULL);
     virtual void setAnimation(AbstractKartAnimation *animation);
     // ------------------------------------------------------------------------
diff --git a/src/items/rubber_band.cpp b/src/items/rubber_band.cpp
index 1d8623722..e22435b57 100644
--- a/src/items/rubber_band.cpp
+++ b/src/items/rubber_band.cpp
@@ -146,7 +146,7 @@ void RubberBand::updatePosition()
  *  so, an explosion is triggered.
  *  \param dt: Time step size.
  */
-void RubberBand::update(float dt)
+void RubberBand::update(int ticks)
 {
     const KartProperties *kp = m_owner->getKartProperties();
 
@@ -155,7 +155,7 @@ void RubberBand::update(float dt)
         // Rubber band snaps
         m_plunger->hit(NULL);
         // This causes the plunger to be removed at the next update
-        m_plunger->setKeepAlive(0.0f);
+        m_plunger->setKeepAlive(0);
         return;
     }
 
@@ -171,7 +171,7 @@ void RubberBand::update(float dt)
         // Rubber band snaps
         m_plunger->hit(NULL);
         // This causes the plunger to be removed at the next update
-        m_plunger->setKeepAlive(0.0f);
+        m_plunger->setKeepAlive(0);
     }
 
     // Apply forces (if applicable)
@@ -187,7 +187,7 @@ void RubberBand::update(float dt)
             // Rubber band snaps
             m_plunger->hit(NULL);
             // This causes the plunger to be removed at the next update
-            m_plunger->setKeepAlive(0.0f);
+            m_plunger->setKeepAlive(0);
             return;
         }
 
@@ -196,8 +196,8 @@ void RubberBand::update(float dt)
         m_owner->increaseMaxSpeed(MaxSpeed::MS_INCREASE_RUBBER,
             kp->getPlungerBandSpeedIncrease(),
             /*engine_force*/ 0.0f,
-            /*duration*/0.1f,
-            kp->getPlungerBandFadeOutTime());
+            /*duration*/stk_config->time2Ticks(0.1f),
+            kp->getPlungerBandFadeOutTicks());
         if(m_attached_state==RB_TO_KART)
             m_hit_kart->getBody()->applyCentralForce(diff*(-force));
     }
@@ -260,7 +260,7 @@ void RubberBand::hit(AbstractKart *kart_hit, const Vec3 *track_xyz)
         if(kart_hit->isShielded())
         {
             kart_hit->decreaseShieldTime();
-            m_plunger->setKeepAlive(0.0f);
+            m_plunger->setKeepAlive(0);
 
             return;
         }
diff --git a/src/items/rubber_band.hpp b/src/items/rubber_band.hpp
index b4edb43eb..037bab03a 100644
--- a/src/items/rubber_band.hpp
+++ b/src/items/rubber_band.hpp
@@ -66,7 +66,7 @@ private:
 public:
          RubberBand(Plunger *plunger, AbstractKart *kart);
         ~RubberBand();
-    void update(float dt);
+    void update(int ticks);
     void hit(AbstractKart *kart_hit, const Vec3 *track_xyz=NULL);
 };   // RubberBand
 #endif
diff --git a/src/items/swatter.cpp b/src/items/swatter.cpp
index f2b73ce6a..b8c5cc3a5 100644
--- a/src/items/swatter.cpp
+++ b/src/items/swatter.cpp
@@ -114,8 +114,9 @@ Swatter::~Swatter()
  *  \param dt Time step size.
  *  \return True if the attachment should be discarded.
  */
-bool Swatter::updateAndTestFinished(float dt)
+bool Swatter::updateAndTestFinished(int ticks)
 {
+    float dt = stk_config->ticks2Time(ticks);
     if (!m_discard_now)
     {
         if (m_removing_bomb)
diff --git a/src/items/swatter.hpp b/src/items/swatter.hpp
index 1fc1fd2dd..d113f5d70 100644
--- a/src/items/swatter.hpp
+++ b/src/items/swatter.hpp
@@ -21,6 +21,7 @@
 
 #include "config/stk_config.hpp"
 #include "items/attachment_plugin.hpp"
+#include "utils/cpp2011.hpp"
 #include "utils/no_copy.hpp"
 #include "utils/random_generator.hpp"
 
@@ -79,7 +80,7 @@ public:
              Swatter(AbstractKart *kart, bool was_bomb,
                      scene::ISceneNode* bomb_scene_node);
     virtual ~Swatter();
-    bool     updateAndTestFinished(float dt);
+    bool     updateAndTestFinished(int ticks) OVERRIDE;
 
     // ------------------------------------------------------------------------
     /** Returns if the swatter is currently aiming, i.e. can be used to
diff --git a/src/karts/abstract_characteristic.cpp b/src/karts/abstract_characteristic.cpp
index e520ea393..3826e3bbc 100644
--- a/src/karts/abstract_characteristic.cpp
+++ b/src/karts/abstract_characteristic.cpp
@@ -1496,7 +1496,7 @@ float AbstractCharacteristic::getSlipstreamWidth() const
 }  // getSlipstreamWidth
 
 // ----------------------------------------------------------------------------
-float AbstractCharacteristic::getSlipstreamCollectTime() const
+int AbstractCharacteristic::getSlipstreamCollectTicks() const
 {
     float result;
     bool is_set = false;
@@ -1504,8 +1504,8 @@ float AbstractCharacteristic::getSlipstreamCollectTime() const
     if (!is_set)
         Log::fatal("AbstractCharacteristic", "Can't get characteristic %s",
                     getName(SLIPSTREAM_COLLECT_TIME).c_str());
-    return result;
-}  // getSlipstreamCollectTime
+    return stk_config->time2Ticks(result);
+}  // getSlipstreamCollectTicks
 
 // ----------------------------------------------------------------------------
 float AbstractCharacteristic::getSlipstreamUseTime() const
diff --git a/src/karts/abstract_characteristic.hpp b/src/karts/abstract_characteristic.hpp
index 7cdc897f8..9727f9231 100644
--- a/src/karts/abstract_characteristic.hpp
+++ b/src/karts/abstract_characteristic.hpp
@@ -362,7 +362,7 @@ public:
     float getSlipstreamDuration() const;
     float getSlipstreamLength() const;
     float getSlipstreamWidth() const;
-    float getSlipstreamCollectTime() const;
+    int   getSlipstreamCollectTicks() const;
     float getSlipstreamUseTime() const;
     float getSlipstreamAddPower() const;
     float getSlipstreamMinSpeed() const;
diff --git a/src/karts/abstract_kart.hpp b/src/karts/abstract_kart.hpp
index 2baa13afc..84cc4212f 100644
--- a/src/karts/abstract_kart.hpp
+++ b/src/karts/abstract_kart.hpp
@@ -253,7 +253,7 @@ public:
     virtual float getFinishTime() const = 0;
     // ------------------------------------------------------------------------
     /** Returns true if the kart has a plunger attached to its face. */
-    virtual float getBlockedByPlungerTime() const = 0;
+    virtual int getBlockedByPlungerTicks() const = 0;
     // ------------------------------------------------------------------------
     /** Sets that the view is blocked by a plunger. The duration depends on
      *  the difficulty, see KartPorperties getPlungerInFaceTime. */
@@ -285,7 +285,7 @@ public:
      *  category. Not pure abstract, since there is no need to implement this
      *  e.g. in Ghost.
      *  \param category Which category to report on. */
-    virtual float getSpeedIncreaseTimeLeft(unsigned int category) const = 0;
+    virtual int getSpeedIncreaseTicksLeft(unsigned int category) const = 0;
     // ------------------------------------------------------------------------
     /** Sets an increased maximum speed for a category.
      *  \param category The category for which to set the higher maximum speed.
@@ -295,15 +295,15 @@ public:
      *  \param fade_out_time How long the maximum speed will fade out linearly.
      */
     virtual void increaseMaxSpeed(unsigned int category, float add_speed,
-                                  float engine_force, float duration,
-                                  float fade_out_time) = 0;
+                                  float engine_force, int duration,
+                                  int fade_out_time) = 0;
     // ------------------------------------------------------------------------
     /** Defines a slowdown, which is in fraction of top speed.
      *  \param category The category for which the speed is increased.
      *  \param max_speed_fraction Fraction of top speed to allow only.
      *  \param fade_in_time How long till maximum speed is capped. */
     virtual void setSlowdown(unsigned int category, float max_speed_fraction,
-                             float fade_in_time) = 0;
+                             int fade_in_time) = 0;
     // ------------------------------------------------------------------------
     /** Returns the remaining collected energy. */
     virtual float getEnergy() const = 0;
@@ -364,7 +364,7 @@ public:
     /** Return whether nitro is being used despite the nitro button not being
      *  pressed due to minimal use time requirements
      */
-    virtual float isOnMinNitroTime() const = 0;
+    virtual bool isOnMinNitroTime() const = 0;
     // ------------------------------------------------------------------------
     /** Returns the current material the kart is on. */
     virtual const Material *getMaterial() const = 0;
@@ -412,7 +412,7 @@ public:
     /** Returns if the kart is invulnerable. */
     virtual bool isInvulnerable() const = 0;
     // ------------------------------------------------------------------------
-    virtual void setInvulnerableTime(float t) = 0;
+    virtual void setInvulnerableTicks(int ticks) = 0;
     // ------------------------------------------------------------------------
     /** Returns if the kart is protected by a shield. */
     virtual bool isShielded() const = 0;
@@ -459,8 +459,8 @@ public:
     virtual void setOnScreenText(const wchar_t *text) = 0;
     // ------------------------------------------------------------------------- 
     /** Counter which is used for displaying wrong way message after a delay */
-    virtual float getWrongwayCounter() = 0;
-    virtual void setWrongwayCounter(float counter) = 0;
+    virtual int getWrongwayCounter() = 0;
+    virtual void setWrongwayCounter(int counter) = 0;
     // ------------------------------------------------------------------------
     /** Returns whether this kart wins or loses. */
     virtual bool getRaceResult() const = 0;
diff --git a/src/karts/controller/ai_base_controller.cpp b/src/karts/controller/ai_base_controller.cpp
index 0c6746868..e71168c86 100644
--- a/src/karts/controller/ai_base_controller.cpp
+++ b/src/karts/controller/ai_base_controller.cpp
@@ -53,7 +53,7 @@ void AIBaseController::reset()
 
 //-----------------------------------------------------------------------------
 
-void AIBaseController::update(float dt)
+void AIBaseController::update(int ticks)
 {
     m_stuck = false;
 }
@@ -193,7 +193,7 @@ void AIBaseController::setSteering(float angle, float dt)
     if     (steer_fraction >  1.0f) steer_fraction =  1.0f;
     else if(steer_fraction < -1.0f) steer_fraction = -1.0f;
 
-    if(m_kart->getBlockedByPlungerTime()>0)
+    if(m_kart->getBlockedByPlungerTicks()>0)
     {
         if     (steer_fraction >  0.5f) steer_fraction =  0.5f;
         else if(steer_fraction < -0.5f) steer_fraction = -0.5f;
diff --git a/src/karts/controller/ai_base_controller.hpp b/src/karts/controller/ai_base_controller.hpp
index 432381f71..5aaaa10e1 100644
--- a/src/karts/controller/ai_base_controller.hpp
+++ b/src/karts/controller/ai_base_controller.hpp
@@ -75,7 +75,7 @@ protected:
     // ------------------------------------------------------------------------
     void         determineTurnRadius(const Vec3 &end, Vec3 *center,
                                      float *radius) const;
-    virtual void update      (float delta);
+    virtual void update(int ticks);
     virtual void setSteering   (float angle, float dt);
     // ------------------------------------------------------------------------
     /** Return true if AI can skid now. */
diff --git a/src/karts/controller/ai_base_lap_controller.cpp b/src/karts/controller/ai_base_lap_controller.cpp
index cfda6ad87..1afea29a5 100644
--- a/src/karts/controller/ai_base_lap_controller.cpp
+++ b/src/karts/controller/ai_base_lap_controller.cpp
@@ -195,11 +195,11 @@ void AIBaseLapController::computePath()
 /** Updates the ai base controller each time step. Note that any calls to
  *  isStuck() must be done before update is called, since update will call
  *  AIBaseController::update() which will reset the isStuck flag!
- *  \param dt Time step size.
+ *  \param ticks Number of physics time steps - should be 1.
  */
-void AIBaseLapController::update(float dt)
+void AIBaseLapController::update(int ticks)
 {
-    AIBaseController::update(dt);
+    AIBaseController::update(ticks);
     if(DriveGraph::get())
     {
         // Update the current node:
@@ -252,7 +252,7 @@ float AIBaseLapController::steerToAngle(const unsigned int sector,
     //Desired angle minus current angle equals how many angles to turn
     float steer_angle = angle - m_kart->getHeading();
 
-    if(m_kart->getBlockedByPlungerTime()>0)
+    if(m_kart->getBlockedByPlungerTicks()>0)
         steer_angle += add_angle*0.2f;
     else
         steer_angle += add_angle;
diff --git a/src/karts/controller/ai_base_lap_controller.hpp b/src/karts/controller/ai_base_lap_controller.hpp
index 90d1feb26..2265bbc4d 100644
--- a/src/karts/controller/ai_base_lap_controller.hpp
+++ b/src/karts/controller/ai_base_lap_controller.hpp
@@ -53,9 +53,9 @@ protected:
      *  graph nodes. */
     std::vector<std::vector<int> > m_all_look_aheads;
 
-    virtual void update      (float delta) ;
+    virtual void update(int ticks);
     virtual unsigned int getNextSector(unsigned int index);
-    virtual void  newLap             (int lap);
+    virtual void  newLap(int lap);
     //virtual void setControllerName(const std::string &name);
 
     float    steerToAngle  (const unsigned int sector, const float angle);
diff --git a/src/karts/controller/arena_ai.cpp b/src/karts/controller/arena_ai.cpp
index b667d17fa..051bdd8f4 100644
--- a/src/karts/controller/arena_ai.cpp
+++ b/src/karts/controller/arena_ai.cpp
@@ -59,8 +59,8 @@ void ArenaAI::reset()
     m_reverse_point = Vec3(0, 0, 0);
     m_time_since_last_shot = 0.0f;
     m_time_since_driving = 0.0f;
-    m_time_since_off_road = 0.0f;
-    m_time_since_reversing = 0.0f;
+    m_ticks_since_off_road = 0;
+    m_ticks_since_reversing = 0;
     m_time_since_uturn = 0.0f;
     m_turn_radius = 0.0f;
     m_steering_angle = 0.0f;
@@ -74,9 +74,9 @@ void ArenaAI::reset()
 /** This is the main entry point for the AI.
  *  It is called once per frame for each AI and determines the behaviour of
  *  the AI, e.g. steering, accelerating/braking, firing.
- *  \param dt Time step size.
+ *  \param ticks Number of physics time steps - should be 1.
  */
-void ArenaAI::update(float dt)
+void ArenaAI::update(int ticks)
 {
     // This is used to enable firing an item backwards.
     m_controls->setLookBack(false);
@@ -96,30 +96,31 @@ void ArenaAI::update(float dt)
 
     if (!isKartOnRoad() && m_kart->isOnGround())
     {
-        m_time_since_off_road += dt;
+        m_ticks_since_off_road += ticks;
     }
-    else if (m_time_since_off_road != 0.0f)
+    else if (m_ticks_since_off_road != 0)
     {
-        m_time_since_off_road = 0.0f;
+        m_ticks_since_off_road = 0;
     }
 
     // If the kart needs to be rescued, do it now (and nothing else)
-    if (m_time_since_off_road > 5.0f && m_kart->isOnGround())
+    if (m_ticks_since_off_road > stk_config->time2Ticks(5.0f) &&
+        m_kart->isOnGround()                                     )
     {
-        m_time_since_off_road = 0.0f;
+        m_ticks_since_off_road = 0;
         new RescueAnimation(m_kart);
-        AIBaseController::update(dt);
+        AIBaseController::update(ticks);
         return;
     }
 
     if (isWaiting())
     {
-        AIBaseController::update(dt);
+        AIBaseController::update(ticks);
         return;
     }
-
+    float dt = stk_config->ticks2Time(ticks);
     checkIfStuck(dt);
-    if (gettingUnstuck(dt))
+    if (gettingUnstuck(ticks))
         return;
 
     findTarget();
@@ -156,7 +157,7 @@ void ArenaAI::update(float dt)
         setSteering(m_steering_angle, dt);
     }
 
-    AIBaseController::update(dt);
+    AIBaseController::update(ticks);
 
 }   // update
 
@@ -385,22 +386,23 @@ void ArenaAI::doUTurn(const float dt)
  *  \param dt Time step size.
  *  \return True if getting stuck is needed to be done.
  */
-bool ArenaAI::gettingUnstuck(const float dt)
+bool ArenaAI::gettingUnstuck(int ticks)
 {
     if (!m_is_stuck || m_is_uturn) return false;
 
     resetAfterStop();
+    float dt = stk_config->ticks2Time(ticks);
     setSteering(0.0f, dt);
     m_controls->setBrake(true);
 
-    m_time_since_reversing += dt;
+    m_ticks_since_reversing += ticks;
 
-    if (m_time_since_reversing >= 1.0f)
+    if (m_ticks_since_reversing >= stk_config->time2Ticks(1.0f))
     {
         m_is_stuck = false;
-        m_time_since_reversing = 0.0f;
+        m_ticks_since_reversing = 0;
     }
-    AIBaseController::update(dt);
+    AIBaseController::update(ticks);
     return true;
 
 }   // gettingUnstuck
diff --git a/src/karts/controller/arena_ai.hpp b/src/karts/controller/arena_ai.hpp
index fee41d97b..71c49f85d 100644
--- a/src/karts/controller/arena_ai.hpp
+++ b/src/karts/controller/arena_ai.hpp
@@ -89,7 +89,7 @@ private:
      *  until facing in front of it. */
     Vec3 m_reverse_point;
 
-    /** Indicates that the kart is currently stuck, and m_time_since_reversing
+    /** Indicates that the kart is currently stuck, and m_ticks_since_reversing
      *  is counting down. */
     bool m_is_stuck;
 
@@ -105,7 +105,7 @@ private:
     float m_time_since_last_shot;
 
     /** This is a timer that counts down when the kart is reversing to get unstuck. */
-    float m_time_since_reversing;
+    float m_ticks_since_reversing;
 
     /** This is a timer that counts down when the kart is starting to drive. */
     float m_time_since_driving;
@@ -114,7 +114,7 @@ private:
     float m_time_since_uturn;
 
     /** This is a timer that counts when the kart start going off road. */
-    float m_time_since_off_road;
+    int m_ticks_since_off_road;
 
     /** Used to determine braking and nitro usage. */
     float m_turn_radius;
@@ -142,7 +142,7 @@ private:
     // ------------------------------------------------------------------------
     void          doUTurn(const float dt);
     // ------------------------------------------------------------------------
-    bool          gettingUnstuck(const float dt);
+    bool          gettingUnstuck(int ticks);
     // ------------------------------------------------------------------------
     bool          updateAimingPosition(Vec3* target_point);
     // ------------------------------------------------------------------------
@@ -183,11 +183,11 @@ public:
     // ------------------------------------------------------------------------
     virtual     ~ArenaAI() {}
     // ------------------------------------------------------------------------
-    virtual void update (float delta) OVERRIDE;
+    virtual void update(int ticks) OVERRIDE;
     // ------------------------------------------------------------------------
-    virtual void reset  () OVERRIDE;
+    virtual void reset() OVERRIDE;
     // ------------------------------------------------------------------------
-    virtual void newLap (int lap) OVERRIDE {}
+    virtual void newLap(int lap) OVERRIDE {}
 
 };
 
diff --git a/src/karts/controller/controller.hpp b/src/karts/controller/controller.hpp
index 9b42a7bae..be4e82fe0 100644
--- a/src/karts/controller/controller.hpp
+++ b/src/karts/controller/controller.hpp
@@ -61,7 +61,7 @@ public:
                   Controller         (AbstractKart *kart);
     virtual      ~Controller         () {};
     virtual void  reset              () = 0;
-    virtual void  update             (float dt) = 0;
+    virtual void  update             (int ticks) = 0;
     virtual void  handleZipper       (bool play_sound) = 0;
     virtual void  collectedItem      (const Item &item, int add_info=-1,
                                       float previous_energy=0) = 0;
diff --git a/src/karts/controller/end_controller.cpp b/src/karts/controller/end_controller.cpp
index 0076f4544..e7cc77539 100644
--- a/src/karts/controller/end_controller.cpp
+++ b/src/karts/controller/end_controller.cpp
@@ -172,7 +172,7 @@ void EndController::action(PlayerAction action, int value)
 }   // action
 
 //-----------------------------------------------------------------------------
-void EndController::update(float dt)
+void EndController::update(int ticks)
 {
     // This is used to enable firing an item backwards.
     m_controls->setLookBack(false);
@@ -180,7 +180,7 @@ void EndController::update(float dt)
     m_controls->setBrake(false);
     m_controls->setAccel(1.0f);
 
-    AIBaseLapController::update(dt);
+    AIBaseLapController::update(ticks);
 
     // In case of battle mode: don't do anything
     if(race_manager->getMinorMode()==RaceManager::MINOR_MODE_3_STRIKES ||
@@ -198,6 +198,7 @@ void EndController::update(float dt)
     calcSteps();
 
     /*Response handling functions*/
+    float dt = stk_config->ticks2Time(ticks);
     handleSteering(dt);
     handleRescue(dt);
 }   // update
diff --git a/src/karts/controller/end_controller.hpp b/src/karts/controller/end_controller.hpp
index d9936edf3..7790175ff 100644
--- a/src/karts/controller/end_controller.hpp
+++ b/src/karts/controller/end_controller.hpp
@@ -84,7 +84,7 @@ public:
                  EndController(AbstractKart *kart,
                                Controller *prev_controller);
                 ~EndController();
-    virtual void update      (float delta) ;
+    virtual void update      (int ticks) ;
     virtual void reset       ();
     virtual void action      (PlayerAction action, int value);
     virtual void newLap      (int lap);
diff --git a/src/karts/controller/ghost_controller.cpp b/src/karts/controller/ghost_controller.cpp
index 5d3740c46..b0789823d 100644
--- a/src/karts/controller/ghost_controller.cpp
+++ b/src/karts/controller/ghost_controller.cpp
@@ -35,7 +35,7 @@ void GhostController::reset()
 }   // reset
 
 //-----------------------------------------------------------------------------
-void GhostController::update(float dt)
+void GhostController::update(int ticks)
 {
     m_current_time = World::getWorld()->getTime();
     // Find (if necessary) the next index to use
diff --git a/src/karts/controller/ghost_controller.hpp b/src/karts/controller/ghost_controller.hpp
index f889f9862..44d343168 100644
--- a/src/karts/controller/ghost_controller.hpp
+++ b/src/karts/controller/ghost_controller.hpp
@@ -47,7 +47,7 @@ public:
              GhostController(AbstractKart *kart, core::stringw display_name);
     virtual ~GhostController() {};
     virtual void reset() OVERRIDE;
-    virtual void update (float dt) OVERRIDE;
+    virtual void update (int ticks) OVERRIDE;
     virtual bool disableSlipstreamBonus() const OVERRIDE { return true; }
     virtual void crashed(const Material *m) OVERRIDE {}
     virtual void crashed(const AbstractKart *k) OVERRIDE {}
diff --git a/src/karts/controller/local_player_controller.cpp b/src/karts/controller/local_player_controller.cpp
index 27ef87122..5406d3d72 100644
--- a/src/karts/controller/local_player_controller.cpp
+++ b/src/karts/controller/local_player_controller.cpp
@@ -172,7 +172,7 @@ bool LocalPlayerController::action(PlayerAction action, int value,
 //-----------------------------------------------------------------------------
 /** Handles steering for a player kart.
  */
-void LocalPlayerController::steer(float dt, int steer_val)
+void LocalPlayerController::steer(int ticks, int steer_val)
 {
     if(UserConfigParams::m_gamepad_debug)
     {
@@ -182,7 +182,7 @@ void LocalPlayerController::steer(float dt, int steer_val)
                              m_kart, 1.0f,
                              video::SColor(255, 255, 0, 255), false);
     }
-    PlayerController::steer(dt, steer_val);
+    PlayerController::steer(ticks, steer_val);
     
     if(UserConfigParams::m_gamepad_debug)
     {
@@ -194,7 +194,7 @@ void LocalPlayerController::steer(float dt, int steer_val)
 //-----------------------------------------------------------------------------
 /** Updates the player kart, called once each timestep.
  */
-void LocalPlayerController::update(float dt)
+void LocalPlayerController::update(int ticks)
 {
     if (UserConfigParams::m_gamepad_debug)
     {
@@ -203,7 +203,7 @@ void LocalPlayerController::update(float dt)
         Log::debug("LocalPlayerController", "irr_driver", "-------------------------------------");
     }
 
-    PlayerController::update(dt);
+    PlayerController::update(ticks);
 
     // look backward when the player requests or
     // if automatic reverse camera is active
diff --git a/src/karts/controller/local_player_controller.hpp b/src/karts/controller/local_player_controller.hpp
index d585b7bec..ba3bfc50c 100644
--- a/src/karts/controller/local_player_controller.hpp
+++ b/src/karts/controller/local_player_controller.hpp
@@ -54,13 +54,13 @@ private:
     SFXBuffer   *m_grab_sound;
     SFXBuffer   *m_full_sound;
 
-    virtual void steer(float, int) OVERRIDE;
+    virtual void steer(int, int) OVERRIDE;
     virtual void displayPenaltyWarning() OVERRIDE;
 public:
                  LocalPlayerController(AbstractKart *kart,
                                        const int local_playerID);
                 ~LocalPlayerController();
-    void         update            (float) OVERRIDE;
+    void         update            (int ticks) OVERRIDE;
     bool         action            (PlayerAction action, int value,
                                     bool dry_run=false) OVERRIDE;
     virtual void handleZipper      (bool play_sound) OVERRIDE;
diff --git a/src/karts/controller/player_controller.cpp b/src/karts/controller/player_controller.cpp
index 49aaa7330..4034068e0 100644
--- a/src/karts/controller/player_controller.cpp
+++ b/src/karts/controller/player_controller.cpp
@@ -38,7 +38,7 @@
 PlayerController::PlayerController(AbstractKart *kart)
                 : Controller(kart)
 {
-    m_penalty_time = 0.0f;
+    m_penalty_ticks = 0;
 }   // PlayerController
 
 //-----------------------------------------------------------------------------
@@ -53,13 +53,13 @@ PlayerController::~PlayerController()
  */
 void PlayerController::reset()
 {
-    m_steer_val_l  = 0;
-    m_steer_val_r  = 0;
-    m_steer_val    = 0;
-    m_prev_brake   = 0;
-    m_prev_accel   = 0;
-    m_prev_nitro   = false;
-    m_penalty_time = 0;
+    m_steer_val_l   = 0;
+    m_steer_val_r   = 0;
+    m_steer_val     = 0;
+    m_prev_brake    = 0;
+    m_prev_accel    = 0;
+    m_prev_nitro    = false;
+    m_penalty_ticks = 0;
 }   // reset
 
 // ----------------------------------------------------------------------------
@@ -167,7 +167,7 @@ bool PlayerController::action(PlayerAction action, int value, bool dry_run)
         break;
     case PA_ACCEL:
         SET_OR_TEST(m_prev_accel, value);
-        if (value && !(m_penalty_time > 0.0f))
+        if (value && !(m_penalty_ticks > 0))
         {
             SET_OR_TEST_GETTER(Accel, value/32768.0f);
             SET_OR_TEST_GETTER(Brake, false);
@@ -249,7 +249,7 @@ void PlayerController::actionFromNetwork(PlayerAction p_action, int value,
 //-----------------------------------------------------------------------------
 /** Handles steering for a player kart.
  */
-void PlayerController::steer(float dt, int steer_val)
+void PlayerController::steer(int ticks, int steer_val)
 {
     // Get the old value, compute the new steering value,
     // and set it at the end of this function
@@ -264,6 +264,7 @@ void PlayerController::steer(float dt, int steer_val)
     // Amount the steering is changed for digital devices.
     // If the steering is 'back to straight', a different steering
     // change speed is used.
+    float dt = stk_config->ticks2Time(ticks);
     const float STEER_CHANGE = ( (steer_val<=0 && steer<0) ||
                                  (steer_val>=0 && steer>0)   )
                      ? dt/m_kart->getKartProperties()->getTurnTimeResetSteer()
@@ -313,13 +314,13 @@ void PlayerController::skidBonusTriggered()
 //-----------------------------------------------------------------------------
 /** Updates the player kart, called once each timestep.
  */
-void PlayerController::update(float dt)
+void PlayerController::update(int ticks)
 {
     // Don't do steering if it's replay. In position only replay it doesn't
     // matter, but if it's physics replay the gradual steering causes
     // incorrect results, since the stored values are already adjusted.
     if (!history->replayHistory() || !history->dontDoPhysics())
-        steer(dt, m_steer_val);
+        steer(ticks, m_steer_val);
 
     if (World::getWorld()->getPhase() == World::GOAL_PHASE)
     {
@@ -336,11 +337,11 @@ void PlayerController::update(float dt)
             // Only give penalty time in SET_PHASE.
             // Penalty time check makes sure it doesn't get rendered on every
             // update.
-            if (m_penalty_time == 0.0 &&
+            if (m_penalty_ticks == 0 &&
                 World::getWorld()->getPhase() == WorldStatus::SET_PHASE)
             {
                 displayPenaltyWarning();
-                m_penalty_time = stk_config->m_penalty_time;
+                m_penalty_ticks = stk_config->m_penalty_ticks;
             }   // if penalty_time = 0
 
             m_controls->setBrake(false);
@@ -350,9 +351,9 @@ void PlayerController::update(float dt)
         return;
     }   // if isStartPhase
 
-    if (m_penalty_time>0.0)
+    if (m_penalty_ticks>0)
     {
-        m_penalty_time-=dt;
+        m_penalty_ticks-=ticks;
         return;
     }
 
diff --git a/src/karts/controller/player_controller.hpp b/src/karts/controller/player_controller.hpp
index 2d52e44d6..750ce5126 100644
--- a/src/karts/controller/player_controller.hpp
+++ b/src/karts/controller/player_controller.hpp
@@ -32,9 +32,9 @@ protected:
     bool           m_prev_brake;
     bool           m_prev_nitro;
 
-    float          m_penalty_time;
+    int            m_penalty_ticks;
 
-    virtual void  steer(float, int);
+    virtual void  steer(int ticks, int steer_val);
     // ------------------------------------------------------------------------
     /** Called when this kart started too early and got a start penalty. */
     virtual void  displayPenaltyWarning() {}
@@ -43,7 +43,7 @@ protected:
 public:
                  PlayerController(AbstractKart *kart);
     virtual     ~PlayerController  ();
-    virtual void update            (float) OVERRIDE;
+    virtual void update            (int ticks) OVERRIDE;
     virtual bool action            (PlayerAction action, int value,
                                     bool dry_run = false           ) OVERRIDE;
     virtual void actionFromNetwork(PlayerAction action, int value,
diff --git a/src/karts/controller/skidding_ai.cpp b/src/karts/controller/skidding_ai.cpp
index 957934f2f..ea4bc70e3 100644
--- a/src/karts/controller/skidding_ai.cpp
+++ b/src/karts/controller/skidding_ai.cpp
@@ -161,7 +161,7 @@ void SkiddingAI::reset()
 {
     m_time_since_last_shot       = 0.0f;
     m_start_kart_crash_direction = 0;
-    m_start_delay                = -1.0f;
+    m_start_delay                = -1;
     m_time_since_stuck           = 0.0f;
     m_kart_ahead                 = NULL;
     m_distance_ahead             = 0.0f;
@@ -218,8 +218,9 @@ unsigned int SkiddingAI::getNextSector(unsigned int index)
  *  It is called once per frame for each AI and determines the behaviour of
  *  the AI, e.g. steering, accelerating/braking, firing.
  */
-void SkiddingAI::update(float dt)
+void SkiddingAI::update(int ticks)
 {
+    float dt = stk_config->ticks2Time(ticks);
     // This is used to enable firing an item backwards.
     m_controls->setLookBack(false);
     m_controls->setNitro(false);
@@ -293,14 +294,14 @@ void SkiddingAI::update(float dt)
     if(isStuck() && !m_kart->getKartAnimation())
     {
         new RescueAnimation(m_kart);
-        AIBaseLapController::update(dt);
+        AIBaseLapController::update(ticks);
         return;
     }
 
     if( m_world->isStartPhase() )
     {
         handleRaceStart();
-        AIBaseLapController::update(dt);
+        AIBaseLapController::update(ticks);
         return;
     }
 
@@ -309,7 +310,7 @@ void SkiddingAI::update(float dt)
 
     m_kart->setSlowdown(MaxSpeed::MS_DECREASE_AI,
                         m_ai_properties->getSpeedCap(m_distance_to_player),
-                        /*fade_in_time*/0.0f);
+                        /*fade_in_time*/0);
     //Detect if we are going to crash with the track and/or kart
     checkCrashes(m_kart->getXYZ());
     determineTrackDirection();
@@ -347,7 +348,7 @@ void SkiddingAI::update(float dt)
     if(!commands_set)
     {
         /*Response handling functions*/
-        handleAcceleration(dt);
+        handleAcceleration(ticks);
         handleSteering(dt);
         handleItems(dt);
         handleRescue(dt);
@@ -361,7 +362,7 @@ void SkiddingAI::update(float dt)
     if(m_controls->getNitro() &&
         m_kart->getPowerup()->getType()==PowerupManager::POWERUP_ZIPPER &&
         m_kart->getSpeed()>1.0f &&
-        m_kart->getSpeedIncreaseTimeLeft(MaxSpeed::MS_INCREASE_ZIPPER)<=0 &&
+        m_kart->getSpeedIncreaseTicksLeft(MaxSpeed::MS_INCREASE_ZIPPER)<=0 &&
         !m_avoid_item_close)
     {
         // Make sure that not all AI karts use the zipper at the same
@@ -376,7 +377,7 @@ void SkiddingAI::update(float dt)
     }
 
     /*And obviously general kart stuff*/
-    AIBaseLapController::update(dt);
+    AIBaseLapController::update(ticks);
 }   // update
 
 //-----------------------------------------------------------------------------
@@ -849,7 +850,7 @@ bool SkiddingAI::handleSelectedItem(Vec3 kart_aim_direction, Vec3 *aim_point)
     // If the item is unavailable keep on testing. It is not necessary
     // to test if an item has turned bad, this was tested before this
     // function is called.
-    if(m_item_to_collect->getDisableTime()>0)
+    if(m_item_to_collect->getDisableTicks()>0)
         return false;
 
     const Vec3 &xyz = m_item_to_collect->getXYZ();
@@ -1039,7 +1040,7 @@ void SkiddingAI::evaluateItems(const Item *item, Vec3 kart_aim_direction,
     const KartProperties *kp = m_kart->getKartProperties();
 
     // Ignore items that are currently disabled
-    if(item->getDisableTime()>0) return;
+    if(item->getDisableTicks()>0) return;
 
     // If the item type is not handled here, ignore it
     Item::ItemType type = item->getType();
@@ -1373,7 +1374,8 @@ void SkiddingAI::handleItems(const float dt)
         // likely that this kart then gets a good iteam), otherwise use it
         // after a waiting an appropriate time
         if(m_kart->getPosition()>1 &&
-            m_time_since_last_shot > stk_config->m_item_switch_time+2.0f)
+            m_time_since_last_shot > 
+            stk_config->ticks2Time(stk_config->m_item_switch_ticks)+2.0f)
             m_controls->setFire(true);
         break;   // POWERUP_SWITCH
 
@@ -1504,12 +1506,12 @@ void SkiddingAI::computeNearestKarts()
 /** Determines if the AI should accelerate or not.
  *  \param dt Time step size.
  */
-void SkiddingAI::handleAcceleration( const float dt)
+void SkiddingAI::handleAcceleration(int ticks)
 {
     //Do not accelerate until we have delayed the start enough
-    if( m_start_delay > 0.0f )
+    if( m_start_delay > 0 )
     {
-        m_start_delay -= dt;
+        m_start_delay -= ticks;
         m_controls->setAccel(0.0f);
         return;
     }
@@ -1520,7 +1522,7 @@ void SkiddingAI::handleAcceleration( const float dt)
         return;
     }
 
-    if(m_kart->getBlockedByPlungerTime()>0)
+    if(m_kart->getBlockedByPlungerTicks()>0)
     {
         if(m_kart->getSpeed() < m_kart->getCurrentMaxSpeed() / 2)
             m_controls->setAccel(0.05f);
@@ -1536,14 +1538,15 @@ void SkiddingAI::handleAcceleration( const float dt)
 //-----------------------------------------------------------------------------
 void SkiddingAI::handleRaceStart()
 {
-    if( m_start_delay <  0.0f )
+    if( m_start_delay <  0 )
     {
         // Each kart starts at a different, random time, and the time is
         // smaller depending on the difficulty.
-        m_start_delay = m_ai_properties->m_min_start_delay
+        m_start_delay = stk_config->time2Ticks(
+                        m_ai_properties->m_min_start_delay
                       + (float) rand() / RAND_MAX
                       * (m_ai_properties->m_max_start_delay -
-                         m_ai_properties->m_min_start_delay);
+                         m_ai_properties->m_min_start_delay)   );
 
         float false_start_probability =
                m_superpower == RaceManager::SUPERPOWER_NOLOK_BOSS
@@ -1552,7 +1555,7 @@ void SkiddingAI::handleRaceStart()
         // Now check for a false start. If so, add 1 second penalty time.
         if(rand() < RAND_MAX * false_start_probability)
         {
-            m_start_delay+=stk_config->m_penalty_time;
+            m_start_delay+=stk_config->m_penalty_ticks;
             return;
         }
     }
@@ -1591,7 +1594,7 @@ void SkiddingAI::handleNitroAndZipper()
     if(m_kart->getSpeed() > 0.95f*m_kart->getCurrentMaxSpeed())
         return;
     // Don't use nitro when the AI has a plunger in the face!
-    if(m_kart->getBlockedByPlungerTime()>0) return;
+    if(m_kart->getBlockedByPlungerTicks()>0) return;
 
     // Don't use nitro if we are braking
     if(m_controls->getBrake()) return;
@@ -1683,7 +1686,7 @@ void SkiddingAI::handleNitroAndZipper()
 
     if(m_kart->getPowerup()->getType()==PowerupManager::POWERUP_ZIPPER &&
         m_kart->getSpeed()>1.0f &&
-        m_kart->getSpeedIncreaseTimeLeft(MaxSpeed::MS_INCREASE_ZIPPER)<=0)
+        m_kart->getSpeedIncreaseTicksLeft(MaxSpeed::MS_INCREASE_ZIPPER)<=0)
     {
         DriveNode::DirectionType dir;
         unsigned int last;
@@ -2391,7 +2394,7 @@ void SkiddingAI::setSteering(float angle, float dt)
     else if(steer_fraction < -1.0f) steer_fraction = -1.0f;
 
     // Restrict steering when a plunger is in the face
-    if(m_kart->getBlockedByPlungerTime()>0)
+    if(m_kart->getBlockedByPlungerTicks()>0)
     {
         if     (steer_fraction >  0.5f) steer_fraction =  0.5f;
         else if(steer_fraction < -0.5f) steer_fraction = -0.5f;
diff --git a/src/karts/controller/skidding_ai.hpp b/src/karts/controller/skidding_ai.hpp
index 1eff42935..b13c4187f 100644
--- a/src/karts/controller/skidding_ai.hpp
+++ b/src/karts/controller/skidding_ai.hpp
@@ -51,8 +51,6 @@
 #include <line3d.h>
 
 class LinearWorld;
-class DriveGraph;
-class ShowCurve;
 class Track;
 
 namespace irr
@@ -145,8 +143,8 @@ private:
     /** Distance to the kard behind. */
     float m_distance_behind;
 
-    /** The actual start delay used. */
-    float m_start_delay;
+    /** The actual start delay used in ticks. */
+    int m_start_delay;
 
     /** Time an item has been collected and not used. */
     float m_time_since_last_shot;
@@ -242,7 +240,7 @@ private:
      *specific action (more like, associated with inaction).
      */
     void  handleRaceStart();
-    void  handleAcceleration(const float dt);
+    void  handleAcceleration(int ticks);
     void  handleSteering(float dt);
     void  handleItems(const float dt);
     void  handleRescue(const float dt);
@@ -277,7 +275,7 @@ protected:
 public:
                  SkiddingAI(AbstractKart *kart);
                 ~SkiddingAI();
-    virtual void update      (float delta) ;
+    virtual void update      (int ticks);
     virtual void reset       ();
     virtual const irr::core::stringw& getNamePostfix() const;
 };
diff --git a/src/karts/controller/soccer_ai.cpp b/src/karts/controller/soccer_ai.cpp
index 0b1517219..8c09ae89d 100644
--- a/src/karts/controller/soccer_ai.cpp
+++ b/src/karts/controller/soccer_ai.cpp
@@ -107,7 +107,7 @@ void SoccerAI::reset()
  *  after goal.
  *  \param dt Time step size.
  */
-void SoccerAI::update(float dt)
+void SoccerAI::update(int ticks)
 {
 #ifdef BALL_AIM_DEBUG
     Vec3 red = m_world->getBallAimPosition(SOCCER_TEAM_RED);
@@ -125,11 +125,11 @@ void SoccerAI::update(float dt)
         resetAfterStop();
         m_controls->setBrake(false);
         m_controls->setAccel(0.0f);
-        AIBaseController::update(dt);
+        AIBaseController::update(ticks);
         return;
     }
 
-    ArenaAI::update(dt);
+    ArenaAI::update(ticks);
 }   // update
 
 //-----------------------------------------------------------------------------
diff --git a/src/karts/controller/soccer_ai.hpp b/src/karts/controller/soccer_ai.hpp
index 36d21c4f2..17a9f0093 100644
--- a/src/karts/controller/soccer_ai.hpp
+++ b/src/karts/controller/soccer_ai.hpp
@@ -100,12 +100,9 @@ private:
 
 public:
                  SoccerAI(AbstractKart *kart);
-    // ------------------------------------------------------------------------
                 ~SoccerAI();
-    // ------------------------------------------------------------------------
-    virtual void update  (float delta) OVERRIDE;
-    // ------------------------------------------------------------------------
-    virtual void reset   () OVERRIDE;
+    virtual void update (int ticks) OVERRIDE;
+    virtual void reset() OVERRIDE;
 
 };
 
diff --git a/src/karts/controller/spare_tire_ai.cpp b/src/karts/controller/spare_tire_ai.cpp
index 2f4eb2f9d..e561050a3 100644
--- a/src/karts/controller/spare_tire_ai.cpp
+++ b/src/karts/controller/spare_tire_ai.cpp
@@ -56,8 +56,8 @@ SpareTireAI::SpareTireAI(AbstractKart *kart)
 void SpareTireAI::reset()
 {
     BattleAI::reset();
-    m_idx = 0;
-    m_timer = 0.0f;
+    m_idx   = 0;
+    m_timer = 0;
 }   // reset
 
 //-----------------------------------------------------------------------------
@@ -65,12 +65,12 @@ void SpareTireAI::reset()
  *  \ref m_timer reaches zero which it will be decreased here.
  *  \param dt Time step size.
  */
-void SpareTireAI::update(float dt)
+void SpareTireAI::update(int ticks)
 {
-    BattleAI::update(dt);
-    m_kart->setSlowdown(MaxSpeed::MS_DECREASE_AI, 0.5f, /*fade_in_time*/0.0f);
-    m_timer -= dt;
-    if (m_timer < 0.0f)
+    BattleAI::update(ticks);
+    m_kart->setSlowdown(MaxSpeed::MS_DECREASE_AI, 0.5f, /*fade_in_time*/0);
+    m_timer -= ticks;
+    if (m_timer < 0)
         unspawn();
 }   // update
 
@@ -108,10 +108,10 @@ void SpareTireAI::findTarget()
  *  moving around.
  *  \param time_to_last Time before calling \ref unspawn.
  */
-void SpareTireAI::spawn(float time_to_last)
+void SpareTireAI::spawn(int ticks_to_last)
 {
     findDefaultPath();
-    m_timer = time_to_last;
+    m_timer = ticks_to_last;
 
     Physics::getInstance()->addKart(m_kart);
     m_kart->startEngineSFX();
diff --git a/src/karts/controller/spare_tire_ai.hpp b/src/karts/controller/spare_tire_ai.hpp
index 39269128d..c11c3dab4 100644
--- a/src/karts/controller/spare_tire_ai.hpp
+++ b/src/karts/controller/spare_tire_ai.hpp
@@ -35,7 +35,7 @@ private:
     int m_idx;
 
     /** Store the time before calling \ref unspawn. */
-    float m_timer;
+    int m_timer;
 
     // ------------------------------------------------------------------------
     virtual void  findTarget() OVERRIDE;
@@ -47,11 +47,11 @@ public:
     // ------------------------------------------------------------------------
     virtual void crashed(const AbstractKart *k) OVERRIDE;
     // ------------------------------------------------------------------------
-    virtual void update(float delta) OVERRIDE;
+    virtual void update(int ticks) OVERRIDE;
     // ------------------------------------------------------------------------
     virtual void reset() OVERRIDE;
     // ------------------------------------------------------------------------
-    void         spawn(float time_to_last);
+    void         spawn(int ticks_to_last);
     // ------------------------------------------------------------------------
     void         unspawn();
     // ------------------------------------------------------------------------
diff --git a/src/karts/controller/test_ai.cpp b/src/karts/controller/test_ai.cpp
index e7fc11f07..d196ac658 100644
--- a/src/karts/controller/test_ai.cpp
+++ b/src/karts/controller/test_ai.cpp
@@ -59,8 +59,8 @@
 #include <iostream>
 
 // This define is only used to make the TestAI as similar to the
-// SkiddingAI. This way the two AIs can be compared without too many
-// false positives.
+// SkiddingAI as possible. This way the two AIs can be compared 
+// without too many false and distracing positives.
 
 #define SkiddingAI TestAI
 
@@ -167,7 +167,7 @@ void SkiddingAI::reset()
 {
     m_time_since_last_shot       = 0.0f;
     m_start_kart_crash_direction = 0;
-    m_start_delay                = -1.0f;
+    m_start_delay                = -1;
     m_time_since_stuck           = 0.0f;
     m_kart_ahead                 = NULL;
     m_distance_ahead             = 0.0f;
@@ -224,8 +224,9 @@ unsigned int SkiddingAI::getNextSector(unsigned int index)
  *  It is called once per frame for each AI and determines the behaviour of
  *  the AI, e.g. steering, accelerating/braking, firing.
  */
-void SkiddingAI::update(float dt)
+void SkiddingAI::update(int ticks)
 {
+    float dt = stk_config->ticks2Time(ticks);
     // This is used to enable firing an item backwards.
     m_controls->setLookBack(false);
     m_controls->setNitro(false);
@@ -299,14 +300,14 @@ void SkiddingAI::update(float dt)
     if(isStuck() && !m_kart->getKartAnimation())
     {
         new RescueAnimation(m_kart);
-        AIBaseLapController::update(dt);
+        AIBaseLapController::update(ticks);
         return;
     }
 
     if( m_world->isStartPhase() )
     {
         handleRaceStart();
-        AIBaseLapController::update(dt);
+        AIBaseLapController::update(ticks);
         return;
     }
 
@@ -315,7 +316,7 @@ void SkiddingAI::update(float dt)
 
     m_kart->setSlowdown(MaxSpeed::MS_DECREASE_AI,
                         m_ai_properties->getSpeedCap(m_distance_to_player),
-                        /*fade_in_time*/0.0f);
+                        /*fade_in_time*/0);
     //Detect if we are going to crash with the track and/or kart
     checkCrashes(m_kart->getXYZ());
     determineTrackDirection();
@@ -353,7 +354,7 @@ void SkiddingAI::update(float dt)
     if(!commands_set)
     {
         /*Response handling functions*/
-        handleAcceleration(dt);
+        handleAcceleration(ticks);
         handleSteering(dt);
         handleItems(dt);
         handleRescue(dt);
@@ -367,7 +368,7 @@ void SkiddingAI::update(float dt)
     if(m_controls->getNitro() &&
         m_kart->getPowerup()->getType()==PowerupManager::POWERUP_ZIPPER &&
         m_kart->getSpeed()>1.0f &&
-        m_kart->getSpeedIncreaseTimeLeft(MaxSpeed::MS_INCREASE_ZIPPER)<=0 &&
+        m_kart->getSpeedIncreaseTicksLeft(MaxSpeed::MS_INCREASE_ZIPPER)<=0 &&
         !m_avoid_item_close)
     {
         // Make sure that not all AI karts use the zipper at the same
@@ -382,7 +383,7 @@ void SkiddingAI::update(float dt)
     }
 
     /*And obviously general kart stuff*/
-    AIBaseLapController::update(dt);
+    AIBaseLapController::update(ticks);
 }   // update
 
 //-----------------------------------------------------------------------------
@@ -855,7 +856,7 @@ bool SkiddingAI::handleSelectedItem(Vec3 kart_aim_direction, Vec3 *aim_point)
     // If the item is unavailable keep on testing. It is not necessary
     // to test if an item has turned bad, this was tested before this
     // function is called.
-    if(m_item_to_collect->getDisableTime()>0)
+    if(m_item_to_collect->getDisableTicks()>0)
         return false;
 
     const Vec3 &xyz = m_item_to_collect->getXYZ();
@@ -1045,7 +1046,7 @@ void SkiddingAI::evaluateItems(const Item *item, Vec3 kart_aim_direction,
     const KartProperties *kp = m_kart->getKartProperties();
 
     // Ignore items that are currently disabled
-    if(item->getDisableTime()>0) return;
+    if(item->getDisableTicks()>0) return;
 
     // If the item type is not handled here, ignore it
     Item::ItemType type = item->getType();
@@ -1159,7 +1160,7 @@ void SkiddingAI::handleItems(const float dt)
     if (m_superpower == RaceManager::SUPERPOWER_NOLOK_BOSS)
     {
         m_controls->setLookBack(m_kart->getPowerup()->getType() ==
-                                PowerupManager::POWERUP_BOWLING    );
+                                   PowerupManager::POWERUP_BOWLING   );
 
         if( m_time_since_last_shot > 3.0f )
         {
@@ -1287,7 +1288,7 @@ void SkiddingAI::handleItems(const float dt)
             // Since cakes can be fired all around, just use a sane distance
             // with a bit of extra for backwards, as enemy will go towards cake
             m_controls->setFire( (fire_backwards && distance < 25.0f) ||
-                                 (!fire_backwards && distance < 20.0f)   );
+                                 (!fire_backwards && distance < 20.0f)  );
             if(m_controls->getFire())
                 m_controls->setLookBack(fire_backwards);
             break;
@@ -1339,7 +1340,7 @@ void SkiddingAI::handleItems(const float dt)
             m_controls->setFire( ( (fire_backwards && distance < 30.0f)  ||
                                    (!fire_backwards && distance <10.0f)    ) &&
                                 m_time_since_last_shot > 3.0f &&
-                                (straight_behind || straight_ahead)            );
+                                (straight_behind || straight_ahead)             );
             if(m_controls->getFire())
                 m_controls->setLookBack(fire_backwards);
             break;
@@ -1379,7 +1380,8 @@ void SkiddingAI::handleItems(const float dt)
         // likely that this kart then gets a good iteam), otherwise use it
         // after a waiting an appropriate time
         if(m_kart->getPosition()>1 &&
-            m_time_since_last_shot > stk_config->m_item_switch_time+2.0f)
+            m_time_since_last_shot 
+            > stk_config->ticks2Time(stk_config->m_item_switch_ticks)+2.0f)
             m_controls->setFire(true);
         break;   // POWERUP_SWITCH
 
@@ -1396,7 +1398,7 @@ void SkiddingAI::handleItems(const float dt)
         if(race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER)
         {
             m_controls->setFire(m_world->getTime()<1.0f &&
-                                m_kart->getPosition()>2     );
+                                m_kart->getPosition()>2    );
         }
         else
         {
@@ -1510,12 +1512,12 @@ void SkiddingAI::computeNearestKarts()
 /** Determines if the AI should accelerate or not.
  *  \param dt Time step size.
  */
-void SkiddingAI::handleAcceleration( const float dt)
+void SkiddingAI::handleAcceleration(int ticks)
 {
     //Do not accelerate until we have delayed the start enough
-    if( m_start_delay > 0.0f )
+    if( m_start_delay > 0 )
     {
-        m_start_delay -= dt;
+        m_start_delay -= ticks;
         m_controls->setAccel(0.0f);
         return;
     }
@@ -1530,7 +1532,7 @@ void SkiddingAI::handleAcceleration( const float dt)
         return;
     }
 
-    if(m_kart->getBlockedByPlungerTime()>0)
+    if(m_kart->getBlockedByPlungerTicks()>0)
     {
         if(m_kart->getSpeed() < m_kart->getCurrentMaxSpeed() / 2)
             m_controls->setAccel(0.05f);
@@ -1546,14 +1548,15 @@ void SkiddingAI::handleAcceleration( const float dt)
 //-----------------------------------------------------------------------------
 void SkiddingAI::handleRaceStart()
 {
-    if( m_start_delay <  0.0f )
+    if( m_start_delay <  0 )
     {
         // Each kart starts at a different, random time, and the time is
         // smaller depending on the difficulty.
-        m_start_delay = m_ai_properties->m_min_start_delay
+        m_start_delay = stk_config->time2Ticks(
+                        m_ai_properties->m_min_start_delay
                       + (float) rand() / RAND_MAX
                       * (m_ai_properties->m_max_start_delay -
-                         m_ai_properties->m_min_start_delay);
+                         m_ai_properties->m_min_start_delay)   );
 
         float false_start_probability =
                m_superpower == RaceManager::SUPERPOWER_NOLOK_BOSS
@@ -1562,7 +1565,7 @@ void SkiddingAI::handleRaceStart()
         // Now check for a false start. If so, add 1 second penalty time.
         if(rand() < RAND_MAX * false_start_probability)
         {
-            m_start_delay+=stk_config->m_penalty_time;
+            m_start_delay+=stk_config->m_penalty_ticks;
             return;
         }
     }
@@ -1640,7 +1643,7 @@ void SkiddingAI::handleNitroAndZipper()
     // sandtrack            10      489.963            64.18 0.00   3  1009 0.00   0   0   1 135   0   0  1407 0.00
 
     // Don't use nitro when the AI has a plunger in the face!
-    if(m_kart->getBlockedByPlungerTime()>0) return;
+    if(m_kart->getBlockedByPlungerTicks()>0) return;
 
     // Don't use nitro if we are braking
     if(m_controls->getBrake()) return;
@@ -1726,13 +1729,13 @@ void SkiddingAI::handleNitroAndZipper()
     {
         // Only prevent overtaking on highest level
         m_controls->setNitro(m_ai_properties->m_nitro_usage
-                              == AIProperties::NITRO_ALL    );
+                              == AIProperties::NITRO_ALL);
         return;
     }
 
     if(m_kart->getPowerup()->getType()==PowerupManager::POWERUP_ZIPPER &&
         m_kart->getSpeed()>1.0f &&
-        m_kart->getSpeedIncreaseTimeLeft(MaxSpeed::MS_INCREASE_ZIPPER)<=0)
+        m_kart->getSpeedIncreaseTicksLeft(MaxSpeed::MS_INCREASE_ZIPPER)<=0)
     {
         DriveNode::DirectionType dir;
         unsigned int last;
@@ -1742,7 +1745,7 @@ void SkiddingAI::handleNitroAndZipper()
         {
             float diff = DriveGraph::get()->getDistanceFromStart(last)
                        - DriveGraph::get()->getDistanceFromStart(m_track_node);
-            if (diff < 0) diff += Track::getCurrentTrack()->getTrackLength();
+            if(diff<0) diff += Track::getCurrentTrack()->getTrackLength();
             if(diff>m_ai_properties->m_straight_length_for_zipper)
                 m_controls->setFire(true);
         }
@@ -2076,6 +2079,7 @@ void SkiddingAI::findNonCrashingPointFixed(Vec3 *aim_position, int *last_node)
     *last_node = m_next_node_index[m_track_node];
     float angle = DriveGraph::get()->getAngleToNext(m_track_node,
                                               m_successor_index[m_track_node]);
+
     Vec3 direction;
     Vec3 step_track_coord;
 
@@ -2431,7 +2435,7 @@ void SkiddingAI::setSteering(float angle, float dt)
 #endif
         }
         m_controls->setSkidControl(m_skid_probability_state == SKID_PROBAB_SKID
-                                   ? sc : KartControl::SC_NONE   );
+                                   ? sc : KartControl::SC_NONE );
     }
 
     // Adjust steer fraction in case to be in [-1,1]
@@ -2439,7 +2443,7 @@ void SkiddingAI::setSteering(float angle, float dt)
     else if(steer_fraction < -1.0f) steer_fraction = -1.0f;
 
     // Restrict steering when a plunger is in the face
-    if(m_kart->getBlockedByPlungerTime()>0)
+    if(m_kart->getBlockedByPlungerTicks()>0)
     {
         if     (steer_fraction >  0.5f) steer_fraction =  0.5f;
         else if(steer_fraction < -0.5f) steer_fraction = -0.5f;
@@ -2498,7 +2502,7 @@ void SkiddingAI::setSteering(float angle, float dt)
     else
     {
         m_controls->setSteer( (old_steer-max_steer_change < steer_fraction)
-                              ? steer_fraction : old_steer-max_steer_change );
+                               ? steer_fraction : old_steer-max_steer_change );
     }
 
 
diff --git a/src/karts/controller/test_ai.hpp b/src/karts/controller/test_ai.hpp
index 61d10d14e..d0033d593 100644
--- a/src/karts/controller/test_ai.hpp
+++ b/src/karts/controller/test_ai.hpp
@@ -101,8 +101,8 @@ private:
     /** Distance to the kard behind. */
     float m_distance_behind;
 
-    /** The actual start delay used. */
-    float m_start_delay;
+    /** The actual start delay used in ticks. */
+    int m_start_delay;
 
     /** Time an item has been collected and not used. */
     float m_time_since_last_shot;
@@ -198,7 +198,7 @@ private:
      *specific action (more like, associated with inaction).
      */
     void  handleRaceStart();
-    void  handleAcceleration(const float dt);
+    void  handleAcceleration(int ticks);
     void  handleSteering(float dt);
     void  handleItems(const float dt);
     void  handleRescue(const float dt);
@@ -233,7 +233,7 @@ protected:
 public:
                  TestAI(AbstractKart *kart);
                 ~TestAI();
-    virtual void update      (float delta) ;
+    virtual void update      (int ticks);
     virtual void reset       ();
     virtual const irr::core::stringw& getNamePostfix() const;
 };
diff --git a/src/karts/explosion_animation.cpp b/src/karts/explosion_animation.cpp
index 8bc702aaf..b3cc63918 100644
--- a/src/karts/explosion_animation.cpp
+++ b/src/karts/explosion_animation.cpp
@@ -105,7 +105,7 @@ ExplosionAnimation::ExplosionAnimation(AbstractKart *kart,
 
     // Set invulnerable time, and graphical effects
     float t = m_kart->getKartProperties()->getExplosionInvulnerabilityTime();
-    m_kart->setInvulnerableTime(t);
+    m_kart->setInvulnerableTicks(stk_config->time2Ticks(t));
     m_kart->showStarEffect(t);
     
     m_kart->getAttachment()->clear();
diff --git a/src/karts/ghost_kart.cpp b/src/karts/ghost_kart.cpp
index 52e8d634a..43fc3c386 100644
--- a/src/karts/ghost_kart.cpp
+++ b/src/karts/ghost_kart.cpp
@@ -72,12 +72,12 @@ void GhostKart::addReplayEvent(float time,
 /** Updates the current event of the ghost kart using interpolation
  *  \param dt Time step size.
  */
-void GhostKart::update(float dt)
+void GhostKart::update(int ticks)
 {
     GhostController* gc = dynamic_cast<GhostController*>(getController());
     if (gc == NULL) return;
 
-    gc->update(dt);
+    gc->update(ticks);
     if (gc->isReplayEnd())
     {
         m_node->setVisible(false);
@@ -113,8 +113,9 @@ void GhostKart::update(float dt)
     center_shift.setY(m_graphical_y_offset);
     center_shift = getTrans().getBasis() * center_shift;
 
-    Moveable::updateGraphics(dt, center_shift, btQuaternion(0, 0, 0, 1));
+    Moveable::updateGraphics(ticks, center_shift, btQuaternion(0, 0, 0, 1));
     Moveable::updatePosition();
+    float dt = stk_config->ticks2Time(ticks);
     getKartModel()->update(dt, dt*(m_all_physic_info[idx].m_speed),
         m_all_physic_info[idx].m_steer, m_all_physic_info[idx].m_speed,
         /*lean*/0.0f, idx);
diff --git a/src/karts/ghost_kart.hpp b/src/karts/ghost_kart.hpp
index 009baa00d..c0a29447c 100644
--- a/src/karts/ghost_kart.hpp
+++ b/src/karts/ghost_kart.hpp
@@ -46,7 +46,7 @@ private:
 public:
                   GhostKart(const std::string& ident,
                             unsigned int world_kart_id, int position);
-    virtual void  update (float dt);
+    virtual void  update(int ticks);
     virtual void  reset();
     // ------------------------------------------------------------------------
     /** No physics body for ghost kart, so nothing to adjust. */
diff --git a/src/karts/kart.cpp b/src/karts/kart.cpp
index 532934e62..a951c3c34 100644
--- a/src/karts/kart.cpp
+++ b/src/karts/kart.cpp
@@ -124,10 +124,10 @@ Kart::Kart (const std::string& ident, unsigned int world_kart_id,
     m_finished_race        = false;
     m_race_result          = false;
     m_finish_time          = 0.0f;
-    m_bubblegum_time       = 0.0f;
+    m_bubblegum_ticks      = 0;
     m_bubblegum_torque     = 0.0f;
-    m_invulnerable_time    = 0.0f;
-    m_squash_time          = 0.0f;
+    m_invulnerable_ticks   = 0;
+    m_squash_ticks         = 0;
 
     m_shadow               = NULL;
     m_wheel_box            = NULL;
@@ -139,7 +139,7 @@ Kart::Kart (const std::string& ident, unsigned int world_kart_id,
     m_flying               = false;
     m_stars_effect         = NULL;
     m_is_jumping           = false;
-    m_min_nitro_time       = 0.0f;
+    m_min_nitro_ticks      = 0;
     m_fire_clicked         = 0;
     m_wrongway_counter     = 0;
     m_type                 = RaceManager::KT_AI;
@@ -316,7 +316,7 @@ void Kart::reset()
         Physics::getInstance()->addKart(this);
     }
 
-    m_min_nitro_time = 0.0f;
+    m_min_nitro_ticks = 0;
 
     // Reset star effect in case that it is currently being shown.
     m_stars_effect->reset();
@@ -348,22 +348,21 @@ void Kart::reset()
     m_finished_race        = false;
     m_eliminated           = false;
     m_finish_time          = 0.0f;
-    m_bubblegum_time       = 0.0f;
+    m_bubblegum_ticks      = 0;
     m_bubblegum_torque     = 0.0f;
-    m_invulnerable_time    = 0.0f;
-    m_squash_time          = 0.0f;
+    m_invulnerable_ticks   = 0;
+    m_squash_ticks         = 0;
     m_node->setScale(core::vector3df(1.0f, 1.0f, 1.0f));
     m_collected_energy     = 0;
     m_has_started          = false;
-    m_bounce_back_time     = 0.0f;
-    m_brake_time           = 0.0f;
+    m_bounce_back_ticks    = 0;
+    m_brake_ticks          = 0;
     m_ticks_last_crash     = 0;
     m_speed                = 0.0f;
     m_smoothed_speed       = 0.0f;
     m_current_lean         = 0.0f;
-    m_view_blocked_by_plunger = 0.0f;
-    m_bubblegum_time       = 0.0f;
-    m_bubblegum_torque     = 0.0f;
+    m_falling_ticks        = 0;
+    m_view_blocked_by_plunger = 0;
     m_has_caught_nolok_bubblegum = false;
     m_is_jumping           = false;
 
@@ -444,8 +443,8 @@ void Kart::setXYZ(const Vec3& a)
 
 // -----------------------------------------------------------------------------
 void Kart::increaseMaxSpeed(unsigned int category, float add_speed,
-                            float engine_force, float duration,
-                            float fade_out_time)
+                            float engine_force, int duration,
+                            int fade_out_time)
 {
     m_max_speed->increaseMaxSpeed(category, add_speed, engine_force, duration,
                                   fade_out_time);
@@ -453,7 +452,7 @@ void Kart::increaseMaxSpeed(unsigned int category, float add_speed,
 
 // -----------------------------------------------------------------------------
 void Kart::setSlowdown(unsigned int category, float max_speed_fraction,
-                       float fade_in_time)
+                       int fade_in_time)
 {
     m_max_speed->setSlowdown(category, max_speed_fraction, fade_in_time);
 }   // setSlowdown
@@ -464,9 +463,9 @@ float Kart::getCurrentMaxSpeed() const
     return m_max_speed->getCurrentMaxSpeed();
 }   // getCurrentMaxSpeed
 // -----------------------------------------------------------------------------
-float Kart::getSpeedIncreaseTimeLeft(unsigned int category) const
+int Kart::getSpeedIncreaseTicksLeft(unsigned int category) const
 {
-    return m_max_speed->getSpeedIncreaseTimeLeft(category);
+    return m_max_speed->getSpeedIncreaseTicksLeft(category);
 }   // getSpeedIncreaseTimeLeft
 
 // -----------------------------------------------------------------------------
@@ -544,7 +543,8 @@ void Kart::blockViewWithPlunger()
 {
     // Avoid that a plunger extends the plunger time
     if(m_view_blocked_by_plunger<=0 && !isShielded())
-        m_view_blocked_by_plunger = m_kart_properties->getPlungerInFaceTime();
+        m_view_blocked_by_plunger = 
+        stk_config->time2Ticks(m_kart_properties->getPlungerInFaceTime());
     if(isShielded())
     {
         decreaseShieldTime();
@@ -1020,14 +1020,15 @@ void Kart::collectedItem(Item *item, int add_info)
                                     item->getEmitter()->getIdent() == "nolok");
 
         // slow down
-        m_bubblegum_time = m_kart_properties->getBubblegumDuration();
+        m_bubblegum_ticks =
+            stk_config->time2Ticks(m_kart_properties->getBubblegumDuration());
         m_bubblegum_torque = ((rand()%2)
                            ?  m_kart_properties->getBubblegumTorque()
                            : -m_kart_properties->getBubblegumTorque());
         m_max_speed->setSlowdown(MaxSpeed::MS_DECREASE_BUBBLE,
                                  m_kart_properties->getBubblegumSpeedFraction() ,
-                                 m_kart_properties->getBubblegumFadeInTime(),
-                                 m_bubblegum_time);
+                                 m_kart_properties->getBubblegumFadeInTicks(),
+                                 m_bubblegum_ticks);
         getNextEmitter()->play(getXYZ(), m_goo_sound);
 
         // Play appropriate custom character sound
@@ -1206,19 +1207,19 @@ void Kart::eliminate()
  *  particle effects, camera position, etc.
  *  \param dt Time step size.
  */
-void Kart::update(float dt)
+void Kart::update(int ticks)
 {
     // Reset any instand speed increase in the bullet kart
     m_vehicle->setMinSpeed(0);
 
     // update star effect (call will do nothing if stars are not activated)
-    m_stars_effect->update(dt);
+    m_stars_effect->update(stk_config->ticks2Time(ticks));
 
-    if(m_squash_time>=0)
+    if(m_squash_ticks>=0)
     {
-        m_squash_time-=dt;
+        m_squash_ticks-=ticks;
         // If squasing time ends, reset the model
-        if(m_squash_time<=0)
+        if(m_squash_ticks<=0)
         {
             m_node->setScale(core::vector3df(1.0f, 1.0f, 1.0f));
             scene::ISceneNode* node =
@@ -1236,10 +1237,10 @@ void Kart::update(float dt)
         }
     }   // if squashed
 
-    if (m_bubblegum_time > 0.0f)
+    if (m_bubblegum_ticks > 0.0f)
     {
-        m_bubblegum_time -= dt;
-        if (m_bubblegum_time <= 0.0f)
+        m_bubblegum_ticks -= ticks;
+        if (m_bubblegum_ticks <= 0.0f)
         {
             m_bubblegum_torque = 0.0f;
         }
@@ -1251,6 +1252,7 @@ void Kart::update(float dt)
     // before updating the graphical position (which is done in
     // Moveable::update() ), otherwise 'stuttering' can happen (caused by
     // graphical and physical position not being the same).
+    float dt = stk_config->ticks2Time(ticks);
     if (has_animation_before)
     {
         m_kart_animation->update(dt);
@@ -1258,7 +1260,7 @@ void Kart::update(float dt)
     // Update the position and other data taken from the physics (or
     // an animation which calls setXYZ(), which also updates the kart
     // physical position).
-    Moveable::update(dt);
+    Moveable::update(ticks);
 
     Vec3 front(0, 0, getKartLength()*0.5f);
     m_xyz_front = getTrans()(front);
@@ -1267,14 +1269,14 @@ void Kart::update(float dt)
     updateSpeed();
 
     if(!history->replayHistory() || !history->dontDoPhysics())
-        m_controller->update(dt);
+        m_controller->update(ticks);
 
 #ifndef SERVER_ONLY
 #undef DEBUG_CAMERA_SHAKE
 #ifdef DEBUG_CAMERA_SHAKE
-    Log::verbose("camera", "%s t %f %f xyz %f %f %f v %f %f %f d3 %f d2 %f",
+    Log::verbose("camera", "%s t %f %d xyz %f %f %f v %f %f %f d3 %f d2 %f",
         getIdent().c_str(),
-        World::getWorld()->getTime(), dt,
+        World::getWorld()->getTime(), ticks,
         getXYZ().getX(), getXYZ().getY(), getXYZ().getZ(),
         getVelocity().getX(), getVelocity().getY(), getVelocity().getZ(),
         (Camera::getCamera(0)->getXYZ()-getXYZ()).length(),
@@ -1287,9 +1289,9 @@ void Kart::update(float dt)
 #ifdef DEBUG_TO_COMPARE_KART_PHYSICS
     // This information is useful when comparing kart physics, e.g. to
     // see top speed, acceleration (i.e. time to top speed) etc.
-    Log::verbose("physics", "     %s t %f %f xyz(9-11) %f %f %f v(13-15) %f %f %f steerf(17) %f maxangle(19) %f speed(21) %f steering(23-24) %f %f clock %lf",
+    Log::verbose("physics", "     %s t %f %d xyz(9-11) %f %f %f v(13-15) %f %f %f steerf(17) %f maxangle(19) %f speed(21) %f steering(23-24) %f %f clock %lf",
         getIdent().c_str(),
-        World::getWorld()->getTime(), dt,
+        World::getWorld()->getTime(), ticks,
         getXYZ().getX(), getXYZ().getY(), getXYZ().getZ(),
         getVelocity().getX(), getVelocity().getY(), getVelocity().getZ(),  //13,14,15
         m_skidding->getSteeringFraction(), //19
@@ -1302,17 +1304,17 @@ void Kart::update(float dt)
 #endif
 
     // if its view is blocked by plunger, decrease remaining time
-    if(m_view_blocked_by_plunger > 0) m_view_blocked_by_plunger -= dt;
+    if(m_view_blocked_by_plunger > 0) m_view_blocked_by_plunger -= ticks;
     //unblock the view if kart just became shielded
     if(isShielded())
-        m_view_blocked_by_plunger = 0.0f;
+        m_view_blocked_by_plunger = 0;
     // Decrease remaining invulnerability time
-    if(m_invulnerable_time>0)
+    if(m_invulnerable_ticks>0)
     {
-        m_invulnerable_time-=dt;
+        m_invulnerable_ticks -= ticks;
     }
 
-    m_slipstream->update(dt);
+    m_slipstream->update(ticks);
 
     // TODO: hiker said this probably will be moved to btKart or so when updating bullet engine.
     // Neutralize any yaw change if the kart leaves the ground, so the kart falls more or less
@@ -1343,13 +1345,13 @@ void Kart::update(float dt)
     // Used to prevent creating a rescue animation after an explosion animation
     // got deleted
 
-    m_attachment->update(dt);
+    m_attachment->update(ticks);
 
     m_kart_gfx->update(dt);
     if (m_collision_particles) m_collision_particles->update(dt);
 
     PROFILER_PUSH_CPU_MARKER("Kart::updatePhysics", 0x60, 0x34, 0x7F);
-    updatePhysics(dt);
+    updatePhysics(ticks);
     PROFILER_POP_CPU_MARKER();
 
     if(!m_controls.getFire()) m_fire_clicked = 0;
@@ -1471,7 +1473,7 @@ void Kart::update(float dt)
     }
 
     PROFILER_PUSH_CPU_MARKER("Kart::Update (material)", 0x60, 0x34, 0x7F);
-    handleMaterialGFX(dt);
+    handleMaterialGFX(ticks);
     const Material* material=m_terrain_info->getMaterial();
     if (!material)   // kart falling off the track
     {
@@ -1523,14 +1525,14 @@ void Kart::update(float dt)
         {
             m_max_speed->setSlowdown(MaxSpeed::MS_DECREASE_TERRAIN,
                                      material->getMaxSpeedFraction(),
-                                     material->getSlowDownTime()     );
+                                     material->getSlowDownTicks()    );
 #ifdef DEBUG
             if(UserConfigParams::m_material_debug)
             {
                 Log::info("Kart","%s\tfraction %f\ttime %f.",
                        material->getTexFname().c_str(),
                        material->getMaxSpeedFraction(),
-                       material->getSlowDownTime()       );
+                       material->getSlowDownTicks()       );
             }
 #endif
         }
@@ -1548,12 +1550,16 @@ void Kart::update(float dt)
     static video::SColor green(255, 61, 87, 23);
 
 #ifndef SERVER_ONLY
-    // draw skidmarks if relevant (we force pink skidmarks on when hitting a bubblegum)
+    // draw skidmarks if relevant (we force pink skidmarks on when hitting 
+    // a bubblegum)
     if(m_kart_properties->getSkidEnabled() && m_skidmarks)
     {
         m_skidmarks->update(dt,
-                            m_bubblegum_time > 0,
-                            (m_bubblegum_time > 0 ? (m_has_caught_nolok_bubblegum ? &green : &pink) : NULL) );
+                            m_bubblegum_ticks > 0,
+                            (m_bubblegum_ticks > 0 
+                                ? (m_has_caught_nolok_bubblegum ? &green 
+                                                                : &pink) 
+                                : NULL            )                     );
     }
 #endif
 
@@ -1561,7 +1567,7 @@ void Kart::update(float dt)
 
     if (emergency)
     {
-        m_view_blocked_by_plunger = 0.0f;
+        m_view_blocked_by_plunger = 0;
         if (m_flying)
         {
             stopFlying();
@@ -1695,7 +1701,8 @@ void Kart::setSquash(float time, float slowdown)
     }
     m_node->setScale(core::vector3df(1.0f, 0.5f, 1.0f));
     m_max_speed->setSlowdown(MaxSpeed::MS_DECREASE_SQUASH, slowdown,
-                             0.1f, time);
+                             stk_config->time2Ticks(0.1f), 
+                             stk_config->time2Ticks(time));
     if (m_vehicle->getNumWheels() > 0)
     {
         if (!m_wheel_box)
@@ -1708,7 +1715,7 @@ void Kart::setSquash(float time, float slowdown)
         }
         m_wheel_box->getRelativeTransformationMatrix().setScale(core::vector3df(1.0f, 2.0f, 1.0f));
     }
-    m_squash_time  = time;
+    m_squash_ticks  = stk_config->time2Ticks(time);
 }   // setSquash
 
 //-----------------------------------------------------------------------------
@@ -1796,7 +1803,7 @@ void Kart::handleMaterialSFX(const Material *material)
  *  kart is falling, or if the surface the kart is driving on has
  *  the 'isBelowSurface' property set.
  */
-void Kart::handleMaterialGFX(float dt)
+void Kart::handleMaterialGFX(int ticks)
 {
     const Material *material = getMaterial();
 
@@ -1833,19 +1840,19 @@ void Kart::handleMaterialGFX(float dt)
         bool falling = material && material->hasFallingEffect() && !m_flying;
         if (falling)
         {
-            m_falling_time -= dt;
-            if (m_falling_time < 0.0f)
-                m_falling_time = 0.0f;
+            m_falling_ticks -= ticks;
+            if (m_falling_ticks < 0)
+                m_falling_ticks = 0;
         }
         else
-            m_falling_time = 0.35f;
+            m_falling_ticks = stk_config->time2Ticks(0.35f);
 
         for(unsigned int i=0; i<Camera::getNumCameras(); i++)
         {
             Camera *camera = Camera::getCamera(i);
             if(camera->getKart()!=this) continue;
 
-            if (falling && m_falling_time <= 0.0f)
+            if (falling && m_falling_ticks <= 0)
             {
                 camera->setMode(Camera::CM_FALLING);
             }
@@ -1966,7 +1973,9 @@ void Kart::handleZipper(const Material *material, bool play_sound)
 
     m_max_speed->instantSpeedIncrease(MaxSpeed::MS_INCREASE_ZIPPER,
                                      max_speed_increase, speed_gain,
-                                     engine_force, duration, fade_out_time);
+                                     engine_force,
+                                     stk_config->time2Ticks(duration),
+                                     stk_config->time2Ticks(fade_out_time));
     // Play custom character sound (weee!)
     playCustomSFX(SFXManager::CUSTOM_ZIPPER);
     m_controller->handleZipper(play_sound);
@@ -1974,32 +1983,33 @@ void Kart::handleZipper(const Material *material, bool play_sound)
 
 // -----------------------------------------------------------------------------
 /** Updates the current nitro status.
- *  \param dt Time step size.
+ *  \param ticks Number of physics time steps - should be 1.
  */
-void Kart::updateNitro(float dt)
+void Kart::updateNitro(int ticks)
 {
-    if (m_controls.getNitro() && m_min_nitro_time <= 0.0f)
+    if (m_controls.getNitro() && m_min_nitro_ticks <= 0)
     {
-        m_min_nitro_time = m_kart_properties->getNitroMinConsumptionTime();
+        m_min_nitro_ticks = m_kart_properties->getNitroMinConsumptionTicks();
     }
-    if (m_min_nitro_time > 0.0f)
+    if (m_min_nitro_ticks > 0)
     {
-        m_min_nitro_time -= dt;
+        m_min_nitro_ticks -= ticks;
 
         // when pressing the key, don't allow the min time to go under zero.
         // If it went under zero, it would be reset
-        if (m_controls.getNitro() && m_min_nitro_time <= 0.0f)
-            m_min_nitro_time = 0.1f;
+        if (m_controls.getNitro() && m_min_nitro_ticks <= 0)
+            m_min_nitro_ticks = 1;
     }
 
     bool increase_speed = (m_controls.getNitro() && isOnGround());
-    if (!increase_speed && m_min_nitro_time <= 0.0f)
+    if (!increase_speed && m_min_nitro_ticks <= 0)
     {
         if(m_nitro_sound->getStatus() == SFXBase::SFX_PLAYING)
             m_nitro_sound->stop();
         return;
     }
 
+    float dt = stk_config->ticks2Time(ticks);
     m_collected_energy -= dt * m_kart_properties->getNitroConsumption();
     if (m_collected_energy < 0)
     {
@@ -2014,10 +2024,10 @@ void Kart::updateNitro(float dt)
         if(m_nitro_sound->getStatus() != SFXBase::SFX_PLAYING)
             m_nitro_sound->play();
         m_max_speed->increaseMaxSpeed(MaxSpeed::MS_INCREASE_NITRO,
-                                     m_kart_properties->getNitroMaxSpeedIncrease(),
-                                     m_kart_properties->getNitroEngineForce(),
-                                     m_kart_properties->getNitroDuration(),
-                                     m_kart_properties->getNitroFadeOutTime());
+            m_kart_properties->getNitroMaxSpeedIncrease(),
+            m_kart_properties->getNitroEngineForce(),
+            stk_config->time2Ticks(m_kart_properties->getNitroDuration()),
+            stk_config->time2Ticks(m_kart_properties->getNitroFadeOutTime()));
     }
     else
     {
@@ -2096,8 +2106,7 @@ void Kart::crashed(const Material *m, const Vec3 &normal)
         float abs_speed = fabsf(getSpeed());
         impulse *= ( abs_speed<10 ? 10.0f : sqrt(abs_speed) )
                  * m_kart_properties->getCollisionTerrainImpulse();
-        m_bounce_back_time = 0.2f;
-        m_bounce_back_time = 0.0f;;
+        m_bounce_back_ticks = 0;
         impulse = Vec3(0, 0, 0);
         //m_vehicle->setTimedCentralImpulse(0.1f, impulse);
         m_vehicle->setTimedCentralImpulse(0.0, impulse);
@@ -2125,7 +2134,7 @@ void Kart::crashed(const Material *m, const Vec3 &normal)
             else
                 impulse = Vec3(0, 0, -1); // Arbitrary
             impulse *= m_kart_properties->getCollisionTerrainImpulse();
-            m_bounce_back_time = 0.2f;
+            m_bounce_back_ticks = stk_config->time2Ticks(0.2f);
             m_vehicle->setTimedCentralImpulse(0.1f, impulse);
         }
 
@@ -2173,13 +2182,13 @@ void Kart::crashed(const Material *m, const Vec3 &normal)
         else if (m->getCollisionReaction() == Material::PUSH_BACK)
         {
             // This variable is set to 0.2 in case of a kart-terrain collision
-            if (m_bounce_back_time <= 0.2f)
+            if (m_bounce_back_ticks <= stk_config->time2Ticks(0.2f))
             {
                 btVector3 push = m_body->getLinearVelocity().normalized();
                 push[1] = 0.1f;
                 m_body->applyCentralImpulse( -4000.0f*push );
-                m_bounce_back_time = 2.0f;
-            }   // if m_bounce_back_time <= 0.2f
+                m_bounce_back_ticks = stk_config->time2Ticks(2.0f);
+            }   // if m_bounce_back_ticks <= 0.2f
         }   // if (m->getCollisionReaction() == Material::PUSH_BACK)
     }   // if(m && m->getCollisionReaction() != Material::NORMAL &&
         //   !getKartAnimation())
@@ -2200,7 +2209,7 @@ void Kart::playCrashSFX(const Material* m, AbstractKart *k)
     // After a collision disable the engine for a short time so that karts
     // can 'bounce back' a bit (without this the engine force will prevent
     // karts from bouncing back, they will instead stuck towards the obstable).
-    if(m_bounce_back_time<=0.0f)
+    if(m_bounce_back_ticks <= 0)
     {
         if (getVelocity().length()> 0.555f)
         {
@@ -2244,7 +2253,7 @@ void Kart::playCrashSFX(const Material* m, AbstractKart *k)
                 crash_sound_emitter->play(getXYZ(), buffer);
             }
         }    // if lin_vel > 0.555
-    }   // if m_bounce_back_time <= 0
+    }   // if m_bounce_back_ticks <= 0
 }   // playCrashSFX
 
 // -----------------------------------------------------------------------------
@@ -2327,9 +2336,9 @@ bool Kart::playCustomSFX(unsigned int type)
 // ----------------------------------------------------------------------------
 /** Updates the physics for this kart: computing the driving force, set
  *  steering, handles skidding, terrain impact on kart, ...
- *  \param dt Time step size.
+ *  \param ticks Number if physics time steps - should be 1.
  */
-void Kart::updatePhysics(float dt)
+void Kart::updatePhysics(int ticks)
 {
     // Check if accel is pressed for the first time. The actual timing
     // is done in getStartupBoost - it returns 0 if the start was actually
@@ -2342,22 +2351,22 @@ void Kart::updatePhysics(float dt)
         {
             m_kart_gfx->setCreationRateAbsolute(KartGFX::KGFX_ZIPPER, 100*f);
             m_max_speed->instantSpeedIncrease(MaxSpeed::MS_INCREASE_ZIPPER,
-                                              0.9f*f, f,
-                                              /*engine_force*/200.0f,
-                                              /*duration*/5.0f,
-                                              /*fade_out_time*/5.0f);
+                            0.9f*f, f,
+                            /*engine_force*/200.0f,
+                            /*duration*/stk_config->time2Ticks(5.0f),
+                            /*fade_out_time*/stk_config->time2Ticks(5.0f));
         }
     }
 
-    m_bounce_back_time-=dt;
+    m_bounce_back_ticks-=ticks;
 
-    updateEnginePowerAndBrakes(dt);
+    updateEnginePowerAndBrakes(ticks);
 
     // apply flying physics if relevant
     if (m_flying)
         updateFlying();
 
-    m_skidding->update(dt, isOnGround(), m_controls.getSteer(),
+    m_skidding->update(ticks, isOnGround(), m_controls.getSteer(),
                        m_controls.getSkidControl());
     m_vehicle->setVisualRotation(m_skidding->getVisualSkidRotation());
     if(( m_skidding->getSkidState() == Skidding::SKID_ACCUMULATE_LEFT ||
@@ -2383,10 +2392,10 @@ void Kart::updatePhysics(float dt)
 
     float min_speed =  m && m->isZipper() ? m->getZipperMinSpeed() : -1.0f;
     m_max_speed->setMinSpeed(min_speed);
-    m_max_speed->update(dt);
+    m_max_speed->update(ticks);
 
 
-    updateEngineSFX(dt);
+    updateEngineSFX(stk_config->ticks2Time(ticks));
 #ifdef XX
     Log::info("Kart","angVel %f %f %f heading %f suspension %f %f %f %f"
        ,m_body->getAngularVelocity().getX()
@@ -2447,9 +2456,9 @@ void Kart::updateEngineSFX(float dt)
 /** Sets the engine power. It considers the engine specs, items that influence
  *  the available power, and braking/steering.
  */
-void Kart::updateEnginePowerAndBrakes(float dt)
+void Kart::updateEnginePowerAndBrakes(int ticks)
 {
-    updateNitro(dt);
+    updateNitro(ticks);
     float engine_power = getActualWheelForce();
 
     // apply parachute physics if relevant
@@ -2457,7 +2466,7 @@ void Kart::updateEnginePowerAndBrakes(float dt)
         engine_power*=0.2f;
 
     // apply bubblegum physics if relevant
-    if (m_bubblegum_time > 0.0f)
+    if (m_bubblegum_ticks > 0)
     {
         engine_power = 0.0f;
         m_body->applyTorque(btVector3(0.0, m_bubblegum_torque, 0.0));
@@ -2467,7 +2476,7 @@ void Kart::updateEnginePowerAndBrakes(float dt)
     {
         // For a short time after a collision disable the engine,
         // so that the karts can bounce back a bit from the obstacle.
-        if(m_bounce_back_time>0.0f)
+        if(m_bounce_back_ticks>0.0f)
             engine_power = 0.0f;
         // let a player going backwards accelerate quickly (e.g. if a player
         // hits a wall, he needs to be able to start again quickly after
@@ -2487,7 +2496,7 @@ void Kart::updateEnginePowerAndBrakes(float dt)
         if(m_vehicle->getWheelInfo(0).m_brake &&
             !World::getWorld()->isStartPhase())
             m_vehicle->setAllBrakes(0);
-        m_brake_time = 0;
+        m_brake_ticks = 0;
     }
     else
     {   // not accelerating
@@ -2497,10 +2506,10 @@ void Kart::updateEnginePowerAndBrakes(float dt)
             if(m_speed > 0.0f)
             {   // Still going forward while braking
                 applyEngineForce(-engine_power*2.5f);
-                m_brake_time += dt;
+                m_brake_ticks += ticks;
                 // Apply the brakes - include the time dependent brake increase
-                float f = 1 + m_brake_time
-                            * m_kart_properties->getEngineBrakeTimeIncrease();
+                float f = 1.0f + stk_config->ticks2Time(m_brake_ticks)
+                               * m_kart_properties->getEngineBrakeTimeIncrease();
                 m_vehicle->setAllBrakes(m_kart_properties->getEngineBrakeFactor() * f);
             }
             else   // m_speed < 0
@@ -2525,7 +2534,7 @@ void Kart::updateEnginePowerAndBrakes(float dt)
         }
         else   // !m_brake
         {
-            m_brake_time = 0;
+            m_brake_ticks = 0;
             // lift the foot from throttle, brakes with 10% engine_power
             assert(!std::isnan(m_controls.getAccel()));
             assert(!std::isnan(engine_power));
@@ -2847,14 +2856,14 @@ SFXBase* Kart::getNextEmitter()
  *  \param offset_xyz Offset to be added to the position.
  *  \param rotation Additional rotation.
  */
-void Kart::updateGraphics(float dt, const Vec3& offset_xyz,
+void Kart::updateGraphics(int ticks, const Vec3& offset_xyz,
                           const btQuaternion& rotation)
 {
     // Upate particle effects (creation rate, and emitter size
     // depending on speed)
     // --------------------------------------------------------
     float nitro_frac = 0;
-    if ( (m_controls.getNitro() || m_min_nitro_time > 0.0f) &&
+    if ( (m_controls.getNitro() || m_min_nitro_ticks > 0) &&
          isOnGround() &&  m_collected_energy > 0            )
     {
         // fabs(speed) is important, otherwise the negative number will
@@ -2882,6 +2891,8 @@ void Kart::updateGraphics(float dt, const Vec3& offset_xyz,
     const float steer_frac = m_skidding->getSteeringFraction();
 
     const float roll_speed = m_kart_properties->getLeanSpeed() * DEGREE_TO_RAD;
+
+    float dt = stk_config->ticks2Time(ticks);
     if(speed_frac > 0.8f && fabsf(steer_frac)>0.5f)
     {
         // Use steering ^ 7, which means less effect at lower
@@ -2934,7 +2945,7 @@ void Kart::updateGraphics(float dt, const Vec3& offset_xyz,
     center_shift = getTrans().getBasis() * center_shift;
 
     float heading = m_skidding->getVisualSkidRotation();
-    Moveable::updateGraphics(dt, center_shift,
+    Moveable::updateGraphics(ticks, center_shift,
                              btQuaternion(heading, 0, -m_current_lean));
 
     // m_speed*dt is the distance the kart has moved, which determines
diff --git a/src/karts/kart.hpp b/src/karts/kart.hpp
index e1b888be5..7aa7adee5 100644
--- a/src/karts/kart.hpp
+++ b/src/karts/kart.hpp
@@ -133,24 +133,24 @@ protected:
 
     /** How long the brake key has been pressed - the longer the harder
      *  the kart will brake. */
-    float        m_brake_time;
+    int          m_brake_ticks;
 
     /** A short time after a collision acceleration is disabled to allow
      *  the karts to bounce back*/
-    float        m_bounce_back_time;
+    int          m_bounce_back_ticks;
 
     /** Time a kart is invulnerable. */
-    float        m_invulnerable_time;
+    int          m_invulnerable_ticks;
 
     /** How long a kart is being squashed. If this is >0
      *  the kart is squashed. */
-    float        m_squash_time;
+    int          m_squash_ticks;
 
     /** Current leaning of the kart. */
     float        m_current_lean;
 
     /** If > 0 then bubble gum effect is on. This is the sliding when hitting a gum on the floor, not the shield. */
-    float        m_bubblegum_time;
+    int          m_bubblegum_ticks;
 
     /** The torque to apply after hitting a bubble gum. */
     float        m_bubblegum_torque;
@@ -159,7 +159,7 @@ protected:
     bool         m_fire_clicked;
 
     /** Counter which is used for displaying wrong way message after a delay */
-    float        m_wrongway_counter;
+    int          m_wrongway_counter;
 
 
     // Bullet physics parameters
@@ -193,11 +193,11 @@ protected:
     float           m_finish_time;
     bool            m_finished_race;
 
-    float           m_falling_time = 0.35f;
+    int             m_falling_ticks;
 
     /** When a kart has its view blocked by the plunger, this variable will be
      *  > 0 the number it contains is the time left before removing plunger. */
-    float         m_view_blocked_by_plunger;
+    int           m_view_blocked_by_plunger;
     /** The current speed (i.e. length of velocity vector) of this kart. */
     float         m_speed;
     /** For camera handling an exponentially smoothened value is used, which
@@ -227,17 +227,17 @@ protected:
     RaceManager::KartType m_type;
 
     /** To prevent using nitro in too short bursts */
-    float         m_min_nitro_time;
+    int           m_min_nitro_ticks;
 
-    void          updatePhysics(float dt);
+    void          updatePhysics(int ticks);
     void          handleMaterialSFX(const Material *material);
-    void          handleMaterialGFX(float dt);
+    void          handleMaterialGFX(int ticks);
     void          updateFlying();
     void          updateSliding();
-    void          updateEnginePowerAndBrakes(float dt);
+    void          updateEnginePowerAndBrakes(int ticks);
     void          updateEngineSFX(float dt);
     void          updateSpeed();
-    void          updateNitro(float dt);
+    void          updateNitro(int ticks);
     float         getActualWheelForce();
     void          playCrashSFX(const Material* m, AbstractKart *k);
     void          loadData(RaceManager::KartType type, bool animatedModel);
@@ -250,7 +250,7 @@ public:
     virtual       ~Kart();
     virtual void   init(RaceManager::KartType type);
     virtual void   kartIsInRestNow();
-    virtual void   updateGraphics(float dt, const Vec3& off_xyz,
+    virtual void   updateGraphics(int ticks, const Vec3& off_xyz,
                                   const btQuaternion& off_rotation);
     virtual void   createPhysics    ();
     virtual void   updateWeight     ();
@@ -265,11 +265,11 @@ public:
     virtual void   startEngineSFX   ();
     virtual void   adjustSpeed      (float f);
     virtual void   increaseMaxSpeed(unsigned int category, float add_speed,
-                                    float engine_force, float duration,
-                                    float fade_out_time);
+                                    float engine_force, int duration,
+                                    int fade_out_time);
     virtual void   setSlowdown(unsigned int category, float max_speed_fraction,
-                               float fade_in_time);
-    virtual float getSpeedIncreaseTimeLeft(unsigned int category) const;
+                               int fade_in_time);
+    virtual int   getSpeedIncreaseTicksLeft(unsigned int category) const OVERRIDE;
     virtual void  collectedItem(Item *item, int random_attachment);
     virtual float getStartupBoost() const;
 
@@ -286,7 +286,7 @@ public:
     virtual void   crashed          (AbstractKart *k, bool update_attachments);
     virtual void   crashed          (const Material *m, const Vec3 &normal);
     virtual float  getHoT           () const;
-    virtual void   update           (float dt);
+    virtual void   update           (int ticks);
     virtual void   finishedRace     (float time, bool from_server=false);
     virtual void   setPosition      (int p);
     virtual void   beep             ();
@@ -335,7 +335,7 @@ public:
     virtual bool   hasFinishedRace     () const { return m_finished_race;    }
     // ------------------------------------------------------------------------
     /** Returns true if the kart has a plunger attached to its face. */
-    virtual float  getBlockedByPlungerTime() const
+    virtual int getBlockedByPlungerTicks() const
                                          { return m_view_blocked_by_plunger; }
     // ------------------------------------------------------------------------
     /** Sets that the view is blocked by a plunger. The duration depends on
@@ -416,10 +416,13 @@ public:
     virtual void eliminate();
     // ------------------------------------------------------------------------
     /** Makes a kart invulnerable for a certain amount of time. */
-    virtual void  setInvulnerableTime(float t) { m_invulnerable_time = t; }
+    virtual void setInvulnerableTicks(int ticks) OVERRIDE
+    { 
+        m_invulnerable_ticks = ticks;
+    }   // setInvulnerableTicks
     // ------------------------------------------------------------------------
     /** Returns if the kart is invulnerable. */
-    virtual bool   isInvulnerable() const { return m_invulnerable_time > 0; }
+    virtual bool isInvulnerable() const { return m_invulnerable_ticks > 0; }
     // ------------------------------------------------------------------------
     /** Enables a kart shield protection for a certain amount of time. */
     virtual void setShieldTime(float t);
@@ -440,10 +443,10 @@ public:
     /** Return whether nitro is being used despite the nitro button not being
      *  pressed due to minimal use time requirements
      */
-    virtual float isOnMinNitroTime() const { return m_min_nitro_time > 0.0f; }
+    virtual bool isOnMinNitroTime() const { return m_min_nitro_ticks > 0; }
     // ------------------------------------------------------------------------
     /** Returns if the kart is currently being squashed. */
-    virtual bool   isSquashed() const { return m_squash_time >0; }
+    virtual bool isSquashed() const { return m_squash_ticks >0; }
     // ------------------------------------------------------------------------
     /** Shows the star effect for a certain time. */
     virtual void showStarEffect(float t);
@@ -461,9 +464,9 @@ public:
     bool isFlying() const { return m_flying;  }
     // ------------------------------------------------------------------------
     /** Counter which is used for displaying wrong way message after a delay */
-    float getWrongwayCounter() { return m_wrongway_counter; }
+    int getWrongwayCounter() { return m_wrongway_counter; }
     // ------------------------------------------------------------------------
-    void setWrongwayCounter(float counter) { m_wrongway_counter = counter; }
+    void setWrongwayCounter(int counter) { m_wrongway_counter = counter; }
     // ------------------------------------------------------------------------
     /** Returns whether this kart wins or loses. */
     virtual bool getRaceResult() const { return m_race_result;  }
diff --git a/src/karts/kart_properties.cpp b/src/karts/kart_properties.cpp
index c29a1d718..ca4787ece 100644
--- a/src/karts/kart_properties.cpp
+++ b/src/karts/kart_properties.cpp
@@ -839,9 +839,10 @@ float KartProperties::getBubblegumTorque() const
 }  // getBubblegumTorque
 
 // ----------------------------------------------------------------------------
-float KartProperties::getBubblegumFadeInTime() const
+int KartProperties::getBubblegumFadeInTicks() const
 {
-    return m_cached_characteristic->getBubblegumFadeInTime();
+    return stk_config->time2Ticks(m_cached_characteristic
+                                  ->getBubblegumFadeInTime());
 }  // getBubblegumFadeInTime
 
 // ----------------------------------------------------------------------------
@@ -929,9 +930,10 @@ float KartProperties::getPlungerBandSpeedIncrease() const
 }  // getPlungerBandSpeedIncrease
 
 // ----------------------------------------------------------------------------
-float KartProperties::getPlungerBandFadeOutTime() const
+int KartProperties::getPlungerBandFadeOutTicks() const
 {
-    return m_cached_characteristic->getPlungerBandFadeOutTime();
+    return stk_config->time2Ticks(m_cached_characteristic
+                                   ->getPlungerBandFadeOutTime());
 }  // getPlungerBandFadeOutTime
 
 // ----------------------------------------------------------------------------
@@ -994,6 +996,15 @@ float KartProperties::getNitroDuration() const
     return m_cached_characteristic->getNitroDuration();
 }  // getNitroDuration
 
+// ------------------------------------------------------------------------
+/** Returns minimum time during which nitro is consumed when pressing nitro
+ *  key, to prevent using nitro in very short bursts
+  */
+int KartProperties::getNitroMinConsumptionTicks() const
+{
+    return stk_config->time2Ticks(m_nitro_min_consumption);
+}
+
 // ----------------------------------------------------------------------------
 float KartProperties::getNitroEngineForce() const
 {
@@ -1037,9 +1048,10 @@ float KartProperties::getNitroMax() const
 }  // getNitroMax
 
 // ----------------------------------------------------------------------------
-float KartProperties::getSlipstreamDuration() const
+int KartProperties::getSlipstreamDuration() const
 {
-    return m_cached_characteristic->getSlipstreamDuration();
+    return stk_config->time2Ticks( m_cached_characteristic
+                                   ->getSlipstreamDuration() );
 }  // getSlipstreamDuration
 
 // ----------------------------------------------------------------------------
@@ -1055,9 +1067,9 @@ float KartProperties::getSlipstreamWidth() const
 }  // getSlipstreamWidth
 
 // ----------------------------------------------------------------------------
-float KartProperties::getSlipstreamCollectTime() const
+int KartProperties::getSlipstreamCollectTicks() const
 {
-    return m_cached_characteristic->getSlipstreamCollectTime();
+    return m_cached_characteristic->getSlipstreamCollectTicks();
 }  // getSlipstreamCollectTime
 
 // ----------------------------------------------------------------------------
@@ -1085,9 +1097,10 @@ float KartProperties::getSlipstreamMaxSpeedIncrease() const
 }  // getSlipstreamMaxSpeedIncrease
 
 // ----------------------------------------------------------------------------
-float KartProperties::getSlipstreamFadeOutTime() const
+int KartProperties::getSlipstreamFadeOutTicks() const
 {
-    return m_cached_characteristic->getSlipstreamFadeOutTime();
+    return stk_config->time2Ticks(m_cached_characteristic
+                                  ->getSlipstreamFadeOutTime());
 }  // getSlipstreamFadeOutTime
 
 // ----------------------------------------------------------------------------
diff --git a/src/karts/kart_properties.hpp b/src/karts/kart_properties.hpp
index 235ed561c..eaee98703 100644
--- a/src/karts/kart_properties.hpp
+++ b/src/karts/kart_properties.hpp
@@ -352,11 +352,6 @@ public:
     /** Returns the full path where the files for this kart are stored. */
     const std::string& getKartDir   () const {return m_root;                  }
 
-    // ------------------------------------------------------------------------
-    /** Returns minimum time during which nitro is consumed when pressing nitro
-     *  key, to prevent using nitro in very short bursts
-     */
-    float getNitroMinConsumptionTime() const { return m_nitro_min_consumption; }
     // ------------------------------------------------------------------------
     /** Returns the bevel factor (!=0 indicates to use a bevelled box). */
     const Vec3 &getBevelFactor() const { return m_bevel_factor; }
@@ -440,7 +435,7 @@ public:
     float getBubblegumDuration() const;
     float getBubblegumSpeedFraction() const;
     float getBubblegumTorque() const;
-    float getBubblegumFadeInTime() const;
+    int   getBubblegumFadeInTicks() const;
     float getBubblegumShieldDuration() const;
 
     float getZipperDuration() const;
@@ -458,7 +453,7 @@ public:
     float getPlungerBandForce() const;
     float getPlungerBandDuration() const;
     float getPlungerBandSpeedIncrease() const;
-    float getPlungerBandFadeOutTime() const;
+    int   getPlungerBandFadeOutTicks() const;
     float getPlungerInFaceTime() const;
 
     std::vector<float> getStartupTime() const;
@@ -480,16 +475,18 @@ public:
     float getNitroMaxSpeedIncrease() const;
     float getNitroFadeOutTime() const;
     float getNitroMax() const;
+    int   getNitroMinConsumptionTicks() const;
+    // ------------------------------------------------------------------------
 
-    float getSlipstreamDuration() const;
+    int getSlipstreamDuration() const;
     float getSlipstreamLength() const;
     float getSlipstreamWidth() const;
-    float getSlipstreamCollectTime() const;
+    int   getSlipstreamCollectTicks() const;
     float getSlipstreamUseTime() const;
     float getSlipstreamAddPower() const;
     float getSlipstreamMinSpeed() const;
     float getSlipstreamMaxSpeedIncrease() const;
-    float getSlipstreamFadeOutTime() const;
+    int getSlipstreamFadeOutTicks() const;
 
     float getSkidIncrease() const;
     float getSkidDecrease() const;
diff --git a/src/karts/kart_rewinder.cpp b/src/karts/kart_rewinder.cpp
index 63fdcf343..648b64303 100644
--- a/src/karts/kart_rewinder.cpp
+++ b/src/karts/kart_rewinder.cpp
@@ -181,9 +181,9 @@ void KartRewinder::rewindToState(BareNetworkString *buffer)
 /** Called once a frame. It will add a new kart control event to the rewind
  *  manager if any control values have changed.
  */
-void KartRewinder::update(float dt)
+void KartRewinder::update(int ticks)
 {
-    Kart::update(dt);
+    Kart::update(ticks);
 }   // update
 
 // ----------------------------------------------------------------------------
diff --git a/src/karts/kart_rewinder.hpp b/src/karts/kart_rewinder.hpp
index 1cd4e981d..b87c6f03e 100644
--- a/src/karts/kart_rewinder.hpp
+++ b/src/karts/kart_rewinder.hpp
@@ -49,7 +49,7 @@ public:
    void          reset();
    virtual void  rewindToState(BareNetworkString *p) OVERRIDE;
    virtual void  rewindToEvent(BareNetworkString *p) OVERRIDE;
-   virtual void  update(float dt);
+   virtual void  update(int ticks) OVERRIDE;
 
    // -------------------------------------------------------------------------
    virtual void  undoState(BareNetworkString *p) OVERRIDE
diff --git a/src/karts/kart_with_stats.cpp b/src/karts/kart_with_stats.cpp
index c77e04bdd..b1c8f22c8 100644
--- a/src/karts/kart_with_stats.cpp
+++ b/src/karts/kart_with_stats.cpp
@@ -58,10 +58,11 @@ void KartWithStats::reset()
  *  statistics for this kart.
  *  \param dt Time step size.
  */
-void KartWithStats::update(float dt)
+void KartWithStats::update(int ticks)
 {
-    Kart::update(dt);
+    Kart::update(ticks);
     if(getSpeed()>m_top_speed        ) m_top_speed = getSpeed();
+    float dt = stk_config->ticks2Time(ticks);
     if(getControls().getSkidControl()) m_skidding_time += dt;
     if(getControls().getBrake()      ) m_brake_count ++;
     LinearWorld *world = dynamic_cast<LinearWorld*>(World::getWorld());
diff --git a/src/karts/kart_with_stats.hpp b/src/karts/kart_with_stats.hpp
index 906d174a6..89086da96 100644
--- a/src/karts/kart_with_stats.hpp
+++ b/src/karts/kart_with_stats.hpp
@@ -76,7 +76,7 @@ public:
                                int position,
                                const btTransform& init_transform,
                                PerPlayerDifficulty difficulty);
-    virtual void update(float dt);
+    virtual void update(int ticks) OVERRIDE;
     virtual void reset();
     virtual void collectedItem(Item *item, int add_info);
     virtual void setKartAnimation(AbstractKartAnimation *ka);
diff --git a/src/karts/max_speed.cpp b/src/karts/max_speed.cpp
index f9d4e9412..70692ed2c 100644
--- a/src/karts/max_speed.cpp
+++ b/src/karts/max_speed.cpp
@@ -18,13 +18,14 @@
 
 #include "karts/max_speed.hpp"
 
-#include <algorithm>
-#include <assert.h>
-
+#include "config/stk_config.hpp"
 #include "karts/abstract_kart.hpp"
 #include "karts/kart_properties.hpp"
 #include "physics/btKart.hpp"
 
+#include <algorithm>
+#include <assert.h>
+
 /** This class handles maximum speed for karts. Several factors can influence
  *  the maximum speed a kart can drive, some will decrease the maximum speed,
  *  some will increase the maximum speed.
@@ -88,8 +89,8 @@ void MaxSpeed::reset()
  *  \param fade_out_time How long the maximum speed will fade out linearly.
  */
 void MaxSpeed::increaseMaxSpeed(unsigned int category, float add_speed,
-                                float engine_force, float duration,
-                                float fade_out_time)
+                                float engine_force, int duration,
+                                int fade_out_time)
 {
     // Allow fade_out_time 0 if add_speed is set to 0.
     assert(add_speed==0.0f || fade_out_time>0.01f);
@@ -117,8 +118,8 @@ void MaxSpeed::increaseMaxSpeed(unsigned int category, float add_speed,
  */
 void MaxSpeed::instantSpeedIncrease(unsigned int category,
                                    float add_max_speed, float speed_boost,
-                                   float engine_force, float duration,
-                                   float fade_out_time)
+                                   float engine_force, int duration,
+                                   int fade_out_time)
 {
     increaseMaxSpeed(category, add_max_speed, engine_force, duration,
                      fade_out_time);
@@ -144,9 +145,9 @@ void MaxSpeed::instantSpeedIncrease(unsigned int category,
  *  -m_fade_out_time and 0, the maximum speed will linearly decrease.
  *  \param dt Time step size.
  */
-void MaxSpeed::SpeedIncrease::update(float dt)
+void MaxSpeed::SpeedIncrease::update(int ticks)
 {
-    m_duration -= dt;
+    m_duration -= ticks;
     // End of increased max speed reached.
     if(m_duration < -m_fade_out_time)
     {
@@ -157,15 +158,15 @@ void MaxSpeed::SpeedIncrease::update(float dt)
     if(m_duration >0) return;
 
     // Now we are in the fade out period: decrease time linearly
-    m_current_speedup -= dt*m_max_add_speed/m_fade_out_time;
+    m_current_speedup -= ticks*m_max_add_speed/m_fade_out_time;
 }   // SpeedIncrease::update
 
 // ----------------------------------------------------------------------------
 void MaxSpeed::SpeedIncrease::saveState(BareNetworkString *buffer) const
 {
     buffer->addFloat(m_max_add_speed);
-    buffer->addFloat(m_duration);
-    buffer->addFloat(m_fade_out_time);
+    buffer->addUInt32(m_duration);
+    buffer->addUInt32(m_fade_out_time);
     buffer->addFloat(m_current_speedup);
     buffer->addFloat(m_engine_force);
 }   // saveState
@@ -177,8 +178,8 @@ void MaxSpeed::SpeedIncrease::rewindTo(BareNetworkString *buffer,
     if(is_active)
     {
         m_max_add_speed   = buffer->getFloat();
-        m_duration        = buffer->getFloat();
-        m_fade_out_time   = buffer->getFloat();
+        m_duration        = buffer->getUInt32();
+        m_fade_out_time   = buffer->getUInt32();
         m_current_speedup = buffer->getFloat();
         m_engine_force    = buffer->getFloat();
     }
@@ -198,7 +199,7 @@ void MaxSpeed::SpeedIncrease::rewindTo(BareNetworkString *buffer,
  *         value is changed to something else).
  */
 void MaxSpeed::setSlowdown(unsigned int category, float max_speed_fraction,
-                           float fade_in_time, float duration)
+                           int fade_in_time, int duration)
 {
     assert(category>=MS_DECREASE_MIN && category <MS_DECREASE_MAX);
     m_speed_decrease[category].m_max_speed_fraction = max_speed_fraction;
@@ -210,12 +211,12 @@ void MaxSpeed::setSlowdown(unsigned int category, float max_speed_fraction,
 /** Handles the speed increase for a certain category.
  *  \param dt Time step size.
  */
-void MaxSpeed::SpeedDecrease::update(float dt)
+void MaxSpeed::SpeedDecrease::update(int ticks)
 {
-    if(m_duration>-1.0f)
+    if(m_duration>-1)
     {
         // It's a timed slowdown
-        m_duration -= dt;
+        m_duration -= ticks;
         if(m_duration<0)
         {
             m_duration           = 0;
@@ -228,8 +229,9 @@ void MaxSpeed::SpeedDecrease::update(float dt)
     float diff = m_current_fraction - m_max_speed_fraction;
     if(diff > 0)
     {
-        if (diff * m_fade_in_time > dt)
-            m_current_fraction -= dt/m_fade_in_time;
+        float dt = stk_config->ticks2Time(ticks);
+        if (diff * m_fade_in_time > ticks)
+            m_current_fraction -= float(dt)/m_fade_in_time;
         else
             m_current_fraction = m_max_speed_fraction;
     }
@@ -245,9 +247,9 @@ void MaxSpeed::SpeedDecrease::update(float dt)
 void MaxSpeed::SpeedDecrease::saveState(BareNetworkString *buffer) const
 {
     buffer->addFloat(m_max_speed_fraction);
-    buffer->addFloat(m_fade_in_time);
+    buffer->addUInt32(m_fade_in_time);
     buffer->addFloat(m_current_fraction);
-    buffer->addFloat(m_duration);
+    buffer->addUInt32(m_duration);
 }   // saveState
 
 // ----------------------------------------------------------------------------
@@ -259,9 +261,9 @@ void MaxSpeed::SpeedDecrease::rewindTo(BareNetworkString *buffer,
     if(is_active)
     {
         m_max_speed_fraction = buffer->getFloat();
-        m_fade_in_time       = buffer->getFloat();
+        m_fade_in_time       = buffer->getUInt32();
         m_current_fraction   = buffer->getFloat();
-        m_duration           = buffer->getFloat();
+        m_duration           = buffer->getUInt32();
     }
     else   // make sure it is not active
     {
@@ -273,7 +275,7 @@ void MaxSpeed::SpeedDecrease::rewindTo(BareNetworkString *buffer,
 /** Returns how much increased speed time is left over in the given category.
  *  \param category Which category to report on.
  */
-float MaxSpeed::getSpeedIncreaseTimeLeft(unsigned int category)
+int MaxSpeed::getSpeedIncreaseTicksLeft(unsigned int category)
 {
     return m_speed_increase[category].getTimeLeft();
 }   // getSpeedIncreaseTimeLeft
@@ -285,7 +287,7 @@ float MaxSpeed::getSpeedIncreaseTimeLeft(unsigned int category)
  *  change to any of the speed increase/decrease objects will be done.
  *  \param dt Time step size (dt=0 only updates the current maximum speed).
  */
-void MaxSpeed::update(float dt)
+void MaxSpeed::update(int ticks)
 {
 
     // First compute the minimum max-speed fraction, which
@@ -295,7 +297,7 @@ void MaxSpeed::update(float dt)
     for(unsigned int i=MS_DECREASE_MIN; i<MS_DECREASE_MAX; i++)
     {
         SpeedDecrease &slowdown = m_speed_decrease[i];
-        slowdown.update(dt);
+        slowdown.update(ticks);
         slowdown_factor = std::min(slowdown_factor,
                                    slowdown.getSlowdownFraction());
     }
@@ -308,7 +310,7 @@ void MaxSpeed::update(float dt)
     for(unsigned int i=MS_INCREASE_MIN; i<MS_INCREASE_MAX; i++)
     {
         SpeedIncrease &speedup = m_speed_increase[i];
-        speedup.update(dt);
+        speedup.update(ticks);
         m_current_max_speed += speedup.getSpeedIncrease();
         m_add_engine_force  += speedup.getEngineForce();
     }
diff --git a/src/karts/max_speed.hpp b/src/karts/max_speed.hpp
index fb54fd137..1724359fb 100644
--- a/src/karts/max_speed.hpp
+++ b/src/karts/max_speed.hpp
@@ -71,9 +71,9 @@ private:
          *  to the duration will be decreased. When the duration is <0, the
          *  fade out time starts, and duration will go down to
          *  -m_fade_out_time before this speed increase stops. */
-        float m_duration;
+        int m_duration;
         /** The fadeout time. */
-        float m_fade_out_time;
+        int m_fade_out_time;
         /** The current max speed increase value. */
         float m_current_speedup;
         /** Additional engine force. */
@@ -96,7 +96,7 @@ private:
             m_engine_force    = 0;
         }   // reset
         // --------------------------------------------------------------------
-        void update(float dt);
+        void update(int ticks);
         void saveState(BareNetworkString *buffer) const;
         void rewindTo(BareNetworkString *buffer, bool is_active);
         // --------------------------------------------------------------------
@@ -107,7 +107,7 @@ private:
          *  Note that this function will return a negative value if
          *  the fade_out time has started or this speed increase has
          *  expired. */
-        float getTimeLeft() const      {return m_duration;       }
+        int getTimeLeft() const      {return m_duration;       }
         // --------------------------------------------------------------------
         /** Returns the additional engine force for this speed increase. */
         float getEngineForce() const
@@ -127,14 +127,14 @@ private:
         /** The maximum slowdown to apply. */
         float m_max_speed_fraction;
         /** How long it should take for the full slowdown to take effect. */
-        float m_fade_in_time;
+        int m_fade_in_time;
         /** The current slowdown fraction, taking the fade-in time
          *  into account. */
         float m_current_fraction;
 
         /** How long the effect should last. A -1.0f as value indicates
          *  that this effect stays active till it is changed back. */
-        float m_duration;
+        int m_duration;
 
         /** The constructor initialises the data with data that won't
          *  affect top speed at all. */
@@ -147,12 +147,12 @@ private:
         void reset()
         {
             m_max_speed_fraction = 1.0f;
-            m_fade_in_time       = 0.0f;
             m_current_fraction   = 1.0f;
-            m_duration           = 0.0f;
+            m_fade_in_time       = 0;
+            m_duration           = 0;
         }   //reset
         // --------------------------------------------------------------------
-        void update(float dt);
+        void update(int ticks);
         void saveState(BareNetworkString *buffer) const;
         void rewindTo(BareNetworkString *buffer, bool is_active);
         // --------------------------------------------------------------------
@@ -179,16 +179,16 @@ public:
           MaxSpeed(AbstractKart *kart);
 
     void  increaseMaxSpeed(unsigned int category, float add_speed,
-                           float engine_force, float duration,
-                           float fade_out_time);
+                           float engine_force, int duration,
+                           int fade_out_time);
     void  instantSpeedIncrease(unsigned int category,
                                float add_speed, float speed_boost,
-                               float engine_force, float duration,
-                               float fade_out_time/*=1.0f*/);
+                               float engine_force, int duration,
+                               int fade_out_time);
     void  setSlowdown(unsigned int category, float max_speed_fraction,
-                      float fade_in_time, float duration=-1.0f);
-    float getSpeedIncreaseTimeLeft(unsigned int category);
-    void  update(float dt);
+                      int fade_in_time, int duration=-1);
+    int   getSpeedIncreaseTicksLeft(unsigned int category);
+    void  update(int ticks);
     void  reset();
     void  saveState(BareNetworkString *buffer) const;
     void  rewindTo(BareNetworkString *buffer);
diff --git a/src/karts/moveable.cpp b/src/karts/moveable.cpp
index 46d233fe4..dde568126 100644
--- a/src/karts/moveable.cpp
+++ b/src/karts/moveable.cpp
@@ -88,7 +88,7 @@ void Moveable::addError(const Vec3& pos_error,
  *  \param offset_xyz Offset to be added to the position.
  *  \param rotation Additional rotation.
  */
-void Moveable::updateGraphics(float dt, const Vec3& offset_xyz,
+void Moveable::updateGraphics(int ticks, const Vec3& offset_xyz,
                               const btQuaternion& rotation)
 {
     // If this is a client, don't smooth error during rewinds
@@ -165,16 +165,16 @@ void Moveable::stopFlying()
 //-----------------------------------------------------------------------------
 /** Updates the current position and rotation from the corresponding physics
  *  body, and then calls updateGraphics to position the model correctly.
- *  \param float dt Time step size.
+ *  \param ticks Number of physics time steps - should be 1.
  */
-void Moveable::update(float dt)
+void Moveable::update(int ticks)
 {
     if(m_body->getInvMass()!=0)
         m_motion_state->getWorldTransform(m_transform);
     m_velocityLC = getVelocity()*m_transform.getBasis();
     updatePosition();
 
-    updateGraphics(dt, Vec3(0,0,0), btQuaternion(0, 0, 0, 1));
+    updateGraphics(ticks, Vec3(0,0,0), btQuaternion(0, 0, 0, 1));
 }   // update
 
 //-----------------------------------------------------------------------------
diff --git a/src/karts/moveable.hpp b/src/karts/moveable.hpp
index 40946c87f..435c968b5 100644
--- a/src/karts/moveable.hpp
+++ b/src/karts/moveable.hpp
@@ -116,10 +116,10 @@ public:
             m_motion_state->setWorldTransform(m_transform);
     }   // setRotation(btQuaternion)
     // ------------------------------------------------------------------------
-    virtual void  updateGraphics(float dt, const Vec3& off_xyz,
+    virtual void  updateGraphics(int ticks, const Vec3& off_xyz,
                                  const btQuaternion& off_rotation);
     virtual void  reset();
-    virtual void  update(float dt) ;
+    virtual void  update(int ticks) ;
     btRigidBody  *getBody() const {return m_body; }
     void          createBody(float mass, btTransform& trans,
                              btCollisionShape *shape,
diff --git a/src/karts/skidding.cpp b/src/karts/skidding.cpp
index ceb0d2d79..4da216399 100644
--- a/src/karts/skidding.cpp
+++ b/src/karts/skidding.cpp
@@ -225,15 +225,17 @@ float Skidding::getSteeringWhenSkidding(float steering) const
 
  // ----------------------------------------------------------------------------
 /** Updates skidding status.
- *  \param dt Time step size.
+ *  \param ticks Number of physics time steps - should be 1.
  *  \param is_on_ground True if the kart is on ground.
  *  \param steering Raw steering of the kart [-1,1], i.e. not adjusted by
  *               the kart's max steering angle.
  *  \param skidding  True if the skid button is pressed.
  */
-void Skidding::update(float dt, bool is_on_ground,
+void Skidding::update(int ticks, bool is_on_ground,
                       float steering, KartControl::SkidControl skidding)
 {
+    float dt = stk_config->ticks2Time(ticks);
+
     const KartProperties *kp = m_kart->getKartProperties();
 
     // If a kart animation is shown, stop all skidding bonuses.
@@ -440,9 +442,10 @@ void Skidding::update(float dt, bool is_on_ground,
                           ->setCreationRateRelative(KartGFX::KGFX_SKIDR, 1.0f);
                     m_kart->m_max_speed->
                         instantSpeedIncrease(MaxSpeed::MS_INCREASE_SKIDDING,
-                                             bonus_speed, bonus_speed,
-                                             bonus_force, bonus_time,
-                                             /*fade-out-time*/ 1.0f);
+                               bonus_speed, bonus_speed,
+                               bonus_force,
+                               stk_config->time2Ticks(bonus_time),
+                               /*fade-out-time*/ stk_config->time2Ticks(1.0f));
                     
                     if (m_kart->getController()->canGetAchievements())
                     {
diff --git a/src/karts/skidding.hpp b/src/karts/skidding.hpp
index 4d50b05f4..1e37cf68b 100644
--- a/src/karts/skidding.hpp
+++ b/src/karts/skidding.hpp
@@ -104,7 +104,7 @@ public:
          Skidding(Kart *kart);
         ~Skidding();
     void reset();
-    void update(float dt, bool is_on_ground, float steer,
+    void update(int dt, bool is_on_ground, float steer,
                 KartControl::SkidControl skidding);
     void saveState(BareNetworkString *buffer);
     void rewindTo(BareNetworkString *buffer);
diff --git a/src/main_loop.cpp b/src/main_loop.cpp
index 056c28669..7bedf80fe 100644
--- a/src/main_loop.cpp
+++ b/src/main_loop.cpp
@@ -169,25 +169,25 @@ float MainLoop::getLimitedDt()
     // to findout which events to replay
     if (World::getWorld() && history->replayHistory() )
     {
-        dt = history->updateReplayAndGetDT(World::getWorld()->getTime(), dt);
+        history->updateReplay(World::getWorld()->getTime(), dt);
     }
     return dt;
 }   // getLimitedDt
 
 //-----------------------------------------------------------------------------
 /** Updates all race related objects.
- *  \param dt Time step size.
+ *  \param ticks Number of ticks (physics steps) to simulate - should be 1.
  */
-void MainLoop::updateRace(float dt)
+void MainLoop::updateRace(int ticks)
 {
     if (!World::getWorld())  return;   // No race on atm - i.e. we are in menu
 
     // The race event manager will update world in case of an online race
     if ( RaceEventManager::getInstance() && 
          RaceEventManager::getInstance()->isRunning() )
-        RaceEventManager::getInstance()->update(dt);
+        RaceEventManager::getInstance()->update(ticks);
     else
-        World::getWorld()->updateWorld(dt);
+        World::getWorld()->updateWorld(ticks);
 }   // updateRace
 
 //-----------------------------------------------------------------------------
@@ -356,7 +356,7 @@ void MainLoop::run()
             m_is_last_substep = (i == num_steps - 1);
 
             PROFILER_PUSH_CPU_MARKER("Update race", 0, 255, 255);
-            if (World::getWorld()) updateRace(dt);
+            if (World::getWorld()) updateRace(1);
             PROFILER_POP_CPU_MARKER();
 
             // We need to check again because update_race may have requested
@@ -368,11 +368,11 @@ void MainLoop::run()
                                      0x7F, 0x00, 0x7F);
             if (auto pm = ProtocolManager::lock())
             {
-                pm->update(dt);
+                pm->update(1);
             }
             PROFILER_POP_CPU_MARKER();
 
-            if (World::getWorld()) World::getWorld()->updateTime(dt);
+            if (World::getWorld()) World::getWorld()->updateTime(1);
         }   // for i < num_steps
 
         m_is_last_substep = false;
diff --git a/src/main_loop.hpp b/src/main_loop.hpp
index 766a47c7b..2ab681476 100644
--- a/src/main_loop.hpp
+++ b/src/main_loop.hpp
@@ -41,7 +41,7 @@ private:
     Uint32   m_curr_time;
     Uint32   m_prev_time;
     float    getLimitedDt();
-    void     updateRace(float dt);
+    void     updateRace(int ticks);
 public:
          MainLoop();
         ~MainLoop();
diff --git a/src/modes/cutscene_world.cpp b/src/modes/cutscene_world.cpp
index d850a9cf2..068791236 100644
--- a/src/modes/cutscene_world.cpp
+++ b/src/modes/cutscene_world.cpp
@@ -181,9 +181,9 @@ const std::string& CutsceneWorld::getIdent() const
 
 //-----------------------------------------------------------------------------
 /** Update the world and the track.
- *  \param dt Time step size.
+ *  \param ticks Number of physics time steps - should be 1.
  */
-void CutsceneWorld::update(float dt)
+void CutsceneWorld::update(int ticks)
 {
     /*
     {
@@ -234,7 +234,7 @@ void CutsceneWorld::update(float dt)
         double prev_time = m_time;
         double now = StkTime::getRealTime();
         m_time = now - m_time_at_second_reset;
-        dt = (float)(m_time - prev_time);
+        ticks = stk_config->time2Ticks(float(m_time - prev_time));
     }
 
     float fade = 0.0f;
@@ -288,8 +288,8 @@ void CutsceneWorld::update(float dt)
     }
 
 
-    World::update((float)dt);
-    World::updateTrack((float)dt);
+    World::update(ticks);
+    World::updateTrack(ticks);
 
     PtrVector<TrackObject>& objects = Track::getCurrentTrack()
                                     ->getTrackObjectManager()->getObjects();
diff --git a/src/modes/cutscene_world.hpp b/src/modes/cutscene_world.hpp
index e85da3ad2..5b8fd84bc 100644
--- a/src/modes/cutscene_world.hpp
+++ b/src/modes/cutscene_world.hpp
@@ -70,7 +70,7 @@ public:
 
     virtual const std::string& getIdent() const OVERRIDE;
 
-    virtual void update(float dt) OVERRIDE;
+    virtual void update(int ticks) OVERRIDE;
 
     virtual void createRaceGUI() OVERRIDE;
 
diff --git a/src/modes/demo_world.hpp b/src/modes/demo_world.hpp
index bce6940be..bd9cafb80 100644
--- a/src/modes/demo_world.hpp
+++ b/src/modes/demo_world.hpp
@@ -53,20 +53,25 @@ private:
 public:
                           DemoWorld();
     virtual              ~DemoWorld();
-    /** Returns identifier for this world. */
-    virtual  std::string getInternalCode() const OVERRIDE { return "DEMO"; }
-    virtual  void        update(float dt) OVERRIDE {ProfileWorld::update(dt);};
     virtual  bool        isRaceOver() OVERRIDE;
     virtual  void        enterRaceOverState() OVERRIDE;
     // ------------------------------------------------------------------------
-    static   bool        updateIdleTimeAndStartDemo(float dt);
+    /** Returns identifier for this world. */
+    virtual  std::string getInternalCode() const OVERRIDE { return "DEMO"; }
+    // ------------------------------------------------------------------------
+    virtual void update(int ticks) OVERRIDE { ProfileWorld::update(ticks); }
+    // ------------------------------------------------------------------------
+    static bool updateIdleTimeAndStartDemo(float dt);
     // ------------------------------------------------------------------------
     /** Sets the number of laps to use in demo mode. m_num_laps is from
      *  ProfileWorld. */
     static void setNumLaps(unsigned int num_laps) { m_num_laps = num_laps; }
     // ------------------------------------------------------------------------
     /** Sets the number of karts to use in demo mode. */
-    static void setNumKarts(unsigned int num_karts) { m_default_num_karts = num_karts;}
+    static void setNumKarts(unsigned int num_karts)
+    {
+        m_default_num_karts = num_karts;
+    }   // setNumKarts
     // ------------------------------------------------------------------------
     static void setTracks(const std::vector<std::string> &tracks);
     // ------------------------------------------------------------------------
diff --git a/src/modes/easter_egg_hunt.cpp b/src/modes/easter_egg_hunt.cpp
index b449ba936..2f9935d28 100644
--- a/src/modes/easter_egg_hunt.cpp
+++ b/src/modes/easter_egg_hunt.cpp
@@ -156,12 +156,12 @@ void EasterEggHunt::collectedEasterEgg(const AbstractKart *kart)
 
 //-----------------------------------------------------------------------------
 /** Update the world and the track.
- *  \param dt Time step size.
+ *  \param ticks Physics time step size - should be 1.
  */
-void EasterEggHunt::update(float dt)
+void EasterEggHunt::update(int ticks)
 {
-    LinearWorld::update(dt);
-    LinearWorld::updateTrack(dt);
+    LinearWorld::update(ticks);
+    LinearWorld::updateTrack(ticks);
 }   // update
 
 //-----------------------------------------------------------------------------
@@ -209,7 +209,7 @@ void EasterEggHunt::getKartsDisplayInfo(
  *  direction messages in the easter egg mode since there is no direction there.
  *  \param i Kart id.
  */
-void EasterEggHunt::checkForWrongDirection(unsigned int i, float dt)
+void EasterEggHunt::checkForWrongDirection(unsigned int i, int ticks)
 {
 }   // checkForWrongDirection
 
diff --git a/src/modes/easter_egg_hunt.hpp b/src/modes/easter_egg_hunt.hpp
index 83dde6dbc..9b095b7ca 100644
--- a/src/modes/easter_egg_hunt.hpp
+++ b/src/modes/easter_egg_hunt.hpp
@@ -57,7 +57,7 @@ public:
 
     virtual const std::string& getIdent() const OVERRIDE;
     virtual void terminateRace() OVERRIDE;
-    virtual void update(float dt) OVERRIDE;
+    virtual void update(int ticks) OVERRIDE;
     virtual void getKartsDisplayInfo(
                           std::vector<RaceGUIBase::KartIconDisplayInfo> *info) OVERRIDE;
 
@@ -65,7 +65,7 @@ public:
     void collectedEasterEgg(const AbstractKart *kart);
     void readData(const std::string &filename);
 
-    virtual void checkForWrongDirection(unsigned int i, float dt) OVERRIDE;
+    virtual void checkForWrongDirection(unsigned int i, int ticks) OVERRIDE;
     virtual float estimateFinishTimeForKart(AbstractKart* kart) OVERRIDE;
 
 };   // EasterEggHunt
diff --git a/src/modes/linear_world.cpp b/src/modes/linear_world.cpp
index be8aaf176..3ad5981b3 100644
--- a/src/modes/linear_world.cpp
+++ b/src/modes/linear_world.cpp
@@ -150,13 +150,13 @@ void LinearWorld::reset()
 //-----------------------------------------------------------------------------
 /** General update function called once per frame. This updates the kart
  *  sectors, which are then used to determine the kart positions.
- *  \param dt Time step size.
+ *  \param ticks Number of physics time steps - should be 1.
  */
-void LinearWorld::update(float dt)
+void LinearWorld::update(int ticks)
 {
     // run generic parent stuff that applies to all modes. It
     // especially updates the kart positions.
-    WorldWithRank::update(dt);
+    WorldWithRank::update(ticks);
 
     if (m_last_lap_sfx_playing &&
         m_last_lap_sfx->getStatus() != SFXBase::SFX_PLAYING)
@@ -197,7 +197,7 @@ void LinearWorld::update(float dt)
     // updated their position and laps etc, otherwise inconsistencies
     // (like two karts at same position) can occur.
     // ---------------------------------------------------------------
-    WorldWithRank::updateTrack(dt);
+    WorldWithRank::updateTrack(ticks);
     updateRacePosition();
 
     for (unsigned int i=0; i<kart_amount; i++)
@@ -213,7 +213,7 @@ void LinearWorld::update(float dt)
             m_kart_info[i].m_estimated_finish =
                 estimateFinishTimeForKart(m_karts[i]);
         }
-        checkForWrongDirection(i, dt);
+        checkForWrongDirection(i, ticks);
     }
 
 #ifdef DEBUG
@@ -842,12 +842,12 @@ void LinearWorld::updateRacePosition()
  *  player karts to display a message to the player.
  *  \param i Kart id.
  */
-void LinearWorld::checkForWrongDirection(unsigned int i, float dt)
+void LinearWorld::checkForWrongDirection(unsigned int i, int ticks)
 {
     if (!m_karts[i]->getController()->isLocalPlayerController()) 
         return;
 
-    float wrongway_counter = m_karts[i]->getWrongwayCounter();
+    int wrongway_counter = m_karts[i]->getWrongwayCounter();
     
     const AbstractKart *kart=m_karts[i];
     // If the kart can go in more than one directions from the current track
@@ -875,14 +875,14 @@ void LinearWorld::checkForWrongDirection(unsigned int i, float dt)
         kart->getVelocityLC().getY() > 0.0f &&
         !kart->hasFinishedRace())
     {
-        wrongway_counter += dt;
+        wrongway_counter += ticks;
         
-        if (wrongway_counter > 2.0f)
-            wrongway_counter = 2.0f;
+        if (wrongway_counter > stk_config->time2Ticks(2.0f))
+            wrongway_counter = stk_config->time2Ticks(2.0f);
     }
     else
     {
-        wrongway_counter -= dt;
+        wrongway_counter -= ticks;
 
         if (wrongway_counter < 0)
             wrongway_counter = 0;
@@ -891,7 +891,7 @@ void LinearWorld::checkForWrongDirection(unsigned int i, float dt)
     if (kart->getKartAnimation())
         wrongway_counter = 0;
     
-    if (wrongway_counter > 1.0f)
+    if (wrongway_counter > stk_config->time2Ticks(1.0f))
     {
         m_race_gui->addMessage(_("WRONG WAY!"), kart,
                                /* time */ -1.0f,
diff --git a/src/modes/linear_world.hpp b/src/modes/linear_world.hpp
index 7b3e4e987..eac46cf18 100644
--- a/src/modes/linear_world.hpp
+++ b/src/modes/linear_world.hpp
@@ -101,7 +101,7 @@ protected:
       */
     AlignedArray<KartInfo> m_kart_info;
 
-    virtual void  checkForWrongDirection(unsigned int i, float dt);
+    virtual void  checkForWrongDirection(unsigned int i, int ticks);
     void          updateRacePosition();
     virtual float estimateFinishTimeForKart(AbstractKart* kart) OVERRIDE;
 
@@ -113,7 +113,7 @@ public:
     virtual void  init() OVERRIDE;
     virtual      ~LinearWorld();
 
-    virtual void  update(float delta) OVERRIDE;
+    virtual void  update(int ticks) OVERRIDE;
     float         getDistanceDownTrackForKart(const int kart_id) const;
     float         getDistanceToCenterForKart(const int kart_id) const;
     float         getEstimatedFinishTime(const int kart_id) const;
diff --git a/src/modes/overworld.cpp b/src/modes/overworld.cpp
index 4ba075674..130549185 100644
--- a/src/modes/overworld.cpp
+++ b/src/modes/overworld.cpp
@@ -101,9 +101,9 @@ void OverWorld::enterOverWorld()
 
 //-----------------------------------------------------------------------------
 /** General update function called once per frame.
- *  \param dt Time step size.
+ *  \param ticks Number of physics time steps - should be 1.
  */
-void OverWorld::update(float dt)
+void OverWorld::update(int ticks)
 {
     // Skip annoying waiting without a purpose
     // Make sure to do all things that would normally happen in the
@@ -119,8 +119,8 @@ void OverWorld::update(float dt)
             music_manager->startMusic();
         m_karts[0]->startEngineSFX();
     }
-    World::update(dt);
-    World::updateTrack(dt);
+    World::update(ticks);
+    World::updateTrack(ticks);
     const unsigned int kart_amount  = (unsigned int)m_karts.size();
 
     // isn't it cool, on the overworld nitro is free!
diff --git a/src/modes/overworld.hpp b/src/modes/overworld.hpp
index 1835411fd..fc5370ab4 100644
--- a/src/modes/overworld.hpp
+++ b/src/modes/overworld.hpp
@@ -46,7 +46,7 @@ public:
 
     static void enterOverWorld();
 
-    virtual void  update(float delta) OVERRIDE;
+    virtual void  update(int ticks) OVERRIDE;
     unsigned int  getRescuePositionIndex(AbstractKart *kart) OVERRIDE;
     virtual void  getKartsDisplayInfo(
                  std::vector<RaceGUIBase::KartIconDisplayInfo> *info) OVERRIDE;
diff --git a/src/modes/profile_world.cpp b/src/modes/profile_world.cpp
index 3165e4e13..0b421f2d1 100644
--- a/src/modes/profile_world.cpp
+++ b/src/modes/profile_world.cpp
@@ -149,10 +149,11 @@ bool ProfileWorld::isRaceOver()
 
 //-----------------------------------------------------------------------------
 /** Counts the number of frames.
+ *  \param ticks number of physics time steps - should be 1.
  */
-void ProfileWorld::update(float dt)
+void ProfileWorld::update(int ticks)
 {
-    StandardRace::update(dt);
+    StandardRace::update(ticks);
 
     m_frame_count++;
     video::IVideoDriver *driver = irr_driver->getVideoDriver();
diff --git a/src/modes/profile_world.hpp b/src/modes/profile_world.hpp
index 014ab392c..c4c1e0e00 100644
--- a/src/modes/profile_world.hpp
+++ b/src/modes/profile_world.hpp
@@ -82,7 +82,7 @@ public:
     virtual              ~ProfileWorld();
     /** Returns identifier for this world. */
     virtual  std::string getInternalCode() const {return "PROFILE"; }
-    virtual  void        update(float dt);
+    virtual  void        update(int ticks);
     virtual  bool        isRaceOver();
     virtual  void        enterRaceOverState();
 
diff --git a/src/modes/soccer_world.cpp b/src/modes/soccer_world.cpp
index 3a418a2ed..53537153b 100644
--- a/src/modes/soccer_world.cpp
+++ b/src/modes/soccer_world.cpp
@@ -84,12 +84,12 @@ void SoccerWorld::init()
     m_kart_position_map.clear();
     WorldWithRank::init();
     m_display_rank = false;
-    m_goal_timer = 0.0f;
-    m_ball_hitter = -1;
-    m_ball = NULL;
-    m_ball_body = NULL;
-    m_goal_target = race_manager->getMaxGoal();
-    m_goal_sound = SFXManager::get()->createSoundSource("goal_scored");
+    m_goal_timer   = 0;
+    m_ball_hitter  = -1;
+    m_ball         = NULL;
+    m_ball_body    = NULL;
+    m_goal_target  = race_manager->getMaxGoal();
+    m_goal_sound   = SFXManager::get()->createSoundSource("goal_scored");
 
     Track *track = Track::getCurrentTrack();
     if (track->hasNavMesh())
@@ -143,7 +143,7 @@ void SoccerWorld::reset()
     m_red_kdm.clear();
     m_blue_kdm.clear();
     m_ball_heading = 0.0f;
-    m_ball_invalid_timer = 0.0f;
+    m_ball_invalid_timer = 0;
 
     if (m_goal_sound != NULL &&
         m_goal_sound->getStatus() == SFXBase::SFX_PLAYING)
@@ -177,34 +177,34 @@ const std::string& SoccerWorld::getIdent() const
 
 //-----------------------------------------------------------------------------
 /** Update the world and the track.
- *  \param dt Time step size.
+ *  \param ticks Physics time steps - should be 1.
  */
-void SoccerWorld::update(float dt)
+void SoccerWorld::update(int ticks)
 {
-    updateBallPosition(dt);
+    updateBallPosition(ticks);
     if (Track::getCurrentTrack()->hasNavMesh())
     {
         updateSectorForKarts();
         updateAIData();
     }
 
-    WorldWithRank::update(dt);
-    WorldWithRank::updateTrack(dt);
+    WorldWithRank::update(ticks);
+    WorldWithRank::updateTrack(ticks);
 
     if (getPhase() == World::GOAL_PHASE)
     {
-        if (m_goal_timer == 0.0f)
+        if (m_goal_timer == 0)
         {
             // Stop all karts
             for (unsigned int i = 0; i < m_karts.size(); i++)
                 m_karts[i]->setVelocity(btVector3(0, 0, 0));
         }
-        m_goal_timer += dt;
+        m_goal_timer += ticks;
 
-        if (m_goal_timer > 3.0f)
+        if (m_goal_timer > stk_config->time2Ticks(3.0f))
         {
             setPhase(WorldStatus::RACE_PHASE);
-            m_goal_timer = 0.0f;
+            m_goal_timer = 0;
             if (!isRaceOver())
             {
                 // Reset all karts
@@ -448,7 +448,7 @@ AbstractKart *SoccerWorld::createKart(const std::string &kart_ident, int index,
 //-----------------------------------------------------------------------------
 /** Localize the ball on the navigation mesh.
  */
-void SoccerWorld::updateBallPosition(float dt)
+void SoccerWorld::updateBallPosition(int ticks)
 {
     if (isRaceOver()) return;
 
@@ -465,11 +465,11 @@ void SoccerWorld::updateBallPosition(float dt)
             ->update(getBallPosition(), true/*ignore_vertical*/);
         if (!m_ball_track_sector->isOnRoad() && getPhase() == RACE_PHASE)
         {
-            m_ball_invalid_timer += dt;
+            m_ball_invalid_timer += ticks;
             // Reset the ball and karts if out of navmesh after 2 seconds
-            if (m_ball_invalid_timer >= 2.0f)
+            if (m_ball_invalid_timer >= stk_config->time2Ticks(2.0f))
             {
-                m_ball_invalid_timer = 0.0f;
+                m_ball_invalid_timer = 0;
                 m_ball->reset();
                 for (unsigned int i = 0; i < m_karts.size(); i++)
                     moveKartAfterRescue(m_karts[i]);
@@ -478,7 +478,7 @@ void SoccerWorld::updateBallPosition(float dt)
             }
         }
         else
-            m_ball_invalid_timer = 0.0f;
+            m_ball_invalid_timer = 0;
     }
 
 }   // updateBallPosition
diff --git a/src/modes/soccer_world.hpp b/src/modes/soccer_world.hpp
index 495f9f6e1..ac31d03b1 100644
--- a/src/modes/soccer_world.hpp
+++ b/src/modes/soccer_world.hpp
@@ -266,8 +266,11 @@ private:
     SFXBase *m_goal_sound;
 
     /** Timer for displaying goal text*/
-    float m_goal_timer;
-    float m_ball_invalid_timer;
+    int m_goal_timer;
+
+    /** Counts ticks when the ball is off track, so a reset can be
+     *  triggered if the ball is off for more than 2 seconds. */
+    int m_ball_invalid_timer;
     int m_ball_hitter;
 
     /** Goals data of each team scored */
@@ -290,7 +293,7 @@ private:
     /** Set the team for the karts */
     void initKartList();
     /** Function to update the location the ball on the polygon map */
-    void updateBallPosition(float dt);
+    void updateBallPosition(int ticks);
     /** Function to update data for AI usage. */
     void updateAIData();
     /** Get number of teammates in a team, used by starting position assign. */
@@ -326,7 +329,7 @@ public:
 
     virtual const std::string& getIdent() const OVERRIDE;
 
-    virtual void update(float dt) OVERRIDE;
+    virtual void update(int ticks) OVERRIDE;
     // ------------------------------------------------------------------------
     void onCheckGoalTriggered(bool first_goal);
     // ------------------------------------------------------------------------
diff --git a/src/modes/three_strikes_battle.cpp b/src/modes/three_strikes_battle.cpp
index 0402727ee..b21d504f8 100644
--- a/src/modes/three_strikes_battle.cpp
+++ b/src/modes/three_strikes_battle.cpp
@@ -95,11 +95,12 @@ void ThreeStrikesBattle::reset()
 {
     WorldWithRank::reset();
 
-    m_next_sta_spawn_time =
+    float next_spawn_time =
         race_manager->getDifficulty() == RaceManager::DIFFICULTY_BEST ? 40.0f :
         race_manager->getDifficulty() == RaceManager::DIFFICULTY_HARD ? 30.0f :
         race_manager->getDifficulty() == RaceManager::DIFFICULTY_MEDIUM ?
         25.0f : 20.0f;
+    m_next_sta_spawn_ticks = stk_config->time2Ticks(next_spawn_time);
 
     const unsigned int kart_amount = (unsigned int)m_karts.size();
     for(unsigned int n=0; n<kart_amount; n++)
@@ -349,12 +350,12 @@ const std::string& ThreeStrikesBattle::getIdent() const
 
 //-----------------------------------------------------------------------------
 /** Update the world and the track.
- *  \param dt Time step size.
+ *  \param ticks Number of physics time step - should be 1.
  */
-void ThreeStrikesBattle::update(float dt)
+void ThreeStrikesBattle::update(int ticks)
 {
-    WorldWithRank::update(dt);
-    WorldWithRank::updateTrack(dt);
+    WorldWithRank::update(ticks);
+    WorldWithRank::updateTrack(ticks);
 
     spawnSpareTireKarts();
     if (Track::getCurrentTrack()->hasNavMesh())
@@ -625,7 +626,7 @@ void ThreeStrikesBattle::addKartLife(unsigned int id)
 void ThreeStrikesBattle::spawnSpareTireKarts()
 {
     if (m_spare_tire_karts.empty() ||
-        getTicksSinceStart() < m_next_sta_spawn_time)
+        getTicksSinceStart() < m_next_sta_spawn_ticks)
         return;
 
     // The lifespan for sta: inc_factor / period * 1000 / 2
@@ -639,10 +640,11 @@ void ThreeStrikesBattle::spawnSpareTireKarts()
     default:                           inc_factor = 0.55f; lifespan = 27.5f;  break;
     }
 
+    int lifespan_ticks = stk_config->time2Ticks(lifespan);
     // Spawn spare tire kart when necessary
-    m_next_sta_spawn_time = stk_config->time2Ticks(lifespan) 
-                          + getTicksSinceStart() * inc_factor
-                          + getTicksSinceStart();
+    m_next_sta_spawn_ticks = int( lifespan_ticks
+                                + getTicksSinceStart() * inc_factor
+                                + getTicksSinceStart()             );
     int kart_has_few_lives = 0;
     for (unsigned int i = 0; i < m_kart_info.size(); i++)
     {
@@ -663,7 +665,7 @@ void ThreeStrikesBattle::spawnSpareTireKarts()
         SpareTireAI* sta = dynamic_cast<SpareTireAI*>
             (m_spare_tire_karts[i]->getController());
         assert(sta);
-        sta->spawn(lifespan);
+        sta->spawn(lifespan_ticks);
     }
 }   // spawnSpareTireKarts
 
diff --git a/src/modes/three_strikes_battle.hpp b/src/modes/three_strikes_battle.hpp
index 184b9dc73..f6d9c0149 100644
--- a/src/modes/three_strikes_battle.hpp
+++ b/src/modes/three_strikes_battle.hpp
@@ -78,7 +78,7 @@ private:
     int m_total_hit;
 
     std::vector<AbstractKart*> m_spare_tire_karts;
-    float m_next_sta_spawn_time;
+    int m_next_sta_spawn_ticks;
 
 public:
     /** Used to show a nice graph when battle is over */
@@ -113,7 +113,7 @@ public:
     // ------------------------------------------------------------------------
     virtual void kartHit(const unsigned int kart_id) OVERRIDE;
     // ------------------------------------------------------------------------
-    virtual void update(float dt) OVERRIDE;
+    virtual void update(int ticks) OVERRIDE;
     // ------------------------------------------------------------------------
     virtual void kartAdded(AbstractKart* kart, scene::ISceneNode* node)
                                                                       OVERRIDE;
diff --git a/src/modes/world.cpp b/src/modes/world.cpp
index 3713084a6..f5a484e03 100644
--- a/src/modes/world.cpp
+++ b/src/modes/world.cpp
@@ -740,7 +740,8 @@ void World::resetAllKarts()
             (*i)->getMaterial() && (*i)->getMaterial()->hasGravity() ?
             (*i)->getNormal() * -g : Vec3(0, -g, 0));
     }
-    for(int i=0; i<60; i++) Physics::getInstance()->update(1.f/60.f);
+    for(int i=0; i<stk_config->getPhysicsFPS(); i++) 
+        Physics::getInstance()->update(1);
 
     for ( KartList::iterator i=m_karts.begin(); i!=m_karts.end(); i++)
     {
@@ -834,9 +835,9 @@ void World::scheduleUnpause()
  *  call World::update() first, to get updated kart positions. If race
  *  over would be handled in World::update, LinearWorld had no opportunity
  *  to update its data structures before the race is finished).
- *  \param dt Time step size.
+ *  \param ticks Number of physics time steps - should be 1.
  */
-void World::updateWorld(float dt)
+void World::updateWorld(int ticks)
 {
 #ifdef DEBUG
     assert(m_magic_number == 0xB01D6543);
@@ -863,12 +864,12 @@ void World::updateWorld(float dt)
         ! (NetworkConfig::get()->isClient() &&
            RewindManager::get()->isRewinding() )    )
     {
-        history->updateSaving(dt);   // updating the saved state
+        history->updateSaving(ticks);   // updating the saved state
     }
 
     try
     {
-        update(dt);
+        update(ticks);
     }
     catch (AbortWorldUpdateException& e)
     {
@@ -959,9 +960,9 @@ void World::scheduleTutorial()
 
 //-----------------------------------------------------------------------------
 /** Updates the physics, all karts, the track, and projectile manager.
- *  \param dt Time step size.
+ *  \param ticks Number of physics time steps - should be 1.
  */
-void World::update(float dt)
+void World::update(int ticks)
 {
 #ifdef DEBUG
     assert(m_magic_number == 0xB01D6543);
@@ -970,20 +971,20 @@ void World::update(float dt)
     PROFILER_PUSH_CPU_MARKER("World::update()", 0x00, 0x7F, 0x00);
 
 #if MEASURE_FPS
-    static float time = 0.0f;
-    time += dt;
-    if (time > 5.0f)
+    static int time = 0.0f;
+    time += ticks;
+    if (time > stk_config->time2Ticks(5.0f))
     {
-        time -= 5.0f;
+        time -= stk_config->time2Ticks(5.0f);
         printf("%i\n",irr_driver->getVideoDriver()->getFPS());
     }
 #endif
 
     PROFILER_PUSH_CPU_MARKER("World::update (sub-updates)", 0x20, 0x7F, 0x00);
-    WorldStatus::update(dt);
+    WorldStatus::update(ticks);
     PROFILER_POP_CPU_MARKER();
     PROFILER_PUSH_CPU_MARKER("World::update (RewindManager)", 0x20, 0x7F, 0x40);
-    RewindManager::get()->update(dt);
+    RewindManager::get()->update(ticks);
     PROFILER_POP_CPU_MARKER();
 
     PROFILER_PUSH_CPU_MARKER("World::update (Kart::upate)", 0x40, 0x7F, 0x00);
@@ -998,7 +999,7 @@ void World::update(float dt)
             dynamic_cast<SpareTireAI*>(m_karts[i]->getController());
         // Update all karts that are not eliminated
         if(!m_karts[i]->isEliminated() || (sta && sta->isMoving()))
-            m_karts[i]->update(dt);
+            m_karts[i]->update(ticks);
     }
     PROFILER_POP_CPU_MARKER();
 
@@ -1009,29 +1010,29 @@ void World::update(float dt)
 
         for (unsigned int i = 0; i < Camera::getNumCameras(); i++)
         {
-            Camera::getCamera(i)->update(dt);
+            Camera::getCamera(i)->update(stk_config->ticks2Time(ticks));
         }
         PROFILER_POP_CPU_MARKER();
     }   // if !rewind
 
-    if(race_manager->isRecordingRace()) ReplayRecorder::get()->update(dt);
+    if(race_manager->isRecordingRace()) ReplayRecorder::get()->update(ticks);
     Scripting::ScriptEngine *script_engine = Scripting::ScriptEngine::getInstance();
-    if (script_engine) script_engine->update(dt);
+    if (script_engine) script_engine->update(ticks);
 
     if (!history->dontDoPhysics())
     {
-        Physics::getInstance()->update(dt);
+        Physics::getInstance()->update(ticks);
     }
 
     PROFILER_PUSH_CPU_MARKER("World::update (weather)", 0x80, 0x7F, 0x00);
     if (UserConfigParams::m_particles_effects > 1 && Weather::getInstance())
     {
-        Weather::getInstance()->update(dt);
+        Weather::getInstance()->update(ticks);
     }
     PROFILER_POP_CPU_MARKER();
 
     PROFILER_PUSH_CPU_MARKER("World::update (projectiles)", 0xa0, 0x7F, 0x00);
-    projectile_manager->update(dt);
+    projectile_manager->update(ticks);
     PROFILER_POP_CPU_MARKER();
 
     PROFILER_POP_CPU_MARKER();
@@ -1041,16 +1042,6 @@ void World::update(float dt)
 #endif
 }   // update
 
-// ----------------------------------------------------------------------------
-/** Compute the new time, and set this new time to be used in the rewind
- *  manager.
- *  \param dt Time step size.
- */
-void World::updateTime(const float dt)
-{
-    WorldStatus::updateTime(dt);
-}   // updateTime
-
 // ----------------------------------------------------------------------------
 /** Only updates the track. The order in which the various parts of STK are
  *  updated is quite important (i.e. the track can't be updated as part of
@@ -1068,12 +1059,12 @@ void World::updateTime(const float dt)
  *  update has to be called after updating the race position in linear world.
  *  That's why there is a separate call for trackUpdate here.
  */
-void World::updateTrack(float dt)
+void World::updateTrack(int ticks)
 {
-    Track::getCurrentTrack()->update(dt);
+    Track::getCurrentTrack()->update(ticks);
 }   // update Track
-// ----------------------------------------------------------------------------
 
+// ----------------------------------------------------------------------------
 Highscores* World::getHighscores() const
 {
     if(!m_use_highscores) return NULL;
diff --git a/src/modes/world.hpp b/src/modes/world.hpp
index 4174f28b4..d4152a4aa 100644
--- a/src/modes/world.hpp
+++ b/src/modes/world.hpp
@@ -163,9 +163,9 @@ protected:
     virtual void  onGo() OVERRIDE;
     /** Returns true if the race is over. Must be defined by all modes. */
     virtual bool  isRaceOver() = 0;
-    virtual void  update(float dt) OVERRIDE;
+    virtual void  update(int ticks) OVERRIDE;
     virtual void  createRaceGUI();
-            void  updateTrack(float dt);
+            void  updateTrack(int ticks);
     // ------------------------------------------------------------------------
     /** Used for AI karts that are still racing when all player kart finished.
      *  Generally it should estimate the arrival time for those karts, but as
@@ -240,7 +240,6 @@ public:
     virtual void    reset() OVERRIDE;
     virtual void    pause(Phase phase) OVERRIDE;
     virtual void    unpause() OVERRIDE;
-    virtual void    updateTime(const float dt) OVERRIDE;
     virtual void    getDefaultCollectibles(int *collectible_type,
                                            int *amount );
     virtual void    endRaceEarly() { return; }
@@ -273,7 +272,7 @@ public:
     void            scheduleUnpause();
     void            scheduleExitRace() { m_schedule_exit_race = true; }
     void            scheduleTutorial();
-    void            updateWorld(float dt);
+    void            updateWorld(int ticks);
     void            handleExplosion(const Vec3 &xyz, AbstractKart *kart_hit,
                                     PhysicalObject *object);
     AbstractKart*   getPlayerKart(unsigned int player) const;
diff --git a/src/modes/world_status.cpp b/src/modes/world_status.cpp
index f49d23cb7..eabd893cf 100644
--- a/src/modes/world_status.cpp
+++ b/src/modes/world_status.cpp
@@ -172,7 +172,7 @@ void WorldStatus::terminateRace()
  *  updated.
  *  \param dt Time step.
  */
-void WorldStatus::update(float dt)
+void WorldStatus::update(int ticks)
 {
 }   // update
 
@@ -180,9 +180,9 @@ void WorldStatus::update(float dt)
 /** Updates the world time and clock (which might be running backwards), and
  *  all status information, called once per frame at the end of the main
  *  loop.
- *  \param dt Duration of time step.
+ *  \param ticks Number of ticks (physics time steps) - should be 1.
  */
-void WorldStatus::updateTime(const float dt)
+void WorldStatus::updateTime(int ticks)
 {
     switch (m_phase)
     {
diff --git a/src/modes/world_status.hpp b/src/modes/world_status.hpp
index dcc1081ae..16f4776bf 100644
--- a/src/modes/world_status.hpp
+++ b/src/modes/world_status.hpp
@@ -152,8 +152,8 @@ public:
     virtual ~WorldStatus();
 
     virtual void reset();
-    virtual void updateTime(const float dt);
-    virtual void update(float dt);
+    virtual void updateTime(int ticks);
+    virtual void update(int ticks);
     void         startReadySetGo();
     virtual void pause(Phase phase);
     virtual void unpause();
diff --git a/src/network/protocol.hpp b/src/network/protocol.hpp
index 2b9bcd9c9..a29ba33fe 100644
--- a/src/network/protocol.hpp
+++ b/src/network/protocol.hpp
@@ -119,7 +119,7 @@ public:
 
     /** \brief Called by the protocol listener, synchronously with the main
      *  loop. Must be re-defined.*/
-    virtual void update(float dt) = 0;
+    virtual void update(int ticks) = 0;
 
     /** \brief Called by the protocol listener as often as possible.
      *  Must be re-defined. */
diff --git a/src/network/protocol_manager.cpp b/src/network/protocol_manager.cpp
index f6aeb9601..2828bdb99 100644
--- a/src/network/protocol_manager.cpp
+++ b/src/network/protocol_manager.cpp
@@ -395,14 +395,14 @@ bool ProtocolManager::sendEvent(Event* event)
  *  \param dt Time step size.
  *  \param async True if asynchronousUpdate() should be called.
  */
-void ProtocolManager::OneProtocolType::update(float dt, bool async)
+void ProtocolManager::OneProtocolType::update(int ticks, bool async)
 {
     for (unsigned int i = 0; i < m_protocols.getData().size(); i++)
     {
         if (m_protocols.getData()[i]->getState() == PROTOCOL_STATE_RUNNING)
         {
             async ? m_protocols.getData()[i]->asynchronousUpdate()
-                  : m_protocols.getData()[i]->update(dt);
+                  : m_protocols.getData()[i]->update(ticks);
         }
     }
 }   // update
@@ -417,7 +417,7 @@ void ProtocolManager::OneProtocolType::update(float dt, bool async)
  *  This function is called by the main thread (i.e. from main_loop).
  *  This function IS FPS-dependant.
  */
-void ProtocolManager::update(float dt)
+void ProtocolManager::update(int ticks)
 {
     // Update from main thread only:
     assert(std::this_thread::get_id() != m_asynchronous_update_thread.get_id());
@@ -449,7 +449,7 @@ void ProtocolManager::update(float dt)
     {
         OneProtocolType &opt = m_all_protocols[i];
         opt.lock();
-        opt.update(dt, /*async*/false);
+        opt.update(ticks, /*async*/false);
         opt.unlock();
     }
 }   // update
diff --git a/src/network/protocol_manager.hpp b/src/network/protocol_manager.hpp
index 9712c3453..b6e0262be 100644
--- a/src/network/protocol_manager.hpp
+++ b/src/network/protocol_manager.hpp
@@ -149,7 +149,7 @@ private:
         void removeProtocol(std::shared_ptr<Protocol> p);
         void requestTerminateAll();
         bool notifyEvent(Event *event);
-        void update(float dt, bool async);
+        void update(int ticks, bool async);
         void abort();
         // --------------------------------------------------------------------
         /** Returns the first protocol of a given type. It is assumed that
@@ -242,7 +242,7 @@ public:
     void      requestUnpause(std::shared_ptr<Protocol> protocol);
     void      requestTerminate(std::shared_ptr<Protocol> protocol);
     void      findAndTerminate(ProtocolType type);
-    void      update(float dt);
+    void      update(int ticks);
     // ------------------------------------------------------------------------
     bool isExiting() const                            { return m_exit.load(); }
     // ------------------------------------------------------------------------
diff --git a/src/network/protocols/client_lobby.cpp b/src/network/protocols/client_lobby.cpp
index 6086d6e05..ea9a07139 100644
--- a/src/network/protocols/client_lobby.cpp
+++ b/src/network/protocols/client_lobby.cpp
@@ -298,7 +298,7 @@ bool ClientLobby::notifyEventAsynchronous(Event* event)
 
 //-----------------------------------------------------------------------------
 
-void ClientLobby::update(float dt)
+void ClientLobby::update(int ticks)
 {
     switch (m_state)
     {
diff --git a/src/network/protocols/client_lobby.hpp b/src/network/protocols/client_lobby.hpp
index bd7b5525a..b45fa4197 100644
--- a/src/network/protocols/client_lobby.hpp
+++ b/src/network/protocols/client_lobby.hpp
@@ -80,7 +80,7 @@ public:
     virtual bool notifyEventAsynchronous(Event* event) OVERRIDE;
     virtual void finishedLoadingWorld() OVERRIDE;
     virtual void setup() OVERRIDE;
-    virtual void update(float dt) OVERRIDE;
+    virtual void update(int ticks) OVERRIDE;
     virtual bool waitingForPlayers() const OVERRIDE
                                                   { return m_state == LINKED; }
     virtual void asynchronousUpdate() OVERRIDE {}
diff --git a/src/network/protocols/connect_to_peer.hpp b/src/network/protocols/connect_to_peer.hpp
index 88e7c53e5..d47264399 100644
--- a/src/network/protocols/connect_to_peer.hpp
+++ b/src/network/protocols/connect_to_peer.hpp
@@ -68,7 +68,7 @@ public:
 
     virtual bool notifyEventAsynchronous(Event* event) OVERRIDE;
     virtual void setup() OVERRIDE {}
-    virtual void update(float dt) OVERRIDE {}
+    virtual void update(int ticks) OVERRIDE {}
     virtual void asynchronousUpdate() OVERRIDE;
 };   // class ConnectToPeer
 
diff --git a/src/network/protocols/connect_to_server.cpp b/src/network/protocols/connect_to_server.cpp
index 277552baa..232c2a6a2 100644
--- a/src/network/protocols/connect_to_server.cpp
+++ b/src/network/protocols/connect_to_server.cpp
@@ -218,7 +218,7 @@ void ConnectToServer::asynchronousUpdate()
 }   // asynchronousUpdate
 
 // ----------------------------------------------------------------------------
-void ConnectToServer::update(float dt)
+void ConnectToServer::update(int ticks)
 {
     switch(m_state.load())
     {
diff --git a/src/network/protocols/connect_to_server.hpp b/src/network/protocols/connect_to_server.hpp
index cd86c35f8..d3e7d3eda 100644
--- a/src/network/protocols/connect_to_server.hpp
+++ b/src/network/protocols/connect_to_server.hpp
@@ -68,7 +68,7 @@ public:
     virtual bool notifyEventAsynchronous(Event* event) OVERRIDE;
     virtual void setup() OVERRIDE;
     virtual void asynchronousUpdate() OVERRIDE;
-    virtual void update(float dt) OVERRIDE;
+    virtual void update(int ticks) OVERRIDE;
 };   // class ConnectToServer
 
 #endif // CONNECT_TO_SERVER_HPP
diff --git a/src/network/protocols/game_events_protocol.hpp b/src/network/protocols/game_events_protocol.hpp
index 250108be5..7e2664ee2 100644
--- a/src/network/protocols/game_events_protocol.hpp
+++ b/src/network/protocols/game_events_protocol.hpp
@@ -35,7 +35,7 @@ public:
     void receivedClientHasStarted(Event *event);
     void kartFinishedRace(const NetworkString &ns);
     virtual void setup() OVERRIDE;
-    virtual void update(float dt) OVERRIDE {};
+    virtual void update(int ticks) OVERRIDE {};
     virtual void asynchronousUpdate() OVERRIDE{}
     // ------------------------------------------------------------------------
     virtual bool notifyEventAsynchronous(Event* event) OVERRIDE 
diff --git a/src/network/protocols/game_protocol.cpp b/src/network/protocols/game_protocol.cpp
index 10879a6f2..ae794f275 100644
--- a/src/network/protocols/game_protocol.cpp
+++ b/src/network/protocols/game_protocol.cpp
@@ -65,7 +65,7 @@ GameProtocol::~GameProtocol()
 /** Synchronous update - will send all commands collected during the last
  *  frame (and could optional only send messages every N frames).
  */
-void GameProtocol::update(float dt)
+void GameProtocol::update(int ticks)
 {
     if (m_all_actions.size() == 0) return;   // nothing to do
 
@@ -78,7 +78,7 @@ void GameProtocol::update(float dt)
     // Add all actions
     for (auto a : m_all_actions)
     {
-        m_data_to_send->addFloat(a.m_time);
+        m_data_to_send->addUInt32(a.m_ticks);
         m_data_to_send->addUInt8(a.m_kart_id);
         m_data_to_send->addUInt8((uint8_t)(a.m_action)).addUInt32(a.m_value)
                        .addUInt32(a.m_value_l).addUInt32(a.m_value_r);
@@ -130,7 +130,7 @@ void GameProtocol::controllerAction(int kart_id, PlayerAction action,
     a.m_value   = value;
     a.m_value_l = val_l;
     a.m_value_r = val_r;
-    a.m_time    = World::getWorld()->getTime();
+    a.m_ticks   = World::getWorld()->getTimeTicks();
 
     m_all_actions.push_back(a);
 
@@ -142,8 +142,8 @@ void GameProtocol::controllerAction(int kart_id, PlayerAction action,
     RewindManager::get()->addEvent(this, s, /*confirmed*/true,
                                    World::getWorld()->getTimeTicks() );
 
-    Log::info("GameProtocol", "Action at %f: %d value %d",
-              World::getWorld()->getTime(), action, 
+    Log::info("GameProtocol", "Action at %d: %d value %d",
+              World::getWorld()->getTimeTicks(), action, 
               action==PlayerAction::PA_STEER_RIGHT ? -value : value);
 }   // controllerAction
 
@@ -238,8 +238,8 @@ void GameProtocol::adjustTimeForClient(STKPeer *peer, int ticks)
  */
 void GameProtocol::handleAdjustTime(Event *event)
 {
-    float t = event->data().getFloat();
-    World::getWorld()->setAdjustTime(t);
+    int ticks = event->data().getUInt32();
+    World::getWorld()->setAdjustTime(stk_config->ticks2Time(ticks));
 }   // handleAdjustTime
 // ----------------------------------------------------------------------------
 /** Called by the server before assembling a new message containing the full
@@ -249,9 +249,9 @@ void GameProtocol::startNewState()
 {
     assert(NetworkConfig::get()->isServer());
     m_data_to_send->clear();
-    m_data_to_send->addUInt8(GP_STATE).addFloat(World::getWorld()->getTime());
-    Log::info("GameProtocol", "Sending new state at %f.",
-              World::getWorld()->getTime());
+    m_data_to_send->addUInt8(GP_STATE).addUInt32(World::getWorld()->getTimeTicks());
+    Log::info("GameProtocol", "Sending new state at %d.",
+              World::getWorld()->getTimeTicks());
 }   // startNewState
 
 // ----------------------------------------------------------------------------
diff --git a/src/network/protocols/game_protocol.hpp b/src/network/protocols/game_protocol.hpp
index cfefa3ec6..ad40535e6 100644
--- a/src/network/protocols/game_protocol.hpp
+++ b/src/network/protocols/game_protocol.hpp
@@ -54,7 +54,7 @@ private:
     // Dummy data structure to save all kart actions.
     struct Action
     {
-        float        m_time;
+        int          m_ticks;
         int          m_kart_id;
         PlayerAction m_action;
         int          m_value;
@@ -74,7 +74,7 @@ public:
     virtual ~GameProtocol();
 
     virtual bool notifyEventAsynchronous(Event* event) OVERRIDE;
-    virtual void update(float dt) OVERRIDE;
+    virtual void update(int ticks) OVERRIDE;
 
     void controllerAction(int kart_id, PlayerAction action,
                           int value, int val_l, int val_r);
diff --git a/src/network/protocols/get_peer_address.hpp b/src/network/protocols/get_peer_address.hpp
index 02b5f8d2a..6a251faba 100644
--- a/src/network/protocols/get_peer_address.hpp
+++ b/src/network/protocols/get_peer_address.hpp
@@ -45,7 +45,7 @@ public:
     /** Returns the address found. */
     const TransportAddress &getAddress() const { return m_address;  }
     // ------------------------------------------------------------------------
-    virtual void update(float dt) OVERRIDE {}
+    virtual void update(int ticks) OVERRIDE {}
     // ------------------------------------------------------------------------
     virtual bool notifyEvent(Event* event) OVERRIDE { return true; }
     // ------------------------------------------------------------------------
diff --git a/src/network/protocols/hide_public_address.hpp b/src/network/protocols/hide_public_address.hpp
index 858833bea..48adb355c 100644
--- a/src/network/protocols/hide_public_address.hpp
+++ b/src/network/protocols/hide_public_address.hpp
@@ -50,7 +50,7 @@ public:
     // ------------------------------------------------------------------------
     virtual bool notifyEventAsynchronous(Event* event) OVERRIDE { return true; }
     // ------------------------------------------------------------------------
-    virtual void update(float dt) OVERRIDE {}
+    virtual void update(int ticks) OVERRIDE {}
 };   // class HidePublicAddress
 
 #endif // HIDE_PUBLIC_ADDRESS_HPP
diff --git a/src/network/protocols/latency_protocol.hpp b/src/network/protocols/latency_protocol.hpp
index 1ef1ded7c..92baa6caf 100644
--- a/src/network/protocols/latency_protocol.hpp
+++ b/src/network/protocols/latency_protocol.hpp
@@ -31,7 +31,7 @@ public:
     virtual void asynchronousUpdate() OVERRIDE;
 
     // ------------------------------------------------------------------------
-    virtual void update(float dt) OVERRIDE {}
+    virtual void update(int ticks) OVERRIDE {}
 
 };   // class LatencyProtocol
 
diff --git a/src/network/protocols/lobby_protocol.hpp b/src/network/protocols/lobby_protocol.hpp
index ac5020e04..93a69b7cc 100644
--- a/src/network/protocols/lobby_protocol.hpp
+++ b/src/network/protocols/lobby_protocol.hpp
@@ -97,7 +97,7 @@ public:
              LobbyProtocol(CallbackObject* callback_object);
     virtual ~LobbyProtocol();
     virtual void setup()                = 0;
-    virtual void update(float dt)       = 0;
+    virtual void update(int ticks)      = 0;
     virtual void finishedLoadingWorld() = 0;
     virtual void loadWorld();
     virtual bool waitingForPlayers() const = 0;
diff --git a/src/network/protocols/request_connection.hpp b/src/network/protocols/request_connection.hpp
index de70737e0..e8c99e981 100644
--- a/src/network/protocols/request_connection.hpp
+++ b/src/network/protocols/request_connection.hpp
@@ -45,7 +45,7 @@ public:
     // ------------------------------------------------------------------------
     virtual bool notifyEventAsynchronous(Event* event) OVERRIDE { return true; }
     // ------------------------------------------------------------------------
-    virtual void update(float dt) OVERRIDE {}
+    virtual void update(int ticks) OVERRIDE {}
 
 
 };   // RequestConnection
diff --git a/src/network/protocols/server_lobby.cpp b/src/network/protocols/server_lobby.cpp
index 0c73790fd..c7408289a 100644
--- a/src/network/protocols/server_lobby.cpp
+++ b/src/network/protocols/server_lobby.cpp
@@ -252,7 +252,7 @@ void ServerLobby::asynchronousUpdate()
  *  is known, register the server and its address with the stk server so that
  *  client can find it.
  */
-void ServerLobby::update(float dt)
+void ServerLobby::update(int ticks)
 {
     switch (m_state.load())
     {
@@ -439,7 +439,7 @@ void ServerLobby::signalRaceStartToClients()
  */
 void ServerLobby::startSelection(const Event *event)
 {
-    assert(m_server_registered);
+    //assert(m_server_registered);
     if (m_server_registered)
     {
         unregisterServer();
diff --git a/src/network/protocols/server_lobby.hpp b/src/network/protocols/server_lobby.hpp
index a25e0a3f0..4e067ab22 100644
--- a/src/network/protocols/server_lobby.hpp
+++ b/src/network/protocols/server_lobby.hpp
@@ -90,7 +90,7 @@ public:
     virtual bool notifyEventAsynchronous(Event* event) OVERRIDE;
     virtual bool notifyEvent(Event* event) OVERRIDE;
     virtual void setup() OVERRIDE;
-    virtual void update(float dt) OVERRIDE;
+    virtual void update(int ticks) OVERRIDE;
     virtual void asynchronousUpdate() OVERRIDE;
 
     void signalRaceStartToClients();
diff --git a/src/network/race_event_manager.cpp b/src/network/race_event_manager.cpp
index 20c79c0ef..e1e4e1e54 100644
--- a/src/network/race_event_manager.cpp
+++ b/src/network/race_event_manager.cpp
@@ -22,8 +22,9 @@ RaceEventManager::~RaceEventManager()
 // ----------------------------------------------------------------------------
 /** In network games this update function is called instead of
  *  World::updateWorld(). 
+ *  \param ticks Number of physics time steps - should be 1.
  */
-void RaceEventManager::update(float dt)
+void RaceEventManager::update(int ticks)
 {
     // Replay all recorded events up to the current time (only if the
     // timer isn't stopped, otherwise a potential rewind will trigger
@@ -33,11 +34,11 @@ void RaceEventManager::update(float dt)
         // This might adjust dt - if a new state is being played, the dt is
         // determined from the last state till 'now'
         PROFILER_PUSH_CPU_MARKER("RaceEvent:play event", 100, 100, 100);
-        RewindManager::get()->playEventsTill(World::getWorld()->getTime(),
-                                             &dt);
+        RewindManager::get()->playEventsTill(World::getWorld()->getTimeTicks(),
+                                             &ticks);
         PROFILER_POP_CPU_MARKER();
     }
-    World::getWorld()->updateWorld(dt);
+    World::getWorld()->updateWorld(ticks);
 
     // if the race is over
     if (World::getWorld()->getPhase() >= WorldStatus::RESULT_DISPLAY_PHASE &&
diff --git a/src/network/race_event_manager.hpp b/src/network/race_event_manager.hpp
index 3fff5064f..3ed855c40 100755
--- a/src/network/race_event_manager.hpp
+++ b/src/network/race_event_manager.hpp
@@ -46,7 +46,7 @@ private:
     virtual ~RaceEventManager();
 
 public:
-    void update(float dt);
+    void update(int ticks);
 
     void start();
     void stop();
diff --git a/src/network/rewind_manager.cpp b/src/network/rewind_manager.cpp
index 99bc08804..ec52b41c3 100755
--- a/src/network/rewind_manager.cpp
+++ b/src/network/rewind_manager.cpp
@@ -172,10 +172,11 @@ void RewindManager::addNetworkState(int rewinder_index, BareNetworkString *buffe
 // ----------------------------------------------------------------------------
 /** Determines if a new state snapshot should be taken, and if so calls all
  *  rewinder to do so.
- *  \param dt Time step size.
+ *  \param ticks_not_used NUmber of physics time steps - should be 1.
  */
-void RewindManager::update(float dt)
+void RewindManager::update(int ticks_not_used)
 {
+    // FIXME: rename ticks_not_used
     if(!m_enable_rewind_manager  || 
         m_all_rewinder.size()==0 ||
         m_is_rewinding              )  return;
@@ -220,18 +221,18 @@ void RewindManager::update(float dt)
 // ----------------------------------------------------------------------------
 /** Replays all events from the last event played till the specified time.
  *  \param time Up to (and inclusive) which time events will be replayed.
- *  \param dt Time step size. This might get adjusted if a new state has
- *         been received.
+ *  \param dt Number of time steps - should be 1.
  */
-void RewindManager::playEventsTill(float time, float *dt)
+void RewindManager::playEventsTill(float time, int *ticks)
 {    
     bool needs_rewind;
     int rewind_ticks;
 
-    // Merge in all network events that have happened since the last
+    // Merge in all network events that have happened at the current
+    // time step.
     // merge and that have happened before the current time (which will
     // be getTime()+dt - world time has not been updated yet).
-    m_rewind_queue.mergeNetworkData(World::getWorld()->getTimeTicks(), *dt,
+    m_rewind_queue.mergeNetworkData(World::getWorld()->getTimeTicks(),
                                     &needs_rewind, &rewind_ticks);
 
     if (needs_rewind)
@@ -340,12 +341,12 @@ void RewindManager::rewindTo(int rewind_ticks)
         // the world:
         current->replayAllEvents();
         dt = current->getDT();
-        world->updateWorld(dt);
+        world->updateWorld(1);
 #undef SHOW_ROLLBACK
 #ifdef SHOW_ROLLBACK
         irr_driver->update(dt);
 #endif
-        world->updateTime(dt);
+        world->updateTime(1);
 
         ++m_rewind_queue;
         current = m_rewind_queue.getCurrent();
diff --git a/src/network/rewind_manager.hpp b/src/network/rewind_manager.hpp
index e28c19db0..faee7d8c7 100644
--- a/src/network/rewind_manager.hpp
+++ b/src/network/rewind_manager.hpp
@@ -137,9 +137,9 @@ public:
     // Non-static function declarations:
 
     void reset();
-    void update(float dt);
+    void update(int ticks);
     void rewindTo(int target_ticks);
-    void playEventsTill(float time, float *dt);
+    void playEventsTill(float time, int *ticks);
     void addEvent(EventRewinder *event_rewinder, BareNetworkString *buffer,
                   bool confirmed, int ticks = -1);
     void addNetworkEvent(EventRewinder *event_rewinder,
diff --git a/src/network/rewind_queue.cpp b/src/network/rewind_queue.cpp
index cc5bbbcc3..1d1827807 100755
--- a/src/network/rewind_queue.cpp
+++ b/src/network/rewind_queue.cpp
@@ -241,8 +241,6 @@ void RewindQueue::addNetworkState(Rewinder *rewinder, BareNetworkString *buffer,
  *  local rewind information.
  *  \param world_ticks[in] Current world time up to which network events will be
  *         merged in.
- *  \param dt[in] Time step size. The current frame will cover events between
- *         world_time and world_time+dt.
  *  \param needs_rewind[out] True if network rewind information was received
  *         which was in the past (of this simulation), so a rewind must be
  *         performed.
@@ -250,7 +248,7 @@ void RewindQueue::addNetworkState(Rewinder *rewinder, BareNetworkString *buffer,
  *         must be performed (at least). Otherwise undefined, but the value
  *         might be modified in this function.
  */
-void RewindQueue::mergeNetworkData(int world_ticks, float dt,
+void RewindQueue::mergeNetworkData(int world_ticks,
                                    bool *needs_rewind, int *rewind_ticks)
 {
     *needs_rewind = false;
@@ -274,10 +272,8 @@ void RewindQueue::mergeNetworkData(int world_ticks, float dt,
     {
         // Ignore any events that will happen in the future. An event needs
         // to be handled at the closest time to its original time. The current
-        // time step id world_time, the next will be world_time+dt. So if the
-        // event is later than world_time+0.5*dt, it will be closer to a
-        // future time stamp and is ignored now.
-        if ((*i)->getTicks() > world_ticks+0.5f*dt)
+        // time step is world_ticks.
+        if ((*i)->getTicks() > world_ticks)
         {
             i++;
             continue;
@@ -467,17 +463,17 @@ void RewindQueue::unitTesting()
     int world_ticks = 0;
     float dt = 0.01f;
     assert((*q0.m_time_step_info.begin())->getNumberOfEvents() == 1);
-    q0.mergeNetworkData(world_ticks, dt, &needs_rewind, &rewind_ticks);
+    q0.mergeNetworkData(world_ticks, &needs_rewind, &rewind_ticks);
     assert((*q0.m_time_step_info.begin())->getNumberOfEvents() == 2);
 
     // This will be added to timestep 0
     q0.addNetworkEvent(dummy_rewinder, NULL, 2);
     dt = 0.01f;   // to small, event from 0.2 will not be merged
-    q0.mergeNetworkData(world_ticks, dt, &needs_rewind, &rewind_ticks);
+    q0.mergeNetworkData(world_ticks, &needs_rewind, &rewind_ticks);
     assert(q0.m_time_step_info.size() == 2);
     assert((*q0.m_time_step_info.begin())->getNumberOfEvents() == 2);
     dt = 0.3f;
-    q0.mergeNetworkData(world_ticks, dt, &needs_rewind, &rewind_ticks);
+    q0.mergeNetworkData(world_ticks, &needs_rewind, &rewind_ticks);
     assert(q0.m_time_step_info.size() == 2);
     assert((*q0.m_time_step_info.begin())->getNumberOfEvents() == 3);
 
@@ -485,7 +481,7 @@ void RewindQueue::unitTesting()
     q0.addNetworkEvent(dummy_rewinder, NULL, 1);
     world_ticks = 8;
     dt = 0.3f;
-    q0.mergeNetworkData(world_ticks, dt, &needs_rewind, &rewind_ticks);
+    q0.mergeNetworkData(world_ticks, &needs_rewind, &rewind_ticks);
     // Note that end() is behind the list, i.e. invalid, but rbegin()
     // is the last element
     assert((*q0.m_time_step_info.rbegin())->getNumberOfEvents() == 1);
diff --git a/src/network/rewind_queue.hpp b/src/network/rewind_queue.hpp
index 0efb26307..c282f2d0e 100755
--- a/src/network/rewind_queue.hpp
+++ b/src/network/rewind_queue.hpp
@@ -82,8 +82,8 @@ public:
                          BareNetworkString *buffer, int ticks);
     void addNetworkState(Rewinder *rewinder, BareNetworkString *buffer,
                          int ticks, float dt);
-    void mergeNetworkData(int world_ticks, float dt,
-                          bool *needs_rewind, int *rewind_ticks);
+    void mergeNetworkData(int world_ticks,  bool *needs_rewind, 
+                          int *rewind_ticks);
     bool isEmpty() const;
     bool hasMoreRewindInfo() const;
     void undoUntil(int undo_ticks);
diff --git a/src/physics/physics.cpp b/src/physics/physics.cpp
index f9eb68b77..22a4a1ae4 100644
--- a/src/physics/physics.cpp
+++ b/src/physics/physics.cpp
@@ -136,9 +136,9 @@ void Physics::removeKart(const AbstractKart *kart)
 
 //-----------------------------------------------------------------------------
 /** Updates the physics simulation and handles all collisions.
- *  \param dt Time step.
+ *  \param ticks Number of physics steps to simulate.
  */
-void Physics::update(float dt)
+void Physics::update(int ticks)
 {
     PROFILER_PUSH_CPU_MARKER("Physics", 0, 0, 0);
 
@@ -154,7 +154,8 @@ void Physics::update(float dt)
     // Since the world update (which calls physics update) is called at the
     // fixed frequency necessary for the physics update, we need to do exactly
     // one physic step only.
-    m_dynamics_world->stepSimulation(dt, 1, stk_config->ticks2Time(1));
+    m_dynamics_world->stepSimulation(stk_config->ticks2Time(1), 1,
+                                     stk_config->ticks2Time(1)      );
 
     // Now handle the actual collision. Note: flyables can not be removed
     // inside of this loop, since the same flyables might hit more than one
diff --git a/src/physics/physics.hpp b/src/physics/physics.hpp
index 9f6702a3b..424b50daf 100644
--- a/src/physics/physics.hpp
+++ b/src/physics/physics.hpp
@@ -166,7 +166,7 @@ public:
     void  removeBody       (btRigidBody* b) {m_dynamics_world->removeRigidBody(b);}
     void  KartKartCollision(AbstractKart *ka, const Vec3 &contact_point_a,
                             AbstractKart *kb, const Vec3 &contact_point_b);
-    void  update           (float dt);
+    void  update           (int ticks);
     void  draw             ();
     STKDynamicsWorld*
           getPhysicsWorld  () const {return m_dynamics_world;}
diff --git a/src/race/history.cpp b/src/race/history.cpp
index 357a2390b..80efee64e 100644
--- a/src/race/history.cpp
+++ b/src/race/history.cpp
@@ -40,7 +40,6 @@ History* history = 0;
 History::History()
 {
     m_replay_mode  = HISTORY_NONE;
-    m_history_time = 0.0f;
 }   // History
 
 //-----------------------------------------------------------------------------
@@ -86,11 +85,11 @@ void History::addEvent(int kart_id, PlayerAction pa, int value)
     InputEvent ie;
     // The event is added before m_current is increased. So in order to
     // save the right index for this event, we need to use m_current+1.
-    ie.m_index      = m_current+1;
-    ie.m_time       = World::getWorld()->getTime();
-    ie.m_action     = pa;
-    ie.m_value      = value;
-    ie.m_kart_index = kart_id;
+    ie.m_index       = m_current+1;
+    ie.m_world_ticks = World::getWorld()->getTimeTicks();
+    ie.m_action      = pa;
+    ie.m_value       = value;
+    ie.m_kart_index  = kart_id;
     m_all_input_events.emplace_back(ie);
 }   // addEvent
 
@@ -98,7 +97,7 @@ void History::addEvent(int kart_id, PlayerAction pa, int value)
 /** Saves the current history.
  *  \param dt Time step size.
  */
-void History::updateSaving(float dt)
+void History::updateSaving(int ticks)
 {
     m_current++;
     if(m_current>=(int)m_all_deltas.size())
@@ -112,7 +111,7 @@ void History::updateSaving(float dt)
         if(m_size<(int)m_all_deltas.size())
             m_size ++;
     }
-    m_all_deltas[m_current] = dt;
+    m_all_deltas[m_current] = ticks;
 
     World *world = World::getWorld();
     unsigned int num_karts = world->getNumKarts();
@@ -128,9 +127,10 @@ void History::updateSaving(float dt)
 
 //-----------------------------------------------------------------------------
 /** Sets the kart position and controls to the recorded history value.
- *  \return dt Time step size.
+ *  \param world_ticks WOrld time in ticks.
+ *  \param ticks Number of time steps.
  */
-float History::updateReplayAndGetDT(float world_time, float dt)
+void History::updateReplay(int world_ticks, float dt)
 {
     World *world = World::getWorld();
     // Networking
@@ -139,39 +139,30 @@ float History::updateReplayAndGetDT(float world_time, float dt)
     // not the recorded time steps.
     if (NetworkConfig::get()->isNetworking())
     {
-        // If the event time is greater than world_time+0.5*dt, then it is
-        // closer to the next timestep. So we only replay events till 
-        // world_time + 0.5f
         while (m_event_index < m_all_input_events.size() &&
-            m_all_input_events[m_event_index].m_time <= world_time+0.5f*dt)
+            m_all_input_events[m_event_index].m_world_ticks <= world_ticks)
         {
             const InputEvent &ie = m_all_input_events[m_event_index];
             AbstractKart *kart = world->getKart(ie.m_kart_index);
-            Log::verbose("history", "time %f event-time %f action %d %d",
-                world->getTime(), ie.m_time, ie.m_action, ie.m_value);
+            Log::verbose("history", "time %d event-time %d action %d %d",
+                world->getTimeTicks(), ie.m_world_ticks, ie.m_action,
+                ie.m_value);
             kart->getController()->action(ie.m_action, ie.m_value);
             m_event_index++;
         }
-        return dt;
+        return;
     }
 
     // Now handle the non-networking case
     // ----------------------------------
-    Log::verbose("history", "Begin %f %f %f %f current %d event %d",
-        m_history_time, world_time, dt, world_time + dt,
-        m_current, m_event_index);
 
     m_current++;
-    Log::verbose("history", "Inner %f %f %f %f current %d event %d",
-        m_history_time, world_time, dt, world_time + dt,
-        m_current, m_event_index);
 
     // Check if we have reached the end of the buffer
     if (m_current >= (int)m_all_deltas.size())
     {
         Log::info("History", "Replay finished");
         m_current = 0;
-        m_history_time = 0;
         // This is useful to use a reproducable rewind problem:
         // replay it with history, for debugging only
 #undef DO_REWIND_AT_END_OF_HISTORY
@@ -202,19 +193,16 @@ float History::updateReplayAndGetDT(float world_time, float dt)
         {
             const InputEvent &ie = m_all_input_events[m_event_index];
             AbstractKart *kart = world->getKart(ie.m_kart_index);
-            Log::verbose("history", "time %f event-time %f action %d %d",
-                world->getTime(), ie.m_time, ie.m_action, ie.m_value);
+            Log::verbose("history", "time %d event-time %d action %d %d",
+                world->getTimeTicks(), ie.m_world_ticks, ie.m_action,
+                ie.m_value);
             kart->getController()->action(ie.m_action, ie.m_value);
             m_event_index++;
         }
 
-
-        if (World::getWorld()->isRacePhase())
-            m_history_time += m_all_deltas[m_current];
     }
-    return m_all_deltas[m_current];
 
-}   // updateReplayAndGetDT
+}   // updateReplay
 
 //-----------------------------------------------------------------------------
 /** Saves the history stored in the internal data structures into a file called
@@ -242,7 +230,7 @@ void History::Save()
 
     World *world   = World::getWorld();
     const int num_karts = world->getNumKarts();
-    fprintf(fd, "Version-1:  %s\n",   STK_VERSION);
+    fprintf(fd, "Version-2:  %s\n",   STK_VERSION);
     fprintf(fd, "numkarts: %d\n",   num_karts);
     fprintf(fd, "numplayers: %d\n", race_manager->getNumPlayers());
     fprintf(fd, "difficulty: %d\n", race_manager->getDifficulty());
@@ -298,7 +286,7 @@ void History::Save()
                     m_all_input_events[event_index].m_kart_index,
                     m_all_input_events[event_index].m_action,
                     m_all_input_events[event_index].m_value,
-                    m_all_input_events[event_index].m_time);
+                    m_all_input_events[event_index].m_world_ticks);
             event_index++;
         }
         index=(index+1)%m_size;
@@ -332,15 +320,15 @@ void History::Load()
         Log::fatal("History", "Could not read history.dat.");
 
     int version = 0;
-    if (sscanf(s, "Version-1: %1023s", s1) == 1)
-        version = 1;
+    if (sscanf(s, "Version-2: %1023s", s1) == 1)
+        version = 2;
     else if (sscanf(s,"Version: %1023s",s1)!=1)
         Log::fatal("History", "No Version information found in history "
                               "file (bogus history file).");
     if (strcmp(s1,STK_VERSION))
         Log::warn("History", "History is version '%s', STK version is '%s'.",
                   s1, STK_VERSION);
-    if (version != 1)
+    if (version != 2)
         Log::fatal("History",
                    "Old-style history files are not supported anymore.");
 
@@ -440,7 +428,7 @@ void History::Load()
             InputEvent ie;
             ie.m_index = i;
             if (sscanf(s, "%d %d %d %f\n", &ie.m_kart_index, &ie.m_action,
-                       &ie.m_value, &ie.m_time)                           != 4)
+                       &ie.m_value, &ie.m_world_ticks)                    != 4)
             {
                 Log::warn("History", "Problems reading event: '%s'", s);
             }
diff --git a/src/race/history.hpp b/src/race/history.hpp
index 94dfb537e..f426fa77c 100644
--- a/src/race/history.hpp
+++ b/src/race/history.hpp
@@ -71,10 +71,6 @@ private:
     /** Stores the kart controls being used (for physics replay). */
     std::vector<KartControl>   m_all_controls;
 
-    /** For networking: keep track of the replay time so that the
-     *  right event can be replayed. */
-    float                      m_history_time;
-
     /** Stores the coordinates (for simple replay). */
     AlignedArray<Vec3>         m_all_xyz;
 
@@ -90,7 +86,7 @@ private:
         /** Index at which the even happened. */
         int m_index;
         /* Time at which this event occurred. */
-        float m_time;
+        int m_world_ticks;
         /** For which kart the event was. */
         int m_kart_index;
         /** Which action it was. */
@@ -109,8 +105,8 @@ public:
     void  initRecording  ();
     void  Save           ();
     void  Load           ();
-    void  updateSaving(float dt);
-    float updateReplayAndGetDT(float time, float dt);
+    void  updateSaving(int ticks);
+    void  updateReplay(int world_ticks, float dt);
     void  addEvent(int kart_id, PlayerAction pa, int value);
 
     // -------------------I-----------------------------------------------------
diff --git a/src/replay/replay_recorder.cpp b/src/replay/replay_recorder.cpp
index e94a111e4..d758bf57b 100644
--- a/src/replay/replay_recorder.cpp
+++ b/src/replay/replay_recorder.cpp
@@ -95,9 +95,9 @@ void ReplayRecorder::init()
 
 //-----------------------------------------------------------------------------
 /** Saves the current replay data.
- *  \param dt Time step size.
+ *  \param ticks Number of physics time steps - should be 1.
  */
-void ReplayRecorder::update(float dt)
+void ReplayRecorder::update(int ticks)
 {
     if (m_incorrect_replay || m_complete_replay) return;
 
diff --git a/src/replay/replay_recorder.hpp b/src/replay/replay_recorder.hpp
index be4cced62..59168e9de 100644
--- a/src/replay/replay_recorder.hpp
+++ b/src/replay/replay_recorder.hpp
@@ -72,7 +72,7 @@ public:
     void  init();
     void  reset();
     void  save();
-    void  update(float dt);
+    void  update(int ticks);
 
     // ------------------------------------------------------------------------
     /** Creates a new instance of the replay object. */
diff --git a/src/states_screens/feature_unlocked.cpp b/src/states_screens/feature_unlocked.cpp
index b2fccb05d..42c17733d 100644
--- a/src/states_screens/feature_unlocked.cpp
+++ b/src/states_screens/feature_unlocked.cpp
@@ -683,7 +683,7 @@ void FeatureUnlockedCutScene::continueButtonPressed()
         {
             // simulate all the steps of the animation until we reach the end
             onUpdate(0.4f);
-            World::getWorld()->updateWorld(0.4f);
+            World::getWorld()->updateWorld(stk_config->time2Ticks(0.4f));
         }
     }
     else
diff --git a/src/states_screens/race_gui_base.cpp b/src/states_screens/race_gui_base.cpp
index 92d393f1c..a4956b647 100644
--- a/src/states_screens/race_gui_base.cpp
+++ b/src/states_screens/race_gui_base.cpp
@@ -937,7 +937,7 @@ void RaceGUIBase::drawGlobalPlayerIcons(int bottom_margin)
         }
 
         //Plunger
-        if (kart->getBlockedByPlungerTime()>0)
+        if (kart->getBlockedByPlungerTicks()>0)
         {
             video::ITexture *icon_plunger =
             powerup_manager->getIcon(PowerupManager::POWERUP_PLUNGER)->getTexture();
@@ -981,7 +981,7 @@ void RaceGUIBase::drawPlungerInFace(const Camera *camera, float dt)
 {
 #ifndef SERVER_ONLY
     const AbstractKart *kart = camera->getKart();
-    if (kart->getBlockedByPlungerTime()<=0)
+    if (kart->getBlockedByPlungerTicks()<=0)
     {
         m_plunger_state = PLUNGER_STATE_INIT;
         return;
@@ -1006,7 +1006,7 @@ void RaceGUIBase::drawPlungerInFace(const Camera *camera, float dt)
         if(m_plunger_move_time < dt && m_plunger_state!=PLUNGER_STATE_FAST)
         {
             const float fast_time = 0.3f;
-            if(kart->getBlockedByPlungerTime()<fast_time)
+            if(kart->getBlockedByPlungerTicks()<fast_time)
             {
                 // First time we reach faste state: select random target point
                 // at top of screen and set speed accordingly
diff --git a/src/tracks/track.cpp b/src/tracks/track.cpp
index 93fe9322d..cd50ad1ee 100644
--- a/src/tracks/track.cpp
+++ b/src/tracks/track.cpp
@@ -1530,21 +1530,21 @@ void Track::handleAnimatedTextures(scene::ISceneNode *node, const XMLNode &xml)
 /** Update, called once per frame.
  *  \param dt Timestep.
  */
-void Track::update(float dt)
+void Track::update(int ticks)
 {
     if (!m_startup_run) // first time running update = good point to run startup script
     {
         Scripting::ScriptEngine::getInstance()->runFunction(false, "void onStart()");
         m_startup_run = true;
     }
-    m_track_object_manager->update(dt);
+    m_track_object_manager->update(ticks);
 
     for(unsigned int i=0; i<m_animated_textures.size(); i++)
     {
-        m_animated_textures[i]->update(dt);
+        m_animated_textures[i]->update(ticks);
     }
-    CheckManager::get()->update(dt);
-    ItemManager::get()->update(dt);
+    CheckManager::get()->update(ticks);
+    ItemManager::get()->update(ticks);
 
     // TODO: enable onUpdate scripts if we ever find a compelling use for them
     //Scripting::ScriptEngine* script_engine = World::getWorld()->getScriptEngine();
diff --git a/src/tracks/track.hpp b/src/tracks/track.hpp
index 4117633ee..8bcecec5e 100644
--- a/src/tracks/track.hpp
+++ b/src/tracks/track.hpp
@@ -421,7 +421,7 @@ public:
     void               startMusic        () const;
 
     void               createPhysicsModel(unsigned int main_track_count);
-    void               update(float dt);
+    void               update(int ticks);
     void               reset();
     void               itemCommand(const XMLNode *node);
     core::stringw      getName() const;