From c1098c85cbcb11976d1b8cd27b07d1e6fe580d8c Mon Sep 17 00:00:00 2001
From: bart <bart@bbun>
Date: Wed, 12 Feb 2025 17:11:50 +0100
Subject: [PATCH 1/9] Three strikes battle changes and favorites bugfix

---
 data/gui/screens/track_info.stkgui            |  10 +
 src/audio/music.hpp                           |   1 +
 src/audio/music_information.cpp               |  40 +-
 src/audio/music_information.hpp               |  16 +-
 src/audio/music_ogg.cpp                       |  22 +-
 src/audio/music_ogg.hpp                       |   2 +-
 src/audio/sfx_manager.cpp                     |   2 +-
 src/config/favorite_status.cpp                |   6 +
 src/config/favorite_status.hpp                |   2 +
 src/config/player_profile.cpp                 |  19 +-
 src/config/saved_grand_prix.hpp               |   4 +
 src/config/user_config.hpp                    |  29 +-
 src/graphics/camera/camera.hpp                |   2 -
 src/graphics/camera/camera_normal.cpp         |  59 +-
 src/graphics/irr_driver.cpp                   |   2 +-
 src/graphics/lighting_passes.cpp              |  27 +-
 src/graphics/lighting_passes.hpp              |   6 +-
 src/graphics/post_processing.cpp              |  52 +-
 src/graphics/post_processing.hpp              |   2 +-
 src/graphics/shader_based_renderer.cpp        |  38 +-
 src/graphics/shadow_matrices.cpp              |  14 +-
 src/graphics/shadow_matrices.hpp              |  11 +-
 src/graphics/sp/sp_base.cpp                   |  23 +-
 src/guiengine/event_handler.cpp               |  65 ++-
 src/guiengine/event_handler.hpp               |   4 +-
 src/guiengine/skin.cpp                        |   5 +-
 src/guiengine/widgets/ribbon_widget.cpp       |  24 -
 src/guiengine/widgets/ribbon_widget.hpp       |   7 -
 src/input/device_manager.cpp                  |  18 -
 src/input/device_manager.hpp                  |   6 +-
 src/items/attachment.cpp                      |  31 +-
 src/items/item.cpp                            |  92 ++--
 src/items/item.hpp                            |   3 -
 .../controller/local_player_controller.cpp    |   6 +-
 src/karts/controller/spare_tire_ai.cpp        |  17 +-
 src/karts/kart_model.cpp                      |   3 +-
 src/karts/kart_properties_manager.cpp         |   2 +-
 src/main.cpp                                  |  48 +-
 src/modes/linear_world.cpp                    |  19 +-
 src/modes/overworld.cpp                       |   9 -
 src/modes/three_strikes_battle.cpp            |  71 +--
 src/modes/three_strikes_battle.hpp            |  10 +
 src/modes/world.cpp                           |  91 ++--
 src/modes/world.hpp                           |   2 -
 src/network/protocols/ranking.cpp             | 488 -----------------
 src/network/protocols/ranking.hpp             |  82 ---
 src/network/protocols/server_lobby.cpp        | 504 +++++++++++++++---
 src/network/protocols/server_lobby.hpp        |  45 +-
 src/network/server_config.cpp                 |   8 +-
 src/race/race_manager.cpp                     |  17 +-
 src/race/race_manager.hpp                     |  10 +
 .../dialogs/custom_video_settings.cpp         |   7 +-
 src/states_screens/help/help_screen_1.cpp     |  20 -
 src/states_screens/help/help_screen_1.hpp     |   3 -
 src/states_screens/kart_selection.cpp         |  23 +-
 src/states_screens/main_menu_screen.cpp       |  19 -
 .../online/networking_lobby.cpp               |   1 -
 src/states_screens/online/tracks_screen.cpp   |   2 +-
 src/states_screens/options/options_common.cpp |  15 -
 src/states_screens/options/options_common.hpp |   1 -
 .../options/options_screen_audio.cpp          |   3 +-
 .../options/options_screen_device.cpp         |   6 +-
 .../options/options_screen_display.cpp        |   2 -
 .../options/options_screen_general.cpp        |   2 -
 .../options/options_screen_input.cpp          |   2 -
 .../options/options_screen_ui.cpp             |   1 -
 .../options/options_screen_video.cpp          |  28 +-
 src/states_screens/race_gui.cpp               |  16 +-
 src/states_screens/race_gui_overworld.cpp     |  10 -
 src/states_screens/race_result_gui.cpp        | 170 +++---
 src/states_screens/race_result_gui.hpp        |   7 -
 src/states_screens/track_info_screen.cpp      |  38 +-
 src/states_screens/track_info_screen.hpp      |   3 +
 src/tracks/track.cpp                          |   4 +-
 src/utils/crash_reporting.cpp                 |   6 +-
 75 files changed, 1073 insertions(+), 1392 deletions(-)
 delete mode 100644 src/network/protocols/ranking.cpp
 delete mode 100644 src/network/protocols/ranking.hpp

diff --git a/data/gui/screens/track_info.stkgui b/data/gui/screens/track_info.stkgui
index 49093e9328b..f5290c22c2e 100644
--- a/data/gui/screens/track_info.stkgui
+++ b/data/gui/screens/track_info.stkgui
@@ -73,6 +73,16 @@
                         <label id="option-text" proportion="3" I18N="In the track info screen" text_align="left" align="center"/>
                     </div>
                    
+                    <div width="100%" height="fit" layout="horizontal-row" >
+                        <div proportion="1" height="fit" layout="horizontal-row">
+                            <div width="100%" height="fit" text-align="center" layout="vertical-row" >
+                                <checkbox id="tire-stealing" align="center"/>
+                            </div>
+                        </div>
+                        <spacer width="3%"/>
+                        <label id="tire-stealing-text" proportion="3" I18N="In the track info screen" text_align="left" align="center"/>
+                    </div>
+
                     <spacer width="1" height="1%"/>
                     
                     <div width="100%" height="fit" layout="horizontal-row" >
diff --git a/src/audio/music.hpp b/src/audio/music.hpp
index 120b46f42b1..a848fb6e50f 100644
--- a/src/audio/music.hpp
+++ b/src/audio/music.hpp
@@ -35,6 +35,7 @@ class Music : public NoCopy
     virtual bool pauseMusic  ()                            = 0;
     virtual bool resumeMusic ()                            = 0;
     virtual void setVolume   (float volume)                = 0;
+    virtual void updateFaster(float percent, float pitch)  = 0;
     virtual void update      ()                            = 0;
     virtual bool isPlaying   ()                            = 0;
 
diff --git a/src/audio/music_information.cpp b/src/audio/music_information.cpp
index 511768b4be6..e211664d4ff 100644
--- a/src/audio/music_information.cpp
+++ b/src/audio/music_information.cpp
@@ -84,7 +84,8 @@ MusicInformation::MusicInformation(const XMLNode *root,
     m_fast_loop_end     = -1.0f;
     m_enable_fast       = false;
     m_music_waiting     = false;
-    m_faster_time       = 1.5f;
+    m_faster_time       = 1.0f;
+    m_max_pitch         = 0.1f;
     m_gain              = 1.0f;
 
 
@@ -106,8 +107,6 @@ MusicInformation::MusicInformation(const XMLNode *root,
     root->get("fast-loop-start", &m_fast_loop_start  );
     root->get("fast-loop-end",   &m_fast_loop_end    );
 
-    m_temporary_volume = m_gain;
-
     // Get the path from the filename and add it to the ogg filename
     std::string path  = StringUtils::getPath(filename);
     m_normal_filename = path + "/" + m_normal_filename;
@@ -274,15 +273,31 @@ void MusicInformation::update(float dt)
         {
             m_mode=SOUND_FAST;
             m_normal_music->stopMusic();
-            m_fast_music->setVolume(m_temporary_volume);
             m_fast_music->update();
             return;
         }
         float fraction=m_time_since_faster/m_faster_time;
-        m_normal_music->setVolume(m_temporary_volume * (1-fraction));
-        m_fast_music->setVolume(m_temporary_volume * fraction);
+        m_normal_music->setVolume(1-fraction);
+        m_fast_music->setVolume(fraction);
         m_normal_music->update();
         m_fast_music->update();
+        break;
+                       }
+    case SOUND_FASTER: {
+        if ( m_normal_music == NULL ) break;
+
+        m_time_since_faster +=dt;
+        if(m_time_since_faster>=m_faster_time)
+        {
+            // Once the pitch is adjusted, just switch back to normal
+            // mode. We can't switch to fast music mode, since this would
+            // play m_fast_music, which isn't available.
+            m_mode=SOUND_NORMAL;
+            return;
+        }
+        float fraction=m_time_since_faster/m_faster_time;
+        m_normal_music->updateFaster(fraction, m_max_pitch);
+
         break;
                        }
     case SOUND_NORMAL:
@@ -339,7 +354,6 @@ void MusicInformation::resumeMusic()
 //-----------------------------------------------------------------------------
 void MusicInformation::setDefaultVolume()
 {
-    m_temporary_volume = m_gain;
     if (m_normal_music && m_normal_music->isPlaying())
         m_normal_music->setVolume(m_gain);
     if (m_fast_music && m_fast_music->isPlaying())
@@ -352,14 +366,11 @@ void MusicInformation::setDefaultVolume()
  */
 void MusicInformation::setTemporaryVolume(float volume)
 {
-    m_temporary_volume = m_gain * volume;
-    if (m_normal_music != NULL) m_normal_music->setVolume(m_temporary_volume);
-    if (m_fast_music   != NULL) m_fast_music->setVolume(m_temporary_volume);
+    if (m_normal_music != NULL) m_normal_music->setVolume(volume);
+    if (m_fast_music   != NULL) m_fast_music->setVolume(volume);
 }
 
 //-----------------------------------------------------------------------------
-/** If there is a fast music available, switch to it.
- *  */
 void MusicInformation::switchToFastMusic()
 {
     if(!m_enable_fast) return;
@@ -370,6 +381,11 @@ void MusicInformation::switchToFastMusic()
         m_fast_music->playMusic();
         m_fast_music->setVolume(0);
     }
+    else
+    {
+        // FIXME: for now this music is too annoying,
+        m_mode = SOUND_FASTER;
+    }
 }   // switchToFastMusic
 
 //-----------------------------------------------------------------------------
diff --git a/src/audio/music_information.hpp b/src/audio/music_information.hpp
index 183a9e2ef64..fd2406f3a9c 100644
--- a/src/audio/music_information.hpp
+++ b/src/audio/music_information.hpp
@@ -53,7 +53,8 @@ class MusicInformation : public NoCopy
      *  was told not to start right away). */
     bool                    m_music_waiting;
 
-    /** If faster music is enabled at all. */
+    /** If faster music is enabled at all (either separate file or using
+     *  the pitch shift approach). */
     bool                     m_enable_fast;
 
     float                    m_gain;
@@ -63,19 +64,18 @@ class MusicInformation : public NoCopy
     float                    m_normal_loop_end;
     float                    m_fast_loop_end;
 
-    /** Time for fading faster music in. */
+    /** Either time for fading faster music in, or time to change pitch. */
     float                    m_faster_time;
-
-    /* Avoid the temporary volume being forgotten */
-    float                    m_temporary_volume;
-
+    /** Maximum pitch for faster music. */
+    float                    m_max_pitch;
     static const int         LOOP_FOREVER=-1;
     mutable std::mutex       m_music_mutex;
     Music                   *m_normal_music,
                             *m_fast_music;
     enum {SOUND_NORMAL,     //!< normal music is played
           SOUND_FADING,     //!< normal music fading out, faster fading in
-          SOUND_FAST}       //!< playing faster music
+          SOUND_FASTER,     //!< change pitch of normal music
+          SOUND_FAST}       //!< playing faster music or max pitch reached
                              m_mode;
     float                    m_time_since_faster;
 
@@ -127,6 +127,8 @@ class MusicInformation : public NoCopy
     // ------------------------------------------------------------------------
     /** If available, returns the file name of the faster/last-lap music. */
     const std::string& getFastFilename() const { return m_fast_filename; }
+    // ------------------------------------------------------------------------
+    float getMaxPitch() const { return m_max_pitch; }
 
 };   // MusicInformation
 #endif
diff --git a/src/audio/music_ogg.cpp b/src/audio/music_ogg.cpp
index 72db0e122b8..8b8c421d6b8 100644
--- a/src/audio/music_ogg.cpp
+++ b/src/audio/music_ogg.cpp
@@ -35,7 +35,6 @@ MusicOggStream::MusicOggStream(float loop_start, float loop_end)
     m_soundSource     = -1;
     m_pausedMusic     = true;
     m_playing.store(false);
-    m_play_initialized.store(false);
     m_loop_start      = loop_start;
     m_loop_end        = loop_end;
 }   // MusicOggStream
@@ -167,7 +166,6 @@ bool MusicOggStream::release()
 
     m_soundSource = -1;
     m_playing.store(false);
-    m_play_initialized.store(false);
 
     return true;
 }   // release
@@ -189,7 +187,6 @@ bool MusicOggStream::playMusic()
     alSourcePlay(m_soundSource);
     m_pausedMusic = false;
     m_playing.store(true);
-    m_play_initialized.store(true);
     check("playMusic");
     return true;
 }   // playMusic
@@ -198,6 +195,15 @@ bool MusicOggStream::playMusic()
 bool MusicOggStream::isPlaying()
 {
     return m_playing.load();
+
+    /*
+    if (m_soundSource == -1) return false;
+
+    ALenum state;
+    alGetSourcei(m_soundSource, AL_SOURCE_STATE, &state);
+
+    return (state == AL_PLAYING);
+     */
 }   // isPlaying
 
 //-----------------------------------------------------------------------------
@@ -231,8 +237,7 @@ bool MusicOggStream::resumeMusic()
         return true;
     }
 
-    if(m_play_initialized.load()) // Avoid #5204
-        m_playing.store(true);
+    m_playing.store(true);
 
     alSourcePlay(m_soundSource);
     m_pausedMusic= false;
@@ -250,6 +255,13 @@ void MusicOggStream::setVolume(float volume)
     check("volume music");   // clear errors
 }   // setVolume
 
+//-----------------------------------------------------------------------------
+void MusicOggStream::updateFaster(float percent, float max_pitch)
+{
+    alSourcef(m_soundSource,AL_PITCH,1+max_pitch*percent);
+    update();
+}   // updateFaster
+
 //-----------------------------------------------------------------------------
 void MusicOggStream::update()
 {
diff --git a/src/audio/music_ogg.hpp b/src/audio/music_ogg.hpp
index 7f7a80a7c25..37c2c352c1e 100644
--- a/src/audio/music_ogg.hpp
+++ b/src/audio/music_ogg.hpp
@@ -49,6 +49,7 @@ class MusicOggStream : public Music
     virtual ~MusicOggStream();
 
     virtual void update();
+    virtual void updateFaster(float percent, float max_pitch);
 
     virtual bool load(const std::string& filename);
 
@@ -77,7 +78,6 @@ class MusicOggStream : public Music
     bool            m_error;
 
     std::atomic_bool m_playing;
-    std::atomic_bool m_play_initialized;
 
     ALuint m_soundBuffers[2];
     ALuint m_soundSource;
diff --git a/src/audio/sfx_manager.cpp b/src/audio/sfx_manager.cpp
index ce6b6623640..66aeb38b69f 100644
--- a/src/audio/sfx_manager.cpp
+++ b/src/audio/sfx_manager.cpp
@@ -438,7 +438,7 @@ void SFXManager::mainLoop(void *obj)
             current->m_music_information->pauseMusic();           break;
         case SFX_MUSIC_RESUME:
             current->m_music_information->resumeMusic();
-            // This might be necessary if the volume was changed
+            // This might be necessasary if the volume was changed
             // in the in-game menu
             current->m_music_information->setDefaultVolume();     break;
         case SFX_MUSIC_SWITCH_FAST:
diff --git a/src/config/favorite_status.cpp b/src/config/favorite_status.cpp
index 968e506d94c..85240cb2027 100644
--- a/src/config/favorite_status.cpp
+++ b/src/config/favorite_status.cpp
@@ -61,6 +61,12 @@ FavoriteStatus::FavoriteStatus(const XMLNode* node, std::string parse_type)
     }
 }   // FavoriteStatus
 
+//------------------------------------------------------------------------------
+FavoriteStatus::~FavoriteStatus()
+{
+
+}   // ~FavoriteStatus
+
 //------------------------------------------------------------------------------
 /** Adds a new favorite track to this player profile and to the group
  * of favorite tracks of the Track Manager.
diff --git a/src/config/favorite_status.hpp b/src/config/favorite_status.hpp
index cde113b1bc9..522ae3dd550 100644
--- a/src/config/favorite_status.hpp
+++ b/src/config/favorite_status.hpp
@@ -55,6 +55,8 @@ class FavoriteStatus
     /** Parse all <(parse_type)/> in <favorite> in xml node */
     FavoriteStatus(const XMLNode *node, std::string parse_type);
 
+    virtual ~FavoriteStatus();
+
     void save(UTFWriter &out);
 
     bool isFavorite(std::string ident);
diff --git a/src/config/player_profile.cpp b/src/config/player_profile.cpp
index 8a4a8ee13a2..e2d1aa9f739 100644
--- a/src/config/player_profile.cpp
+++ b/src/config/player_profile.cpp
@@ -105,22 +105,9 @@ PlayerProfile::PlayerProfile(const XMLNode* node)
 //------------------------------------------------------------------------------
 PlayerProfile::~PlayerProfile()
 {
-    if (m_story_mode_status)
-    {
-        delete m_story_mode_status;
-    }
-    if (m_achievements_status)
-    {
-        delete m_achievements_status;
-    }
-    if (m_favorite_track_status)
-    {
-        delete m_favorite_track_status;
-    }
-    if (m_favorite_kart_status)
-    {
-        delete m_favorite_kart_status;
-    }
+    delete m_story_mode_status;
+    delete m_achievements_status;
+    delete m_favorite_track_status;
 #ifdef DEBUG
     m_magic_number = 0xDEADBEEF;
 #endif
diff --git a/src/config/saved_grand_prix.hpp b/src/config/saved_grand_prix.hpp
index 8d12d7d26a8..a5c8eb70433 100644
--- a/src/config/saved_grand_prix.hpp
+++ b/src/config/saved_grand_prix.hpp
@@ -158,6 +158,10 @@ class SavedGrandPrix
     /** Returns time target used in Lap Trial mode */
     float getTimeTarget() const { return m_time_target; }
 
+    // ------------------------------------------------------------------------
+    /** Returns total laps in GP */
+    int getPlayerTotalLaps() const { return m_player_total_laps; }
+
     // ------------------------------------------------------------------------
     /** Sets the index of the last track finished. */
     void setNextTrack(int next_track) { m_next_track = next_track; }
diff --git a/src/config/user_config.hpp b/src/config/user_config.hpp
index e61441e8207..b08990f36b3 100644
--- a/src/config/user_config.hpp
+++ b/src/config/user_config.hpp
@@ -457,6 +457,9 @@ namespace UserConfigParams
     PARAM_PREFIX BoolUserConfigParam         m_use_ffa_mode
         PARAM_DEFAULT(BoolUserConfigParam(false, "use-ffa-mode",
             &m_race_setup_group, "Use ffa mode instead of 3 strikes battle."));
+    PARAM_PREFIX BoolUserConfigParam         m_tire_steal
+        PARAM_DEFAULT(BoolUserConfigParam(false, "tire-steal",
+            &m_race_setup_group, "Steal the tire when you hit a kart."));
     PARAM_PREFIX IntUserConfigParam          m_lap_trial_time_limit
         PARAM_DEFAULT(IntUserConfigParam(3, "lap-trial-time-limit",
             &m_race_setup_group, "Time limit in lap trial mode."));
@@ -834,10 +837,6 @@ namespace UserConfigParams
 
     PARAM_PREFIX bool m_race_now          PARAM_DEFAULT( false );
 
-    PARAM_PREFIX int m_default_keyboard   PARAM_DEFAULT( -1 );
-
-    PARAM_PREFIX int m_default_gamepad    PARAM_DEFAULT( -1 );
-
     PARAM_PREFIX bool m_enforce_current_player PARAM_DEFAULT( false );
 
     PARAM_PREFIX bool m_enable_sound PARAM_DEFAULT( true );
@@ -1037,12 +1036,12 @@ namespace UserConfigParams
                         "Camera settings for player.") );
 
     PARAM_PREFIX FloatUserConfigParam         m_camera_distance
-            PARAM_DEFAULT(  FloatUserConfigParam(2.8, "distance",
+            PARAM_DEFAULT(  FloatUserConfigParam(1.0, "distance",
             &m_camera_normal,
             "Distance between kart and camera"));
 
     PARAM_PREFIX FloatUserConfigParam         m_camera_forward_up_angle
-            PARAM_DEFAULT(  FloatUserConfigParam(25, "forward-up-angle",
+            PARAM_DEFAULT(  FloatUserConfigParam(0, "forward-up-angle",
             &m_camera_normal,
             "Angle between camera and plane of kart (pitch) when the camera is pointing forward"));
 
@@ -1062,7 +1061,7 @@ namespace UserConfigParams
             "Angle between camera and plane of kart (pitch) when the camera is pointing backwards. This is usually larger than the forward-up-angle, since the kart itself otherwise obstricts too much of the view"));
 
     PARAM_PREFIX IntUserConfigParam         m_camera_fov
-            PARAM_DEFAULT(  IntUserConfigParam(85, "fov",
+            PARAM_DEFAULT(  IntUserConfigParam(80, "fov",
             &m_camera_normal,
             "Focal distance (single player)"));
 
@@ -1076,22 +1075,18 @@ namespace UserConfigParams
                             "The current used camera. 0=Custom; 1=Standard; 2=Drone chase") );
 
     // ---- Standard camera settings
-    PARAM_PREFIX BoolUserConfigParam       m_camera_updated_one_five
-            PARAM_DEFAULT(  BoolUserConfigParam(false, "camera-updated-one-five",
-                            "Used to update the standard camera values for users upgrading to 1.5") );
-
     PARAM_PREFIX GroupUserConfigParam        m_standard_camera_settings
             PARAM_DEFAULT( GroupUserConfigParam(
                         "standard-camera-settings",
                         "Standard camera settings for player.") );
 
     PARAM_PREFIX FloatUserConfigParam         m_standard_camera_distance
-            PARAM_DEFAULT(  FloatUserConfigParam(2.8, "distance",
+            PARAM_DEFAULT(  FloatUserConfigParam(1.0, "distance",
             &m_standard_camera_settings,
             "Distance between kart and camera"));
 
     PARAM_PREFIX FloatUserConfigParam         m_standard_camera_forward_up_angle
-            PARAM_DEFAULT(  FloatUserConfigParam(25, "forward-up-angle",
+            PARAM_DEFAULT(  FloatUserConfigParam(0, "forward-up-angle",
             &m_standard_camera_settings,
             "Angle between camera and plane of kart (pitch) when the camera is pointing forward"));
 
@@ -1111,7 +1106,7 @@ namespace UserConfigParams
             "Angle between camera and plane of kart (pitch) when the camera is pointing backwards. This is usually larger than the forward-up-angle, since the kart itself otherwise obstricts too much of the view"));
 
     PARAM_PREFIX IntUserConfigParam         m_standard_camera_fov
-            PARAM_DEFAULT(  IntUserConfigParam(85, "fov",
+            PARAM_DEFAULT(  IntUserConfigParam(80, "fov",
             &m_standard_camera_settings,
             "Focal distance (single player)"));
 
@@ -1168,12 +1163,12 @@ namespace UserConfigParams
                         "Saved custom camera settings for player.") );
 
     PARAM_PREFIX FloatUserConfigParam         m_saved_camera_distance
-            PARAM_DEFAULT(  FloatUserConfigParam(2.8, "distance",
+            PARAM_DEFAULT(  FloatUserConfigParam(1.0, "distance",
             &m_saved_camera_settings,
             "Distance between kart and camera"));
 
     PARAM_PREFIX FloatUserConfigParam         m_saved_camera_forward_up_angle
-            PARAM_DEFAULT(  FloatUserConfigParam(25, "forward-up-angle",
+            PARAM_DEFAULT(  FloatUserConfigParam(0, "forward-up-angle",
             &m_saved_camera_settings,
             "Angle between camera and plane of kart (pitch) when the camera is pointing forward"));
 
@@ -1193,7 +1188,7 @@ namespace UserConfigParams
             "Angle between camera and plane of kart (pitch) when the camera is pointing backwards. This is usually larger than the forward-up-angle, since the kart itself otherwise obstricts too much of the view"));
 
     PARAM_PREFIX IntUserConfigParam         m_saved_camera_fov
-            PARAM_DEFAULT(  IntUserConfigParam(85, "fov",
+            PARAM_DEFAULT(  IntUserConfigParam(80, "fov",
             &m_saved_camera_settings,
             "Focal distance (single player)"));
 
diff --git a/src/graphics/camera/camera.hpp b/src/graphics/camera/camera.hpp
index 06372528dbe..753b5af1b59 100644
--- a/src/graphics/camera/camera.hpp
+++ b/src/graphics/camera/camera.hpp
@@ -185,8 +185,6 @@ class Camera : public NoCopy
     /** Returns the type of this camera. */
     CameraType getType() { return m_type; }
     // ------------------------------------------------------------------------
-    bool isNormal() { return (m_type == CM_TYPE_NORMAL); }
-    // ------------------------------------------------------------------------
     /** Sets the field of view for the irrlicht camera. */
     void setFoV() { m_camera->setFOV(m_fov); }
     // ------------------------------------------------------------------------
diff --git a/src/graphics/camera/camera_normal.cpp b/src/graphics/camera/camera_normal.cpp
index 7ba5353afbb..a1056985074 100644
--- a/src/graphics/camera/camera_normal.cpp
+++ b/src/graphics/camera/camera_normal.cpp
@@ -31,7 +31,6 @@
 #include "karts/kart.hpp"
 #include "karts/kart_properties.hpp"
 #include "karts/skidding.hpp"
-#include "network/rewind_manager.hpp"
 #include "tracks/track.hpp"
 
 // ============================================================================
@@ -82,8 +81,6 @@ void CameraNormal::moveCamera(float dt, bool smooth, float cam_angle, float dist
 {
     if(!m_kart) return;
 
-    if (RewindManager::get()->isRewinding()) return;
-
     Kart *kart = dynamic_cast<Kart*>(m_kart);
     if (kart->isFlying())
     {
@@ -105,34 +102,23 @@ void CameraNormal::moveCamera(float dt, bool smooth, float cam_angle, float dist
     float skid_factor = ks->getVisualSkidRotation();
 
     float skid_angle = asinf(skid_factor);
-
-    // Adjust the distance of the camera to the kart with speed
-    // Note that distance is negative (< 0)
     float ratio = current_speed / max_speed_without_zipper;
+
     ratio = ratio > -0.12f ? ratio : -0.12f;
-    float speed_factor = ((distance - 2.0f) - 1.0f * ratio) / (distance - 2.0f);
-    float camera_distance = distance * speed_factor;
 
-    // Adjust the camera angle
+    // distance of camera from kart in x and z plane
+    float camera_distance = -1.25f - 2.5f * ratio;
+    float min_distance = (distance * 2.0f);
+    if (distance > 0) camera_distance += distance + 1; // note that distance < 0
+    if (camera_distance > min_distance) camera_distance = min_distance; // don't get too close to the kart
+
     float tan_up = 0;
-    if (cam_angle > 0) tan_up = tanf(cam_angle) * std::max(distance - 1.0f, distance * (1.0f + 0.25f * ratio));
-    // Avoid a camera razing the ground (it generates a lot of terrain clipping with the current near value of 1.0)
-    if (tan_up > -0.5f)
-        tan_up = -0.5f;
-
-    // Defines how far the camera should be from the player's kart.
-    float squared_x = distance * sinf(skid_angle / 2);
-    squared_x *= squared_x;
-    float squared_y = tan_up;
-    squared_y *= squared_y;
-    float squared_z = distance * cosf(skid_angle / 2);
-    squared_z *= squared_z;
-    float length = sqrt(squared_x + squared_y + squared_z);
-    float camera_distance_factor = -camera_distance * camera_distance / length;
-
-    Vec3 wanted_camera_offset(camera_distance_factor * sinf(skid_angle / 2),
-        -tan_up,
-        camera_distance_factor * cosf(skid_angle / 2));
+    if (cam_angle > 0) tan_up = tanf(cam_angle) * distance;
+
+    // Defines how far camera should be from player kart.
+    Vec3 wanted_camera_offset(camera_distance * sinf(skid_angle / 2),
+        (0.85f + ratio / 2.5f) - tan_up,
+        camera_distance * cosf(skid_angle / 2));
 
     float delta = 1;
     float delta2 = 1;
@@ -191,8 +177,7 @@ void CameraNormal::moveCamera(float dt, bool smooth, float cam_angle, float dist
 //-----------------------------------------------------------------------------
 void CameraNormal::snapToPosition()
 {
-    float angle = UserConfigParams::m_camera_forward_up_angle * DEGREE_TO_RAD;
-    moveCamera(1.0f, false, angle, -m_distance);
+    moveCamera(1.0f, false, 0, 0);
 }   // snapToPosition
 
 //-----------------------------------------------------------------------------
@@ -207,22 +192,6 @@ void CameraNormal::getCameraSettings(float *above_kart, float *cam_angle,
                                      float *sideway, float *distance,
                                      bool *smoothing, float *cam_roll_angle)
 {
-    // Update the standard camera for users updating to 1.5
-    if(!UserConfigParams::m_camera_updated_one_five)
-    {
-        UserConfigParams::m_standard_camera_fov.revertToDefaults();
-        UserConfigParams::m_standard_camera_distance.revertToDefaults();
-        UserConfigParams::m_standard_camera_forward_up_angle.revertToDefaults();
-        if (UserConfigParams::m_camera_present == 1) // Currently using a standard camera 
-        {
-            UserConfigParams::m_camera_fov.revertToDefaults();
-            UserConfigParams::m_camera_distance.revertToDefaults();
-            UserConfigParams::m_camera_forward_up_angle.revertToDefaults();
-            m_distance = UserConfigParams::m_camera_distance;
-        }
-        UserConfigParams::m_camera_updated_one_five = true;
-    }
-
     switch(getMode())
     {
     case CM_NORMAL:
diff --git a/src/graphics/irr_driver.cpp b/src/graphics/irr_driver.cpp
index 5b598c4f674..da4fc1aea84 100644
--- a/src/graphics/irr_driver.cpp
+++ b/src/graphics/irr_driver.cpp
@@ -803,7 +803,7 @@ void IrrDriver::initDevice()
 
     if (UserConfigParams::m_shadows_resolution != 0 &&
         (UserConfigParams::m_shadows_resolution < 512 ||
-         UserConfigParams::m_shadows_resolution > 4096))
+         UserConfigParams::m_shadows_resolution > 2048))
     {
         Log::warn("irr_driver",
                "Invalid value for UserConfigParams::m_shadows_resolution : %i",
diff --git a/src/graphics/lighting_passes.cpp b/src/graphics/lighting_passes.cpp
index 76459bb8954..d30c6cf4c7e 100644
--- a/src/graphics/lighting_passes.cpp
+++ b/src/graphics/lighting_passes.cpp
@@ -170,7 +170,7 @@ class PointLightScatterShader : public TextureShader<PointLightScatterShader,
 };
 
 // ============================================================================
-class IBLShader : public TextureShader<IBLShader, 6>
+class IBLShader : public TextureShader<IBLShader, 4>
 {
 public:
     IBLShader()
@@ -181,14 +181,12 @@ class IBLShader : public TextureShader<IBLShader, 6>
         assignSamplerNames(0, "ntex",  ST_NEAREST_FILTERED,
                            1, "dtex",  ST_NEAREST_FILTERED,
                            2, "probe", ST_TRILINEAR_CUBEMAP,
-                           3, "albedo",ST_NEAREST_FILTERED,
-                           4, "ssao",  ST_NEAREST_FILTERED,
-                           5, "ctex",  ST_NEAREST_FILTERED);
+                           3, "albedo",ST_NEAREST_FILTERED);
     }   // IBLShader
 };   // IBLShader
 
 // ============================================================================
-class DegradedIBLShader : public TextureShader<DegradedIBLShader, 2>
+class DegradedIBLShader : public TextureShader<DegradedIBLShader, 1>
 {
 public:
     DegradedIBLShader()
@@ -196,8 +194,7 @@ class DegradedIBLShader : public TextureShader<DegradedIBLShader, 2>
         loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "degraded_ibl.frag");
         assignUniforms();
-        assignSamplerNames(0, "ntex", ST_NEAREST_FILTERED,
-                           1, "ssao", ST_NEAREST_FILTERED);
+        assignSamplerNames(0, "ntex", ST_NEAREST_FILTERED);
     }   // DegradedIBLShader
 };   // DegradedIBLShader
 
@@ -301,9 +298,7 @@ static void renderPointLights(unsigned count,
 void LightingPasses::renderEnvMap(GLuint normal_depth_texture,
                                   GLuint depth_stencil_texture,
                                   GLuint specular_probe,
-                                  GLuint albedo_buffer,
-                                  GLuint ssao_texture,
-                                  GLuint diffuse_color_texture)
+                                  GLuint albedo_buffer)
 {
     glDisable(GL_DEPTH_TEST);
     glEnable(GL_BLEND);
@@ -316,7 +311,7 @@ void LightingPasses::renderEnvMap(GLuint normal_depth_texture,
         glBindVertexArray(SharedGPUObjects::getFullScreenQuadVAO());
 
         DegradedIBLShader::getInstance()
-            ->setTextureUnits(normal_depth_texture, ssao_texture);
+            ->setTextureUnits(normal_depth_texture);
         DegradedIBLShader::getInstance()->setUniforms();
     }
     else
@@ -328,9 +323,7 @@ void LightingPasses::renderEnvMap(GLuint normal_depth_texture,
             normal_depth_texture,
             depth_stencil_texture,
             specular_probe,
-            albedo_buffer,
-            ssao_texture,
-            diffuse_color_texture);
+            albedo_buffer);
         IBLShader::getInstance()->setUniforms();
     }
 
@@ -441,8 +434,6 @@ void LightingPasses::renderLights(  bool has_shadow,
                                     GLuint depth_stencil_texture,
                                     GLuint albedo_texture,
                                     const FrameBuffer* shadow_framebuffer,
-                                    GLuint ssao_texture,
-                                    GLuint diffuse_color_texture,
                                     GLuint specular_probe)
 {
     {
@@ -450,9 +441,7 @@ void LightingPasses::renderLights(  bool has_shadow,
         renderEnvMap(normal_depth_texture,
                      depth_stencil_texture,
                      specular_probe,
-                     albedo_texture,
-                     ssao_texture,
-                     diffuse_color_texture);
+                     albedo_texture);
     }
 
     // Render sunlight if and only if track supports shadow
diff --git a/src/graphics/lighting_passes.hpp b/src/graphics/lighting_passes.hpp
index aef150a52bc..2655a4f50d8 100644
--- a/src/graphics/lighting_passes.hpp
+++ b/src/graphics/lighting_passes.hpp
@@ -47,9 +47,7 @@ class LightingPasses
     void renderEnvMap(GLuint normal_depth_texture,
                       GLuint depth_stencil_texture,
                       GLuint specular_probe,
-                      GLuint albedo_buffer,
-                      GLuint ssao_buffer,
-                      GLuint diffuse_color_texture);
+                      GLuint albedo_buffer);
 
     /** Generate diffuse and specular map */
     void         renderSunlight(const core::vector3df &direction,
@@ -67,8 +65,6 @@ class LightingPasses
                         GLuint depth_stencil_texture,
                         GLuint albedo_texture,
                         const FrameBuffer* shadow_framebuffer,
-                        GLuint ssao_texture,
-                        GLuint diffuse_color_texture,
                         GLuint specular_probe);
     void renderLightsScatter(GLuint depth_stencil_texture,
                              const FrameBuffer& half1_framebuffer,
diff --git a/src/graphics/post_processing.cpp b/src/graphics/post_processing.cpp
index 98b2f6831b4..092dfeaf1e7 100644
--- a/src/graphics/post_processing.cpp
+++ b/src/graphics/post_processing.cpp
@@ -181,18 +181,18 @@ class Gaussian6HBlurShader : public TextureShader<Gaussian6HBlurShader, 1,
 };   // Gaussian6HBlurShader
 
 // ============================================================================
-class Gaussian9TapHShader : public TextureShader<Gaussian9TapHShader, 2,
+class Gaussian17TapHShader : public TextureShader<Gaussian17TapHShader, 2,
                                            core::vector2df>
 {
 public:
-    Gaussian9TapHShader()
+    Gaussian17TapHShader()
     {
         loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "bilateralH.frag");
         assignUniforms("pixel");
         assignSamplerNames(0, "tex", ST_BILINEAR_CLAMPED_FILTERED,
                            1, "depth", ST_BILINEAR_CLAMPED_FILTERED);
-    }   // Gaussian9TapHShader
+    }   // Gaussian17TapHShader
     // ------------------------------------------------------------------------
     void render(const FrameBuffer &fb, const FrameBuffer &linear_depth,
                 int width, int height)
@@ -202,15 +202,15 @@ class Gaussian9TapHShader : public TextureShader<Gaussian9TapHShader, 2,
         drawFullScreenEffect(core::vector2df(1.0f/width, 1.0f/height));
 
     }   // render
-};   // Gaussian9TapHShader
+};   // Gaussian17TapHShader
 
 // ============================================================================
-class ComputeGaussian9TapHShader : public TextureShader<ComputeGaussian9TapHShader, 2,
+class ComputeGaussian17TapHShader : public TextureShader<ComputeGaussian17TapHShader, 2,
                                                   core::vector2df>
 {
 public:
     GLuint m_dest_tu;
-    ComputeGaussian9TapHShader()
+    ComputeGaussian17TapHShader()
     {
 #if !defined(USE_GLES2)
         loadProgram(OBJECT,  GL_COMPUTE_SHADER, "bilateralH.comp");
@@ -220,7 +220,7 @@ class ComputeGaussian9TapHShader : public TextureShader<ComputeGaussian9TapHShad
                            1, "depth", ST_NEARED_CLAMPED_FILTERED);
         assignTextureUnit(m_dest_tu, "dest");
 #endif
-    }   // ComputeGaussian9TapHShader
+    }   // ComputeGaussian17TapHShader
     // ------------------------------------------------------------------------
     void render(const FrameBuffer &fb, const FrameBuffer &auxiliary,
                 const FrameBuffer &linear_depth,
@@ -234,18 +234,18 @@ class ComputeGaussian9TapHShader : public TextureShader<ComputeGaussian9TapHShad
         glBindImageTexture(m_dest_tu, auxiliary.getRTT()[0], 0, false,
                            0, GL_WRITE_ONLY, GL_R16F);
         setUniforms(core::vector2df(1.0f/width, 1.0f/height));
-        glDispatchCompute((int)width / 4 + 1, (int)height / 4 + 1, 1);
+        glDispatchCompute((int)width / 8 + 1, (int)height / 8 + 1, 1);
 #endif
     }   // render
-};   // ComputeGaussian9TapHShader
+};   // ComputeGaussian17TapHShader
 
 
 // ============================================================================
-class Gaussian9TapVShader : public TextureShader<Gaussian9TapVShader, 2,
+class Gaussian17TapVShader : public TextureShader<Gaussian17TapVShader, 2,
                                            core::vector2df>
 {
 public:
-    Gaussian9TapVShader()
+    Gaussian17TapVShader()
     {
         loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "bilateralV.frag");
@@ -253,7 +253,7 @@ class Gaussian9TapVShader : public TextureShader<Gaussian9TapVShader, 2,
 
         assignSamplerNames(0, "tex", ST_BILINEAR_CLAMPED_FILTERED,
                            1, "depth", ST_BILINEAR_CLAMPED_FILTERED);
-    }   // Gaussian9TapVShader
+    }   // Gaussian17TapVShader
     // ------------------------------------------------------------------------
     void render(const FrameBuffer &auxiliary, const FrameBuffer &linear_depth,
                 int width, int height)
@@ -263,16 +263,16 @@ class Gaussian9TapVShader : public TextureShader<Gaussian9TapVShader, 2,
         drawFullScreenEffect(core::vector2df(1.0f/width, 1.0f/height));
 
     }   // render
-};   // Gaussian9TapVShader
+};   // Gaussian17TapVShader
 
 // ============================================================================
-class ComputeGaussian9TapVShader : public TextureShader<ComputeGaussian9TapVShader, 2,
+class ComputeGaussian17TapVShader : public TextureShader<ComputeGaussian17TapVShader, 2,
                                                   core::vector2df>
 {
 public:
     GLuint m_dest_tu;
 
-    ComputeGaussian9TapVShader()
+    ComputeGaussian17TapVShader()
     {
 #if !defined(USE_GLES2)
         loadProgram(OBJECT, GL_COMPUTE_SHADER, "bilateralV.comp");
@@ -282,7 +282,7 @@ class ComputeGaussian9TapVShader : public TextureShader<ComputeGaussian9TapVShad
                            1, "depth", ST_NEARED_CLAMPED_FILTERED);
         assignTextureUnit(m_dest_tu, "dest");
 #endif
-    }   // ComputeGaussian9TapVShader
+    }   // ComputeGaussian17TapVShader
     // ------------------------------------------------------------------------
     void render(const FrameBuffer &auxiliary, const FrameBuffer &fb,
                 const FrameBuffer &linear_depth,
@@ -297,11 +297,11 @@ class ComputeGaussian9TapVShader : public TextureShader<ComputeGaussian9TapVShad
         glBindImageTexture(m_dest_tu, fb.getRTT()[0], 0, false, 0,
                            GL_WRITE_ONLY, GL_R16F);
         setUniforms(core::vector2df(1.0f/width, 1.0f/height));
-        glDispatchCompute((int)fb.getWidth()  / 4 + 1,
-                          (int)fb.getHeight() / 4 + 1, 1);
+        glDispatchCompute((int)fb.getWidth()  / 8 + 1,
+                          (int)fb.getHeight() / 8 + 1, 1);
 #endif
     }   // render
-};   // ComputeGaussian9TapVShader
+};   // ComputeGaussian17TapVShader
 
 // ============================================================================
 class BloomShader : public TextureShader<BloomShader, 1, float>
@@ -896,13 +896,13 @@ void PostProcessing::renderHorizontalBlur(const FrameBuffer &in_fbo,
 
 
 // ----------------------------------------------------------------------------
-void PostProcessing::renderGaussian9TapBlur(const FrameBuffer &in_fbo,
+void PostProcessing::renderGaussian17TapBlur(const FrameBuffer &in_fbo,
                                              const FrameBuffer &auxiliary,
                                              const FrameBuffer &linear_depth) const
 {
     assert(in_fbo.getWidth() == auxiliary.getWidth() &&
            in_fbo.getHeight() == auxiliary.getHeight());
-     
+           
 #if !defined(USE_GLES2)
     if (CVS->supportsComputeShadersFiltering())
         glMemoryBarrier(GL_FRAMEBUFFER_BARRIER_BIT);
@@ -912,14 +912,14 @@ void PostProcessing::renderGaussian9TapBlur(const FrameBuffer &in_fbo,
         if (!CVS->supportsComputeShadersFiltering())
         {
             auxiliary.bind();
-            Gaussian9TapHShader::getInstance()->render(in_fbo,
+            Gaussian17TapHShader::getInstance()->render(in_fbo,
                                                         linear_depth,
                                                         in_fbo.getWidth(),
                                                         in_fbo.getHeight());
         }
         else
         {
-            ComputeGaussian9TapHShader::getInstance()->render(in_fbo,
+            ComputeGaussian17TapHShader::getInstance()->render(in_fbo,
                                                                auxiliary,
                                                                linear_depth,
                                                                in_fbo.getWidth(),
@@ -936,14 +936,14 @@ void PostProcessing::renderGaussian9TapBlur(const FrameBuffer &in_fbo,
         if (!CVS->supportsComputeShadersFiltering())
         {
             in_fbo.bind();
-            Gaussian9TapVShader::getInstance()->render(auxiliary,
+            Gaussian17TapVShader::getInstance()->render(auxiliary,
                                                         linear_depth,
                                                         in_fbo.getWidth(),
                                                         in_fbo.getHeight());
         }
         else
         {
-            ComputeGaussian9TapVShader::getInstance()->render(auxiliary,
+            ComputeGaussian17TapVShader::getInstance()->render(auxiliary,
                                                                in_fbo, 
                                                                linear_depth,
                                                                in_fbo.getWidth(),
@@ -955,7 +955,7 @@ void PostProcessing::renderGaussian9TapBlur(const FrameBuffer &in_fbo,
     if (CVS->supportsComputeShadersFiltering())
         glMemoryBarrier(GL_TEXTURE_FETCH_BARRIER_BIT);
 #endif
-}   // renderGaussian9TapBlur
+}   // renderGaussian17TapBlur
 
 // ----------------------------------------------------------------------------
 void PostProcessing::renderPassThrough(GLuint tex, unsigned width,
diff --git a/src/graphics/post_processing.hpp b/src/graphics/post_processing.hpp
index 264d6540f5c..fa2fc4cbd37 100644
--- a/src/graphics/post_processing.hpp
+++ b/src/graphics/post_processing.hpp
@@ -65,7 +65,7 @@ class PostProcessing
                               float sigmaV, float sigmaH) const;
 	void renderHorizontalBlur(const FrameBuffer &in_fbo, const FrameBuffer &auxiliary) const;
 
-    void renderGaussian9TapBlur(const FrameBuffer &in_fbo,
+    void renderGaussian17TapBlur(const FrameBuffer &in_fbo,
                                  const FrameBuffer &auxiliary,
                                  const FrameBuffer &linear_depth) const;
 
diff --git a/src/graphics/shader_based_renderer.cpp b/src/graphics/shader_based_renderer.cpp
index 6f1f17e7c8c..943b8348fff 100644
--- a/src/graphics/shader_based_renderer.cpp
+++ b/src/graphics/shader_based_renderer.cpp
@@ -138,7 +138,7 @@ void ShaderBasedRenderer::renderSSAO() const
     FrameBuffer::blit(m_rtts->getFBO(FBO_SSAO),
                       m_rtts->getFBO(FBO_HALF1_R), 
                       GL_COLOR_BUFFER_BIT, GL_LINEAR);
-    m_post_processing->renderGaussian9TapBlur(m_rtts->getFBO(FBO_HALF1_R), 
+    m_post_processing->renderGaussian17TapBlur(m_rtts->getFBO(FBO_HALF1_R), 
                                                m_rtts->getFBO(FBO_HALF2_R),
                                                m_rtts->getFBO(FBO_LINEAR_DEPTH));
 
@@ -195,7 +195,7 @@ void ShaderBasedRenderer::renderShadows()
 }
 
 // ============================================================================
-class CombineDiffuseColor : public TextureShader<CombineDiffuseColor, 6,
+class CombineDiffuseColor : public TextureShader<CombineDiffuseColor, 7,
                                                  std::array<float, 4> >
 {
 public:
@@ -206,16 +206,17 @@ class CombineDiffuseColor : public TextureShader<CombineDiffuseColor, 6,
         assignUniforms("bg_color");
         assignSamplerNames(0, "diffuse_map", ST_NEAREST_FILTERED,
                            1, "specular_map", ST_NEAREST_FILTERED,
-                           2, "normal_color", ST_NEAREST_FILTERED,
-                           3, "diffuse_color", ST_NEAREST_FILTERED,
-                           4, "depth_stencil", ST_NEAREST_FILTERED,
-                           5, "light_scatter", ST_NEAREST_FILTERED);
+                           2, "ssao_tex", ST_NEAREST_FILTERED,
+                           3, "normal_color", ST_NEAREST_FILTERED,
+                           4, "diffuse_color", ST_NEAREST_FILTERED,
+                           5, "depth_stencil", ST_NEAREST_FILTERED,
+                           6, "light_scatter", ST_NEAREST_FILTERED);
     }   // CombineDiffuseColor
     // ------------------------------------------------------------------------
-    void render(GLuint dm, GLuint sm, GLuint nt, GLuint dc,
+    void render(GLuint dm, GLuint sm, GLuint st, GLuint nt, GLuint dc,
                 GLuint ds, GLuint lt, const std::array<float, 4> & bg_color)
     {
-        setTextureUnits(dm, sm, nt, dc, ds, lt);
+        setTextureUnits(dm, sm, st, nt, dc, ds, lt);
         drawFullScreenEffect(bg_color);
     }   // render
 };   // CombineDiffuseColor
@@ -265,15 +266,6 @@ void ShaderBasedRenderer::renderSceneDeferred(scene::ICameraSceneNode * const ca
         SP::draw(SP::RP_1ST, SP::DCT_NORMAL);
     }
 
-    // Handle SSAO
-    {
-        PROFILER_PUSH_CPU_MARKER("- SSAO", 0xFF, 0xFF, 0x00);
-        ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SSAO));
-        if (UserConfigParams::m_ssao)
-            renderSSAO();
-        PROFILER_POP_CPU_MARKER();
-    }
-
     glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
     // Lights
     {
@@ -290,12 +282,19 @@ void ShaderBasedRenderer::renderSceneDeferred(scene::ICameraSceneNode * const ca
                                         m_rtts->getDepthStencilTexture(),
                                         m_rtts->getRenderTarget(RTT_COLOR),
                                         m_rtts->getShadowFrameBuffer(),
-                                        m_rtts->getRenderTarget(RTT_HALF1_R),
-                                        m_rtts->getRenderTarget(RTT_SP_DIFF_COLOR),
                                         specular_probe);
         PROFILER_POP_CPU_MARKER();
     }
 
+    // Handle SSAO
+    {
+        PROFILER_PUSH_CPU_MARKER("- SSAO", 0xFF, 0xFF, 0x00);
+        ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SSAO));
+        if (UserConfigParams::m_ssao)
+            renderSSAO();
+        PROFILER_POP_CPU_MARKER();
+    }
+
     const Track * const track = Track::getCurrentTrack();
     // Render discrete lights scattering
     if (UserConfigParams::m_light_scatter && track && track->isFogEnabled())
@@ -350,6 +349,7 @@ void ShaderBasedRenderer::renderSceneDeferred(scene::ICameraSceneNode * const ca
         CombineDiffuseColor::getInstance()->render(
             m_rtts->getRenderTarget(RTT_DIFFUSE),
             m_rtts->getRenderTarget(RTT_SPECULAR),
+            m_rtts->getRenderTarget(RTT_HALF1_R),
             m_rtts->getRenderTarget(RTT_NORMAL_AND_DEPTH),
             m_rtts->getRenderTarget(RTT_SP_DIFF_COLOR),
             m_rtts->getDepthStencilTexture(),
diff --git a/src/graphics/shadow_matrices.cpp b/src/graphics/shadow_matrices.cpp
index c655e1b0c74..1d048f721e2 100644
--- a/src/graphics/shadow_matrices.cpp
+++ b/src/graphics/shadow_matrices.cpp
@@ -143,9 +143,11 @@ static std::vector<vector3df> getFrustrumVertex(const scene::SViewFrustum &frust
  *  and 1.
  *  \param transform a transform matrix.
  *  \param pointsInside a vector of point in 3d space.
+ *  \param size returns the size (width, height) of shadowmap coverage
  */
-core::matrix4 ShadowMatrices::getTightestFitOrthoProj(const core::matrix4 &transform,
-                                    const std::vector<vector3df> &pointsInside)
+core::matrix4 ShadowMatrices::getTighestFitOrthoProj(const core::matrix4 &transform,
+                                    const std::vector<vector3df> &pointsInside,
+                                    std::pair<float, float> &size)
 {
     float xmin = std::numeric_limits<float>::infinity();
     float xmax = -std::numeric_limits<float>::infinity();
@@ -171,6 +173,9 @@ core::matrix4 ShadowMatrices::getTightestFitOrthoProj(const core::matrix4 &trans
     float up = ymin;
     float down = ymax;
 
+    size.first = right - left;
+    size.second = down - up;
+
     core::matrix4 tmp_matrix;
     // Prevent Matrix without extend
     if (left == right || up == down)
@@ -179,7 +184,7 @@ core::matrix4 ShadowMatrices::getTightestFitOrthoProj(const core::matrix4 &trans
         down, up,
         zmin - 100, zmax);
     return tmp_matrix;
-}   // getTightestFitOrthoProj
+}   // getTighestFitOrthoProj
 
 // ----------------------------------------------------------------------------
 /** Generate View, Projection, Inverse View, Inverse Projection, ViewProjection
@@ -275,7 +280,8 @@ void ShadowMatrices::computeMatrixesAndCameras(scene::ICameraSceneNode *const ca
             memcpy(m_shadows_cam[i], tmp, 24 * sizeof(float));
 
             std::vector<vector3df> vectors = getFrustrumVertex(*frustrum);
-            tmp_matrix = getTightestFitOrthoProj(sun_cam_view_matrix, vectors);
+            tmp_matrix = getTighestFitOrthoProj(sun_cam_view_matrix, vectors,
+                                                m_shadow_scales[i]);
 
 
             m_shadow_cam_nodes[i]->setProjectionMatrix(tmp_matrix, true);
diff --git a/src/graphics/shadow_matrices.hpp b/src/graphics/shadow_matrices.hpp
index 183438f9226..82918955a90 100644
--- a/src/graphics/shadow_matrices.hpp
+++ b/src/graphics/shadow_matrices.hpp
@@ -46,14 +46,16 @@ class ShadowMatrices
     std::vector<core::matrix4> m_sun_ortho_matrices;
     scene::ICameraSceneNode   *m_sun_cam;
     scene::ICameraSceneNode   *m_shadow_cam_nodes[4];
+    std::pair<float, float>    m_shadow_scales[4];
     core::matrix4              m_rsm_matrix;
     bool                       m_rsm_matrix_initialized;
     float                      m_shadows_cam[4][24];
     bool                       m_rsm_map_available;
     float                      m_mat_ubo[16 * 9 + 2];
 
-    core::matrix4 getTightestFitOrthoProj(const core::matrix4 &transform,
-                              const std::vector<core::vector3df> &pointsInside);
+    core::matrix4 getTighestFitOrthoProj(const core::matrix4 &transform,
+                              const std::vector<core::vector3df> &pointsInside,
+                              std::pair<float, float> &size);
     void renderWireFrameFrustrum(float *tmp, unsigned i);
 public:
 
@@ -82,6 +84,11 @@ class ShadowMatrices
         return m_sun_ortho_matrices;
     }
     // ------------------------------------------------------------------------
+    const std::pair<float, float>* getShadowScales() const
+    {
+        return m_shadow_scales;
+    }
+    // ------------------------------------------------------------------------
     const float* getMatricesData() const { return m_mat_ubo; }
 
 };   // class ShadowMatrices
diff --git a/src/graphics/sp/sp_base.cpp b/src/graphics/sp/sp_base.cpp
index f05fd30cec0..cc9265b33ee 100644
--- a/src/graphics/sp/sp_base.cpp
+++ b/src/graphics/sp/sp_base.cpp
@@ -123,7 +123,7 @@ unsigned g_skinning_offset = 0;
 // ----------------------------------------------------------------------------
 std::vector<SPMeshNode*> g_skinning_mesh;
 // ----------------------------------------------------------------------------
-bool g_skinning_use_tbo = false;
+int g_skinning_tbo_limit = 0;
 // ----------------------------------------------------------------------------
 int sp_cur_shadow_cascade = 0;
 // ----------------------------------------------------------------------------
@@ -319,13 +319,12 @@ void initSkinning()
     else
     {
 #ifndef USE_GLES2
-        int skinning_tbo_limit;
-        glGetIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE, &skinning_tbo_limit);
-        if (stk_config->m_max_skinning_bones << 6 > (unsigned)skinning_tbo_limit)
+        glGetIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE, &g_skinning_tbo_limit);
+        if (stk_config->m_max_skinning_bones << 6 > (unsigned)g_skinning_tbo_limit)
         {
             Log::warn("SharedGPUObjects", "Too many bones for skinning, max: %d",
-                      skinning_tbo_limit >> 6);
-            stk_config->m_max_skinning_bones = skinning_tbo_limit >> 6;
+                      g_skinning_tbo_limit >> 6);
+            stk_config->m_max_skinning_bones = g_skinning_tbo_limit >> 6;
         }
         Log::info("SharedGPUObjects", "Hardware Skinning enabled, method: TBO, "
                   "max bones: %u", stk_config->m_max_skinning_bones);
@@ -445,14 +444,7 @@ void init()
 
     if (CVS->isARBTextureBufferObjectUsable())
     {
-        int skinning_tbo_limit;
-        glGetIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE_ARB, &skinning_tbo_limit);
-        
-        g_skinning_use_tbo = skinning_tbo_limit >= stk_config->m_max_skinning_bones << 6;
-    }
-    else
-    {
-        g_skinning_use_tbo = false;
+        glGetIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE_ARB, &g_skinning_tbo_limit);
     }
 
     initSkinning();
@@ -663,7 +655,8 @@ SPShader* getNormalVisualizer()
 // ----------------------------------------------------------------------------
 bool skinningUseTBO()
 {
-    return g_skinning_use_tbo;
+    return CVS->isARBTextureBufferObjectUsable()
+        && g_skinning_tbo_limit >= 64 * stk_config->m_max_skinning_bones;
 }
 
 
diff --git a/src/guiengine/event_handler.cpp b/src/guiengine/event_handler.cpp
index c931c6d2cd6..a30c1c24e19 100644
--- a/src/guiengine/event_handler.cpp
+++ b/src/guiengine/event_handler.cpp
@@ -446,7 +446,7 @@ void EventHandler::sendNavigationEvent(const NavigationDirection nav, const int
 
     if (!handled_by_widget)
     {
-        navigate(nav, GUIEngine::getFocusForPlayer(playerID), playerID);
+        navigate(nav, playerID);
     }
 } // sendNavigationEvent
 
@@ -456,9 +456,11 @@ void EventHandler::sendNavigationEvent(const NavigationDirection nav, const int
  *
  * \param nav Determine in which direction to navigate
  */
-void EventHandler::navigate(const NavigationDirection nav, Widget* starting_widget, const int playerID)
+void EventHandler::navigate(const NavigationDirection nav, const int playerID)
 {
-    int next_id = findIDClosestWidget(nav, playerID, starting_widget, false);
+    Widget* w = GUIEngine::getFocusForPlayer(playerID);
+
+    int next_id = findIDClosestWidget(nav, playerID, w, false);
 
     if (next_id != -1)
     {
@@ -480,10 +482,9 @@ void EventHandler::navigate(const NavigationDirection nav, Widget* starting_widg
             assert(ribbon != NULL);
             if (ribbon->getRibbonType() == GUIEngine::RibbonType::RIBBON_VERTICAL_TABS)
             {
-                // Some of the tabs may be disabled. So we navigate until an active tab is found
-                (nav == NAV_UP) ? ribbon->setLastSelection(playerID)
-                                : ribbon->setFirstSelection(playerID);
-
+                int new_selection = (nav == NAV_UP) ?
+                                   ribbon->getActiveChildrenNumber(playerID) - 1 : 0;
+                ribbon->setSelection(new_selection, playerID);
                 // The tab selection triggers an action
                 sendEventToUser(ribbon, ribbon->m_properties[PROP_ID], playerID);
             }
@@ -505,19 +506,19 @@ void EventHandler::navigate(const NavigationDirection nav, Widget* starting_widg
 } // navigate
 
 /**
- * This function use simple heuristics to find the closest widget
- * in the requested direction.
+ * This function use simple heuristic to find the closest widget
+ * in the requested direction,
  * It prioritize widgets close vertically to widget close horizontally,
  * as it is expected behavior in any direction.
  * Several hardcoded values are used, having been found to work well
  * experimentally while keeping simple heuristics.
  */
 int EventHandler::findIDClosestWidget(const NavigationDirection nav, const int playerID,
-                                      Widget* w, bool ignore_disabled, int recursion_counter)
+                                      GUIEngine::Widget* w, bool ignore_disabled, int recursion_counter)
 {
     int closest_widget_id = -1;
     int distance = 0;
-    // So that the UI behavior doesn't change when it is upscaled
+    // So that the UI behavior don't change when it is upscaled
     const int BIG_DISTANCE = irr_driver->getActualScreenSize().Width*100;
     int smallest_distance = BIG_DISTANCE;
     // Used when there is no suitable widget in the requested direction
@@ -537,7 +538,7 @@ int EventHandler::findIDClosestWidget(const NavigationDirection nav, const int p
         // - it doesn't match a widget
         // - it doesn't match a focusable widget
         // - it corresponds to the current widget
-        // - it corresponds to an invisible or disabled widget (while ignore_disabled is true)
+        // - it corresponds to an invisible or disabled widget
         // - the player is not allowed to select it
         // - Its base coordinates are negative (such as buttons within ribbons)
         if (w_test == NULL || !Widget::isFocusableId(i) || w == w_test ||
@@ -580,13 +581,16 @@ int EventHandler::findIDClosestWidget(const NavigationDirection nav, const int p
 
         if (nav == NAV_UP || nav == NAV_DOWN)
         {
-            // Compare current top point with other widget lowest point
             if (nav == NAV_UP)
+            {
+                // Compare current top point with other widget lowest point
                 distance = w->m_y - (w_test->m_y + w_test->m_h);
-
-            // compare current lowest point with other widget top point
+            }
             else
+            {
+                // compare current lowest point with other widget top point
                 distance = w_test->m_y - (w->m_y + w->m_h);
+            }
 
             // Better select an item on the side that one much higher,
             // so make the vertical distance matter much more
@@ -608,14 +612,16 @@ int EventHandler::findIDClosestWidget(const NavigationDirection nav, const int p
         }
         else if (nav == NAV_LEFT || nav == NAV_RIGHT)
         {
-            // compare current leftmost point with other widget rightmost
             if (nav == NAV_LEFT)
+            {
+                // compare current leftmost point with other widget rightmost
                 distance = w->m_x - rightmost;
-
-            // compare current rightmost point with other widget leftmost
+            }
             else
+            {
+                // compare current rightmost point with other widget leftmost
                 distance = w_test->m_x - (w->m_x + w->m_w);
-
+            }
             wrapping_distance = distance;
 
             int down_offset = std::max(0, w_test->m_y - w->m_y);
@@ -670,7 +676,6 @@ int EventHandler::findIDClosestWidget(const NavigationDirection nav, const int p
 
     int closest_id = (smallest_distance < BIG_DISTANCE) ? closest_widget_id :
                                                           closest_wrapping_widget_id;
-
     Widget* w_test = GUIEngine::getWidget(closest_id);
     
     if (w_test == NULL)
@@ -681,19 +686,21 @@ int EventHandler::findIDClosestWidget(const NavigationDirection nav, const int p
     // This allows to skip over disabled/invisible widgets in a grid
     if (!w_test->isVisible() || !w_test->isActivated())
     {
-        // Can skip over at most 3 consecutive disabled/invisible widgets
+        // Can skip over at most 3 consecutive disabled/invisible widget
         if (recursion_counter <=2)
-            closest_id = findIDClosestWidget(nav, playerID, w_test, /*ignore disabled*/ false, recursion_counter + 1);
-        // We have only found disabled/invisible widgets on our path
+        {
+            recursion_counter++;
+            return findIDClosestWidget(nav, playerID, w_test, /*ignore disabled*/ false, recursion_counter);
+        }
+        // If nothing has been found, do a search ignoring disabled/invisible widgets,
+        // restarting from the initial focused widget (otherwise, it could lead to weird results) 
         else if (recursion_counter == 3)
-            closest_id = -1;
+        {
+            Widget* w_focus = GUIEngine::getFocusForPlayer(playerID);
+            return findIDClosestWidget(nav, playerID, w_focus, /*ignore disabled*/ true, recursion_counter);
+        }
     }
 
-    // If nothing has been found or if we looped back to the starting widget (see issue #5283),
-    // do a search ignoring disabled/invisible widgets, restarting from the initial widget
-    if (recursion_counter == 0 && (closest_id == -1 || GUIEngine::getWidget(closest_id) == w))
-        closest_id = findIDClosestWidget(nav, playerID, w, /*ignore disabled*/ true, 1 /* avoid infinite loops */);
-
     return closest_id;
 } // findIDClosestWidget
 
diff --git a/src/guiengine/event_handler.hpp b/src/guiengine/event_handler.hpp
index b032b4977c2..ab8f6471986 100644
--- a/src/guiengine/event_handler.hpp
+++ b/src/guiengine/event_handler.hpp
@@ -72,7 +72,7 @@ namespace GUIEngine
         EventPropagation onGUIEvent(const irr::SEvent& event);
         EventPropagation onWidgetActivated(Widget* w, const int playerID, Input::InputType type);
         void sendNavigationEvent(const NavigationDirection nav, const int playerID);
-        void navigate(const NavigationDirection nav, Widget* starting_widget, const int playerID);
+        void navigate(const NavigationDirection nav, const int playerID);
 
         /** \brief          send an event to the GUI module user's event callback
           * \param widget   the widget that triggerred this event
@@ -114,7 +114,7 @@ namespace GUIEngine
         
         void setAcceptEvents(bool value) { m_accept_events = value; }
         int findIDClosestWidget(const NavigationDirection nav, const int playerID,
-                                Widget* w, bool ignore_disabled, int recursion_counter=0);
+                                Widget* w, bool ignore_disabled, int recursion_counter=1);
     };
 
 }
diff --git a/src/guiengine/skin.cpp b/src/guiengine/skin.cpp
index e4e1569d6eb..9a674c75b16 100644
--- a/src/guiengine/skin.cpp
+++ b/src/guiengine/skin.cpp
@@ -1424,11 +1424,10 @@ void Skin::drawRibbonChild(const core::recti &rect, Widget* widget,
         }
 
         const bool mark_focused =
-            (focused || (parent_focused && parentRibbonWidget != NULL &&
+            focused || (parent_focused && parentRibbonWidget != NULL &&
                           parentRibbonWidget->m_mouse_focus == widget) ||
                        (mark_selected && !always_show_selection &&
-                          parent_focused)) &&
-                        widget->m_properties[PROP_FOCUS_ICON].size() == 0;
+                          parent_focused);
 
         /* draw "selection bubble" if relevant */
         if (always_show_selection && mark_selected)
diff --git a/src/guiengine/widgets/ribbon_widget.cpp b/src/guiengine/widgets/ribbon_widget.cpp
index 1b8b76ef728..a252ecc3394 100644
--- a/src/guiengine/widgets/ribbon_widget.cpp
+++ b/src/guiengine/widgets/ribbon_widget.cpp
@@ -307,30 +307,6 @@ void RibbonWidget::removeChildNamed(const char* name)
     }
 }
 
-// ----------------------------------------------------------------------------
-
- /** Sets the first active item within the ribbon as selected,
-  * or the last one if 'reverse_order' is true. */
-void RibbonWidget::setFirstSelection(const int playerID, bool reverse_order)
-{
-    // Despite the name, "active children" includes elements that have been created
-    // and disabled with setActive(false)
-    // TODO: rename it to be clearer
-    int id = (reverse_order) ? getActiveChildrenNumber(playerID) - 1 : 0;
-    while (id >= 0 && id <= (getActiveChildrenNumber(playerID) - 1))
-    {
-        if (m_active_children[id].isActivated())
-            break;
-
-        id = (reverse_order) ? id - 1 : id + 1;
-    }
-
-    // If every single element within the ribbon is desactivated, we will pick
-    // the last (first) even if disabled, but this case should not arise.
-    m_selection[playerID] = id;
-    updateSelection();
-}   // setFirstSelection
-
 // ----------------------------------------------------------------------------
 
 void RibbonWidget::select(std::string item, const int mousePlayerID)
diff --git a/src/guiengine/widgets/ribbon_widget.hpp b/src/guiengine/widgets/ribbon_widget.hpp
index bbcd3b905d4..5cb05414052 100644
--- a/src/guiengine/widgets/ribbon_widget.hpp
+++ b/src/guiengine/widgets/ribbon_widget.hpp
@@ -173,13 +173,6 @@ namespace GUIEngine
         /** Sets the ID of the selected item within the ribbon */
         void setSelection(const int i, const int playerID)
                              { m_selection[playerID] = i; updateSelection(); }
-
-        /** Sets the first active item within the ribbon as selected */
-        void setFirstSelection(const int playerID, bool reverse_order = false);
-
-        /** Sets the last active item within the ribbon as selected */
-        void setLastSelection(const int playerID)
-                             { setFirstSelection(playerID, true); }
         
         /** Select an item in the ribbon by its internal name */
         void select(std::string item, const int playerID);
diff --git a/src/input/device_manager.cpp b/src/input/device_manager.cpp
index 189172c9fa2..6a423b516cc 100644
--- a/src/input/device_manager.cpp
+++ b/src/input/device_manager.cpp
@@ -611,24 +611,6 @@ KeyboardDevice* DeviceManager::getKeyboardFromBtnID(const int button_id)
     return NULL;
 }   // getKeyboardFromButtonID
 
-// -----------------------------------------------------------------------------
-GamePadDevice* DeviceManager::getGamePad(const int i)
-{
-    if (i>= 0 && i < (int)m_gamepads.size())
-        return m_gamepads.get(i);
-    else
-        return NULL;
-}
-
-// -----------------------------------------------------------------------------
-KeyboardDevice* DeviceManager::getKeyboard(const int i)
-{
-    if (i >= 0 && i < (int)m_keyboards.size())
-        return m_keyboards.get(i);
-    else
-        return NULL;
-}
-
 // -----------------------------------------------------------------------------
 
 void DeviceManager::shutdown()
diff --git a/src/input/device_manager.hpp b/src/input/device_manager.hpp
index b6ca0366b3e..126718679d6 100644
--- a/src/input/device_manager.hpp
+++ b/src/input/device_manager.hpp
@@ -98,6 +98,8 @@ class DeviceManager: public NoCopy
     void shutdown();
 
 public:
+
+
     DeviceManager();
     ~DeviceManager();
 
@@ -109,7 +111,7 @@ class DeviceManager: public NoCopy
     void addGamepad(GamePadDevice* d);
     int getGamePadAmount() const                            { return m_gamepads.size(); }
     int getGamePadConfigAmount() const                      { return m_gamepad_configs.size(); }
-    GamePadDevice*      getGamePad(const int i);
+    GamePadDevice*      getGamePad(const int i)             { return m_gamepads.get(i); }
     GamepadConfig*      getGamepadConfig(const int i)       { return m_gamepad_configs.get(i); }
     GamePadDevice*      getGamePadFromIrrID(const int i);
     void                clearGamepads();
@@ -133,7 +135,7 @@ class DeviceManager: public NoCopy
         return active;
     }
     int                 getKeyboardConfigAmount() const     { return m_keyboard_configs.size(); }
-    KeyboardDevice*     getKeyboard(const int i);
+    KeyboardDevice*     getKeyboard(const int i)            { return m_keyboards.get(i); }
     KeyboardConfig*     getKeyboardConfig(const int i)      { return m_keyboard_configs.get(i); }
     KeyboardDevice*     getKeyboardFromBtnID(const int btnID);
 
diff --git a/src/items/attachment.cpp b/src/items/attachment.cpp
index 78da8a2986f..739432556bf 100644
--- a/src/items/attachment.cpp
+++ b/src/items/attachment.cpp
@@ -617,34 +617,9 @@ void Attachment::updateGraphics(float dt)
             World::getWorld()->getTicksSinceStart()) / 0.7f;
         if (scale_ratio > 0.0f)
         {
-            if (m_type == ATTACH_PARACHUTE)
-            {
-                const float progress = 1.0f - scale_ratio;
-
-                const float x = 0.2f * atan(25.0f * progress - 5.0f) + 0.69f;
-                const float y = x;
-                const float z = 1.0f - pow(2.0f, -20.f * progress);
-
-                m_node->setScale(core::vector3df(x * wanted_node_scale,
-                                                 y * wanted_node_scale,
-                                                 z * wanted_node_scale));
-            }
-            else
-            {
-                if (is_shield)
-                {
-                    // Taken from https://easings.net/#easeInElastic
-                    const float c4 = (2.0f * PI) / 3.0f;
-                    const float x = scale_ratio;
-
-                    scale_ratio = x <= 0 ? 0 : x >= 1 ? 1
-                      : -pow(2, 10 * x - 10) * sin((x * 10 - 10.75) * c4);
-                }
-
-                float scale = 0.3f * scale_ratio +
-                    wanted_node_scale * (1.0f - scale_ratio);
-                m_node->setScale(core::vector3df(scale, scale, scale));
-            }
+            float scale = 0.3f * scale_ratio +
+                wanted_node_scale * (1.0f - scale_ratio);
+            m_node->setScale(core::vector3df(scale, scale, scale));
         }
         else
         {
diff --git a/src/items/item.cpp b/src/items/item.cpp
index 79f1b6f2781..7514d5e79aa 100644
--- a/src/items/item.cpp
+++ b/src/items/item.cpp
@@ -223,8 +223,7 @@ Item::Item(ItemType type, const Vec3& xyz, const Vec3& normal,
 {
     m_icon_node = NULL;
     m_was_available_previously = true;
-    // Prevent appear animation at start
-    m_animation_start_ticks = -9999;
+    m_animation_start_ticks = 0;
     m_distance_2        = 1.2f;
     initItem(type, xyz, normal);
     m_graphical_type    = getGrahpicalType();
@@ -252,7 +251,6 @@ Item::Item(ItemType type, const Vec3& xyz, const Vec3& normal,
         // when already quite far.
         lodnode->autoComputeLevel(24); // The distance grows with the square root of the scaling factor
         m_node = lodnode;
-        m_appear_anime_node = irr_driver->getSceneManager()->addEmptySceneNode(m_node);
     }
     setType(type);
     handleNewMesh(getGrahpicalType());
@@ -275,7 +273,7 @@ Item::Item(ItemType type, const Vec3& xyz, const Vec3& normal,
     {
         scene::ISceneNode* billboard =
             irr_driver->addBillboard(core::dimension2df(SPARK_SIZE, SPARK_SIZE),
-                                     "item_spark.png", m_appear_anime_node);
+                                     "item_spark.png", m_node);
 #ifdef DEBUG
         billboard->setName("spark");
 #endif
@@ -363,11 +361,9 @@ Item::~Item()
     if (m_node != NULL)
     {
         for (auto* node : m_spark_nodes)
-            m_appear_anime_node->removeChild(node);
+            m_node->removeChild(node);
         if (m_icon_node)
-            m_appear_anime_node->removeChild(m_icon_node);
-        
-        m_node->removeChild(m_appear_anime_node);
+            m_node->removeChild(m_icon_node);
 
         irr_driver->removeNode(m_node);
         m_node->drop();
@@ -384,7 +380,7 @@ Item::~Item()
 void Item::reset()
 {
     m_was_available_previously = true;
-    m_animation_start_ticks = -9999;
+    m_animation_start_ticks = 0;
     ItemState::reset();
 
     if (m_node != NULL)
@@ -414,14 +410,14 @@ void Item::handleNewMesh(ItemType type)
     m_node->setRotation(hpr.toIrrHPR());
 
     if (m_icon_node)
-        m_appear_anime_node->removeChild(m_icon_node);
+        m_node->removeChild(m_icon_node);
     m_icon_node = NULL;
     auto icon = ItemManager::getIcon(type);
 
     if (!icon.empty())
     {
         m_icon_node = irr_driver->addBillboard(core::dimension2df(1.0f, 1.0f),
-                                        icon, m_appear_anime_node);
+                                        icon, m_node);
 
         m_icon_node->setPosition(core::vector3df(0.0f, 0.5f, 0.0f));
         m_icon_node->setVisible(false);
@@ -507,54 +503,60 @@ void Item::updateGraphics(float dt)
         m_node->setRotation(hpr.toIrrHPR());
     } // if item is available
 
-    bool is_in_appear_anime = time_since_return < 1.0f
-                             || (!isAvailable() && time_till_return < 1.0f);
-    m_appear_anime_node->setVisible(is_in_appear_anime);
-
-    if (is_in_appear_anime)
+    for (size_t i = 0; i < SPARK_AMOUNT; i++)
     {
-        for (size_t i = 0; i < SPARK_AMOUNT; i++)
+        if (time_since_return >= 1.0f)
         {
-            float t = time_since_return + 0.5f;
-            float t2 = time_since_return + 1.0f;
+            m_spark_nodes[i]->setVisible(false);
+            continue;
+        }
 
-            float node_angle = !rotating() ? 0.0f :
-                    fmodf((float)World::getWorld()->getTicksSinceStart() / 40.0f,
-                    M_PI * 2);
+        float t = time_since_return + 0.5f;
+        float t2 = time_since_return + 1.0f;
 
-            float x = sin(float(i) / float(SPARK_AMOUNT) * 2.0f * M_PI - node_angle)
-                        * t * SPARK_SPEED_H;
-            float y = 2.0f * t2 - t2 * t2 - 0.5f;
-            float z = cos(float(i) / float(SPARK_AMOUNT) * 2.0f * M_PI - node_angle)
-                        * t * SPARK_SPEED_H;
+        float node_angle = !rotating() ? 0.0f :
+                fmodf((float)World::getWorld()->getTicksSinceStart() / 40.0f,
+                M_PI * 2);
 
-            m_spark_nodes[i]->setPosition(core::vector3df(x, y, z));
+        float x = sin(float(i) / float(SPARK_AMOUNT) * 2.0f * M_PI - node_angle)
+                    * t * SPARK_SPEED_H;
+        float y = 2.0f * t2 - t2 * t2 - 0.5f;
+        float z = cos(float(i) / float(SPARK_AMOUNT) * 2.0f * M_PI - node_angle)
+                    * t * SPARK_SPEED_H;
 
-            float factor = std::max(0.0f, 1.0f - t / 2.0f);
+        m_spark_nodes[i]->setPosition(core::vector3df(x, y, z));
 
+        float factor = std::max(0.0f, 1.0f - t / 2.0f);
+
+        if (factor < 0.001f)
+        {
+            m_spark_nodes[i]->setVisible(false);
+        }
+        else
+        {
             m_spark_nodes[i]->setVisible(true);
 
             ((scene::IBillboardSceneNode*)m_spark_nodes[i])
                     ->setSize(core::dimension2df(factor * SPARK_SIZE,
-                                                factor * SPARK_SIZE));
+                                                 factor * SPARK_SIZE));
         }
+    }
 
-        if (m_icon_node)
+    if (m_icon_node)
+    {
+        if (!isAvailable() && time_till_return <= 1.0f)
+        {
+            m_icon_node->setVisible(true);
+            float size = 1.0f / (pow(6.0f, -time_till_return - 0.2f) *
+                        (-time_till_return - 0.2f)) + 7.0f;
+
+            ((scene::IBillboardSceneNode*)m_icon_node)
+                    ->setSize(core::dimension2df(size * ICON_SIZE,
+                                                 size * ICON_SIZE));
+        }
+        else
         {
-            if (!isAvailable())
-            {
-                m_icon_node->setVisible(true);
-                float size = 1.0f / (pow(6.0f, -time_till_return - 0.2f) *
-                            (-time_till_return - 0.2f)) + 7.0f;
-
-                ((scene::IBillboardSceneNode*)m_icon_node)
-                        ->setSize(core::dimension2df(size * ICON_SIZE,
-                                                    size * ICON_SIZE));
-            }
-            else
-            {
-                m_icon_node->setVisible(false);
-            }
+            m_icon_node->setVisible(false);
         }
     }
 
diff --git a/src/items/item.hpp b/src/items/item.hpp
index 6e319cf4fd4..4f218513b7b 100644
--- a/src/items/item.hpp
+++ b/src/items/item.hpp
@@ -330,9 +330,6 @@ class Item : public ItemState, public NoCopy
     /** Graphical type of the mesh. */
     ItemType m_graphical_type;
 
-    /** The parent of m_spark_nodes and m_icon_node */
-    scene::ISceneNode* m_appear_anime_node;
-
     /** Vector containing the sparks */
     std::vector<scene::ISceneNode*> m_spark_nodes;
 
diff --git a/src/karts/controller/local_player_controller.cpp b/src/karts/controller/local_player_controller.cpp
index f1498910a77..87cacd5e050 100644
--- a/src/karts/controller/local_player_controller.cpp
+++ b/src/karts/controller/local_player_controller.cpp
@@ -24,7 +24,6 @@
 #include "config/stk_config.hpp"
 #include "config/user_config.hpp"
 #include "graphics/camera/camera.hpp"
-#include "graphics/camera/camera_normal.hpp"
 #include "graphics/irr_driver.hpp"
 #include "graphics/particle_emitter.hpp"
 #include "graphics/particle_kind.hpp"
@@ -57,7 +56,7 @@
 
 #include "LinearMath/btTransform.h"
 
-/** The constructor for a local player kart, i.e. a player that is playing
+/** The constructor for a loca player kart, i.e. a player that is playing
  *  on this machine (non-local player would be network clients).
  *  \param kart_name Name of the kart.
  *  \param position The starting position (1 to n).
@@ -270,10 +269,7 @@ void LocalPlayerController::update(int ticks)
         else
         {
             if (camera->getMode() == Camera::CM_REVERSE)
-            {
                 camera->setMode(Camera::CM_NORMAL);
-                dynamic_cast<CameraNormal*>(camera)->snapToPosition();
-            }
         }
         if (m_sky_particles_emitter)
         {
diff --git a/src/karts/controller/spare_tire_ai.cpp b/src/karts/controller/spare_tire_ai.cpp
index 09210fabc24..4d51d89ec03 100644
--- a/src/karts/controller/spare_tire_ai.cpp
+++ b/src/karts/controller/spare_tire_ai.cpp
@@ -142,20 +142,11 @@ void SpareTireAI::crashed(const AbstractKart *k)
     // Nothing happen when two spare tire karts crash each other
     if (dynamic_cast<const SpareTireAI*>(k->getController()) != NULL) return;
 
-    // Tell players that they can have at most 3 lives
+    // Add a life
     RaceGUIBase* r = World::getWorld()->getRaceGUI();
-    if (m_tsb_world->getKartLife(k->getWorldKartId()) == 3)
-    {
-        if (r)
-            r->addMessage(_("You can have at most 3 lives!"), k, 2.0f);
-    }
-    // Otherwise add one life for that kart 
-    else
-    {
-        m_tsb_world->addKartLife(k->getWorldKartId());
-        if (r)
-            r->addMessage(_("+1 life."), k, 2.0f);
-    }
+    m_tsb_world->addKartLife(k->getWorldKartId());
+    if (r)
+        r->addMessage(_("+1 life."), k, 2.0f);
     unspawn();
 
 }   // crashed
diff --git a/src/karts/kart_model.cpp b/src/karts/kart_model.cpp
index ccc4632ad1f..933cd13a1c4 100644
--- a/src/karts/kart_model.cpp
+++ b/src/karts/kart_model.cpp
@@ -267,8 +267,7 @@ KartModel::~KartModel()
         if(m_is_master && m_wheel_model[i])
         {
             irr_driver->dropAllTextures(m_wheel_model[i]);
-            if (m_wheel_model[i]->getReferenceCount() == 1)
-                irr_driver->removeMeshFromCache(m_wheel_model[i]);
+            irr_driver->removeMeshFromCache(m_wheel_model[i]);
         }
     }
 
diff --git a/src/karts/kart_properties_manager.cpp b/src/karts/kart_properties_manager.cpp
index 833542f8e02..ef816b48bbd 100644
--- a/src/karts/kart_properties_manager.cpp
+++ b/src/karts/kart_properties_manager.cpp
@@ -131,8 +131,8 @@ void KartPropertiesManager::removeKart(const std::string &ident)
         // Handle no custom group first
         if(it!=m_groups_2_indices_no_custom[groups[i]].end())
         {
+            m_groups_2_indices_no_custom.erase(groups[i]);
             m_groups_2_indices_no_custom[groups[i]].erase(it);
-
             if(m_groups_2_indices_no_custom[groups[i]].size()==0)
             {
                 m_groups_2_indices_no_custom.erase(groups[i]);
diff --git a/src/main.cpp b/src/main.cpp
index c52e014cfc7..9d143f78884 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -514,36 +514,12 @@ void setupRaceStart()
     // a current player
     PlayerManager::get()->enforceCurrentPlayer();
 
-    InputDevice *device = NULL;
+    InputDevice *device;
 
-    // Assign the player a device; check the command line params for preferences; by default use keyboard 0
+    // Use keyboard 0 by default in --no-start-screen
+    device = input_manager->getDeviceManager()->getKeyboard(0);
 
-    if(UserConfigParams::m_default_keyboard > -1)
-    {
-        device = input_manager->getDeviceManager()->getKeyboard(UserConfigParams::m_default_keyboard);
-    }
-    else if(UserConfigParams::m_default_gamepad > -1)
-    {
-        // getGamePad(int) returns a GamePadDevice which is a subclass of InputDevice
-        // However, the compiler doesn't like it so it has to be manually casted in
-        device = (InputDevice *) input_manager->getDeviceManager()->getGamePad(UserConfigParams::m_default_gamepad);
-    }
-    // If no config requested or if the requested config doesn't exist
-    if (device == NULL)
-    {
-        if (UserConfigParams::m_default_keyboard > -1 ||
-            UserConfigParams::m_default_gamepad > -1)
-        {
-            Log::error("main", "Requested input device unavailable, fallback to the default keyboard");
-        }
-        device = input_manager->getDeviceManager()->getKeyboard(0);
-    }
-
-    // In case the requested config was disabled, enable it.
-    if (!device->getConfiguration()->isEnabled())
-        device->getConfiguration()->setEnabled(true);
-
-    // Create player and associate player with device
+    // Create player and associate player with keyboard
     StateManager::get()->createActivePlayer(
         PlayerManager::get()->getPlayer(0), device);
 
@@ -581,14 +557,10 @@ void cmdLineHelp()
                               "menu.\n"
     "  -R,  --race-now         Same as -N but also skip the ready-set-go phase"
                               " and the music.\n"
-    "       --use-keyboard=N   Used in conjunction with the -N or -R option, will assign the player to the specified"
-                              " keyboard. Is zero indexed.\n"
-    "       --use-gamepad=N    Used in conjunction with the -N or -R option, will assign the player to the specified"
-                              " gamepad. Is zero indexed.\n"
     "  -t,  --track=NAME       Start track NAME.\n"
     "       --gp=NAME          Start the specified Grand Prix.\n"
-    "       --add-gp-dir=DIR   Load Grand Prix files in DIR. Setting will be saved"
-                              "in config.xml under additional_gp_directory. Use"
+    "       --add-gp-dir=DIR   Load Grand Prix files in DIR. Setting will be saved\n"
+                              "in config.xml under additional_gp_directory. Use\n"
                               "--add-gp-dir=\"\" to unset.\n"
     "       --stk-config=FILE  use ./data/FILE instead of "
                               "./data/stk_config.xml\n"
@@ -1703,14 +1675,6 @@ int handleCmdLine(bool has_server_config, bool has_parent_process)
         UserConfigParams::m_race_now = true;
     }   // --race-now
 
-    if(CommandLine::has( "--use-keyboard",&n)) {
-        UserConfigParams::m_default_keyboard = n;
-    } //--use-keyboard
-
-    if(CommandLine::has( "--use-gamepad",&n)) {
-        UserConfigParams::m_default_gamepad = n;
-    } //--use-gamepad
-
     if(CommandLine::has("--laps", &s))
     {
         int laps = atoi(s.c_str());
diff --git a/src/modes/linear_world.cpp b/src/modes/linear_world.cpp
index ad770659630..148a8f97932 100644
--- a/src/modes/linear_world.cpp
+++ b/src/modes/linear_world.cpp
@@ -443,14 +443,6 @@ void LinearWorld::newLap(unsigned int kart_index)
                 m_last_lap_sfx_playing = false;
             }
         }
-        // Switch on faster music if not already done so, if the
-        // first kart is doing its last lap.
-        if(!m_faster_music_active &&
-            useFastMusicNearEnd())
-        {
-            music_manager->switchToFastMusic();
-            m_faster_music_active=true;
-        }
     }
     else if (raceHasLaps() && kart_info.m_finished_laps > 0 &&
              kart_info.m_finished_laps+1 < lap_count && !isLiveJoinWorld() && m_race_gui)
@@ -963,6 +955,17 @@ void LinearWorld::updateRacePosition()
             assert(false);
         }
 #endif
+
+        // Switch on faster music if not already done so, if the
+        // first kart is doing its last lap.
+        if(!m_faster_music_active                                  &&
+            p == 1                                                 &&
+            kart_info.m_finished_laps == RaceManager::get()->getNumLaps() - 1 &&
+            useFastMusicNearEnd()                                       )
+        {
+            music_manager->switchToFastMusic();
+            m_faster_music_active=true;
+        }
     }   // for i<kart_amount
 
     // Define this to get a detailled analyses each time a race position
diff --git a/src/modes/overworld.cpp b/src/modes/overworld.cpp
index 0fed626666e..1f060ecbf69 100644
--- a/src/modes/overworld.cpp
+++ b/src/modes/overworld.cpp
@@ -38,10 +38,6 @@
 #include "tracks/track.hpp"
 #include "tracks/track_object_manager.hpp"
 
-#ifdef ANDROID
-#include <SDL_system.h>
-#endif
-
 //-----------------------------------------------------------------------------
 OverWorld::OverWorld() : World()
 {
@@ -246,11 +242,6 @@ void OverWorld::onFirePressed(Controller* who)
         {
             if (challenges[n].m_challenge_id == "tutorial")
             {
-#ifdef ANDROID
-                if (SDL_IsAndroidTV())
-                    return;
-#endif
-
                 scheduleTutorial();
                 return;
             }
diff --git a/src/modes/three_strikes_battle.cpp b/src/modes/three_strikes_battle.cpp
index c4f4c7982f9..521406c2bfe 100644
--- a/src/modes/three_strikes_battle.cpp
+++ b/src/modes/three_strikes_battle.cpp
@@ -31,6 +31,7 @@
 #include "karts/kart_properties_manager.hpp"
 #include "physics/physics.hpp"
 #include "states_screens/race_gui_base.hpp"
+#include "states_screens/track_info_screen.hpp"
 #include "tracks/arena_graph.hpp"
 #include "tracks/arena_node.hpp"
 #include "tracks/terrain_info.hpp"
@@ -45,6 +46,8 @@
 #include <string>
 #include <IMeshSceneNode.h>
 
+#include <iostream>
+
 //-----------------------------------------------------------------------------
 /** Constructor. Sets up the clock mode etc.
  */
@@ -63,6 +66,7 @@ ThreeStrikesBattle::ThreeStrikesBattle() : WorldWithRank()
     m_start_time = irr_driver->getRealTime();
     m_total_hit = 0;
 
+
 }   // ThreeStrikesBattle
 
 //-----------------------------------------------------------------------------
@@ -98,7 +102,7 @@ ThreeStrikesBattle::~ThreeStrikesBattle()
 void ThreeStrikesBattle::reset(bool restart)
 {
     WorldWithRank::reset(restart);
-
+    
     float next_spawn_time =
         RaceManager::get()->getDifficulty() == RaceManager::DIFFICULTY_BEST ? 40.0f :
         RaceManager::get()->getDifficulty() == RaceManager::DIFFICULTY_HARD ? 30.0f :
@@ -116,7 +120,9 @@ void ThreeStrikesBattle::reset(bool restart)
         }
         else
         {
-            m_kart_info[n].m_lives = 3;
+            //m_kart_info[n].m_lives = RaceManager::get()->getTireAmount();
+            //m_kart_info[n].m_lives = 1;   
+            m_kart_info[n].m_lives = UserConfigParams::m_ffa_time_limit;         
         }
 
         // no positions in this mode
@@ -229,10 +235,15 @@ bool ThreeStrikesBattle::kartHit(int kart_id, int hitter)
     assert(kart_id < (int)m_karts.size());
     // make kart lose a life, ignore if in profiling mode
     if (!UserConfigParams::m_arena_ai_stats)
+    {
         m_kart_info[kart_id].m_lives--;
+        if (hitter != -1 && hitter != kart_id && UserConfigParams::m_tire_steal)
+            m_kart_info[hitter].m_lives++;
+    }  
     else
+    {
         m_total_hit++;
-
+    }
     // record event
     BattleEvent evt;
     evt.m_time = getTime();
@@ -316,6 +327,11 @@ bool ThreeStrikesBattle::kartHit(int kart_id, int hitter)
 
     // schedule a tire to be thrown away (but can't do it in this callback
     // because the caller is currently iterating the list of track objects)
+    // don't do this if the tire is getting stolen
+    
+    if (hitter != -1 && hitter != kart_id && UserConfigParams::m_tire_steal)
+        return true;
+    
     m_insert_tire++;
     core::vector3df wheel_pos(m_karts[kart_id]->getKartWidth()*0.5f,
                               0.0f, 0.0f);
@@ -514,23 +530,19 @@ void ThreeStrikesBattle::getKartsDisplayInfo(
 
         // reset color
         rank_info.lap = -1;
-
-        switch(m_kart_info[i].m_lives)
+        
+        if (m_kart_info[i].m_lives == 0)
         {
-            case 3:
-                rank_info.m_color = video::SColor(255, 0, 255, 0);
-                break;
-            case 2:
-                rank_info.m_color = video::SColor(255, 255, 229, 0);
-                break;
-            case 1:
-                rank_info.m_color = video::SColor(255, 255, 0, 0);
-                break;
-            case 0:
-                rank_info.m_color = video::SColor(128, 128, 128, 0);
-                break;
+            rank_info.m_color = video::SColor(128,128,128,0);
         }
-
+        else
+        {
+            float lerp_time;
+            lerp_time = float(m_kart_info[i].m_lives-1)/float(UserConfigParams::m_ffa_time_limit);
+            int lerp_lower = floor(lerp_time*gradientLength);
+    
+            rank_info.m_color = video::SColor(255, lerp(redGradient[lerp_lower+1],redGradient[lerp_lower+2],lerp_time*gradientLength-lerp_lower), lerp(greenGradient[lerp_lower+1],greenGradient[lerp_lower+2],lerp_time*gradientLength-lerp_lower), lerp(blueGradient[lerp_lower+1],blueGradient[lerp_lower+2],lerp_time*gradientLength-lerp_lower));
+    }
         std::ostringstream oss;
         oss << m_kart_info[i].m_lives;
 
@@ -544,20 +556,17 @@ std::pair<int, video::SColor> ThreeStrikesBattle::getSpeedometerDigit(
 {
     video::SColor color = video::SColor(255, 255, 255, 255);
     int id = kart->getWorldKartId();
-    switch(m_kart_info[id].m_lives)
+    if (m_kart_info[id].m_lives == 0)
+    {
+        color = video::SColor(128,128,128,0);
+    }
+    else
     {
-        case 3:
-            color = video::SColor(255, 0, 255, 0);
-            break;
-        case 2:
-            color = video::SColor(255, 255, 229, 0);
-            break;
-        case 1:
-            color = video::SColor(255, 255, 0, 0);
-            break;
-        case 0:
-            color = video::SColor(255, 128, 128, 128);
-            break;
+        float lerp_time;
+        lerp_time = float(m_kart_info[id].m_lives-1)/float(UserConfigParams::m_ffa_time_limit);
+        int lerp_lower = floor(lerp_time*gradientLength);
+    
+        color = video::SColor(255, lerp(redGradient[lerp_lower+1],redGradient[lerp_lower+2],lerp_time*gradientLength-lerp_lower), lerp(greenGradient[lerp_lower+1],greenGradient[lerp_lower+2],lerp_time*gradientLength-lerp_lower), lerp(blueGradient[lerp_lower+1],blueGradient[lerp_lower+2],lerp_time*gradientLength-lerp_lower));
     }
     return std::make_pair(m_kart_info[id].m_lives, color);
 }   // getSpeedometerDigit
diff --git a/src/modes/three_strikes_battle.hpp b/src/modes/three_strikes_battle.hpp
index d9886760f51..5eddbb502e3 100644
--- a/src/modes/three_strikes_battle.hpp
+++ b/src/modes/three_strikes_battle.hpp
@@ -150,6 +150,16 @@ class ThreeStrikesBattle : public WorldWithRank
     bool spareTireKartsSpawned() const;
     // ------------------------------------------------------------------------
     void spawnSpareTireKarts();
+    // ------------------------------------------------------------------------
+    const int redGradient[12] = {30, 64, 255, 255, 255, 128, 0, 0, 0, 0, 0, 0};
+    // ------------------------------------------------------------------------
+    const int greenGradient[12] = {0, 0, 0, 128, 255, 255, 255, 128, 255, 128, 0, 0};
+    // ------------------------------------------------------------------------
+    const int blueGradient[12] = {0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 192, 64};
+    // ------------------------------------------------------------------------
+    /* Must be two lower than the actual length, the first and last items in the 
+     array are just buffers to prevent floating-point disasters */
+    const int gradientLength = 10;
 
 };   // ThreeStrikesBattles
 
diff --git a/src/modes/world.cpp b/src/modes/world.cpp
index 82cdc3829ae..d84f68796ba 100644
--- a/src/modes/world.cpp
+++ b/src/modes/world.cpp
@@ -25,7 +25,6 @@
 #include "challenges/unlock_manager.hpp"
 #include "config/user_config.hpp"
 #include "graphics/camera/camera.hpp"
-#include "graphics/camera/camera_normal.hpp"
 #include "graphics/central_settings.hpp"
 #include "graphics/irr_driver.hpp"
 #include "graphics/material.hpp"
@@ -138,7 +137,6 @@ World::World() : WorldStatus()
     m_schedule_exit_race = false;
     m_schedule_tutorial  = false;
     m_is_network_world   = false;
-    m_snap_camera        = false;
 
     m_stop_music_when_dialog_open = true;
 
@@ -893,11 +891,7 @@ void World::resetAllKarts()
     {
         for(unsigned int i=0; i<Camera::getNumCameras(); i++)
         {
-            Camera* cam = Camera::getCamera(i);
-            cam->setInitialTransform();
-            // Ensure that smoothed cameras start from a correct position
-            if (cam->isNormal())
-                dynamic_cast<CameraNormal*>(cam)->snapToPosition();
+            Camera::getCamera(i)->setInitialTransform();
         }
     }
 }   // resetAllKarts
@@ -945,7 +939,6 @@ void World::moveKartTo(AbstractKart* kart, const btTransform &transform)
     Track::getCurrentTrack()->findGround(kart);
     Track::getCurrentTrack()->getCheckManager()->resetAfterKartMove(kart);
 
-    m_snap_camera = true;
 }   // moveKartTo
 
 // ----------------------------------------------------------------------------
@@ -1029,18 +1022,6 @@ void World::updateWorld(int ticks)
         m_schedule_unpause = false;
     }
 
-    if (m_snap_camera)
-    {
-        m_snap_camera = false;
-        for(unsigned int i=0; i<Camera::getNumCameras(); i++)
-        {
-            Camera* cam = Camera::getCamera(i);
-            // Ensure that smoothed cameras start from a correct position
-            if (cam->isNormal())
-                dynamic_cast<CameraNormal*>(cam)->snapToPosition();
-        }
-    }
-
     // Don't update world if a menu is shown or the race is over.
     // Exceptions : - Networking (local pause doesn't affect the server or other players)
     //              - Benchmarking (a pause would mess up measurements)
@@ -1275,13 +1256,14 @@ Highscores* World::getGPHighscores() const
 }
 
 // ----------------------------------------------------------------------------
-/** Called at the end of a race.
- * Submits the valid new times through the addHighscore functions, which then handles
- * checking if the new times are worth of a highscore and saving them.
- * The best highscore rank is transmitted to highlight the best new highscore in the GUI.
+/** Called at the end of a race. Checks if the current times are worth a new
+ *  score, if so it notifies the HighscoreManager so the new score is added
+ *  and saved.
  */
 void World::updateHighscores(int* best_highscore_rank)
 {
+    *best_highscore_rank = -1;
+
     if(!m_use_highscores) return;
 
     // Add times to highscore list. First compute the order of karts,
@@ -1309,6 +1291,7 @@ void World::updateHighscores(int* best_highscore_rank)
         {
             // no kart claimed to be in this position, most likely means
             // the kart location data is wrong
+
 #ifdef DEBUG
             Log::error("[World]", "Incorrect kart positions:");
             for (unsigned int i=0; i<m_karts.size(); i++ )
@@ -1331,49 +1314,39 @@ void World::updateHighscores(int* best_highscore_rank)
         Kart *k = (Kart*)m_karts[index[pos]].get();
 
         Highscores* highscores = getHighscores();
-        float highscore_value = RaceManager::get()->isLapTrialMode() ? static_cast<float>(getFinishedLapsOfKart(index[pos]))
-                                                                     : k->getFinishTime();
-        // The player is a local player, so there is a name:
-        int highscore_rank = highscores->addData(k->getIdent(), k->getController()->getName(), highscore_value);
 
-        if (highscore_rank > 0 && (*best_highscore_rank == -1 ||
-                                    highscore_rank < *best_highscore_rank))
+        int highscore_rank = 0;
+        // The player is a local player, so there is a name:
+        if (RaceManager::get()->isLapTrialMode())
         {
-            *best_highscore_rank = highscore_rank;
+            highscore_rank = highscores->addData(k->getIdent(),
+                                                 k->getController()->getName(),
+                                                 static_cast<float>(getFinishedLapsOfKart(index[pos])));
         }
-    } // next position
-
-    // Handle GP highscores
-    if (RaceManager::get()->getMajorMode() == RaceManager::MAJOR_MODE_GRAND_PRIX &&
-        RaceManager::get()->getNumOfTracks() == RaceManager::get()->getTrackNumber() + 1 &&
-        !RaceManager::get()->getGrandPrix().isRandomGP() &&
-        RaceManager::get()->getSkippedTracksInGP() == 0)
-    {
-        std::string gp_name = RaceManager::get()->getGrandPrix().getId();
-
-        for (unsigned int kart_id = 0; kart_id < RaceManager::get()->getNumberOfKarts(); kart_id++)
+        else
         {
-            // Only record times for local player karts and only if
-            // they finished the race
-            if (!m_karts[kart_id]->getController()->isLocalPlayerController() ||
-                !m_karts[kart_id]->hasFinishedRace() ||
-                m_karts[kart_id]->isEliminated())
-                continue;
-
-            // The original lap trial GP code was a mess. I'm not fixing it...
-            if (RaceManager::get()->isLapTrialMode())
-                continue;
+            highscore_rank = highscores->addData(k->getIdent(),
+                                                 k->getController()->getName(),
+                                                 k->getFinishTime()    );
+        }
+        
 
-            Kart *k = (Kart*)m_karts[kart_id].get();
-            float full_time = RaceManager::get()->getOverallTime(kart_id);
+        if (highscore_rank > 0)
+        {
+            if (*best_highscore_rank == -1 ||
+                highscore_rank < *best_highscore_rank)
+            {
+                *best_highscore_rank = highscore_rank;
+            }
 
-            Highscores* highscores = World::getWorld()->getGPHighscores();
-            // The player is a local player, so there is a name:
-            highscores->addGPData(k->getIdent(), k->getController()->getName(), gp_name, full_time);
-        } // for kart_id
-    } // Handle GP highscores
+            Highscores::setSortOrder(Highscores::SO_DEFAULT);
+            highscore_manager->sortHighscores(false);
 
+            highscore_manager->saveHighscores();
+        }
+    } // next position
     delete []index;
+
 }   // updateHighscores
 
 //-----------------------------------------------------------------------------
diff --git a/src/modes/world.hpp b/src/modes/world.hpp
index d259e535096..4351810bd6e 100644
--- a/src/modes/world.hpp
+++ b/src/modes/world.hpp
@@ -174,8 +174,6 @@ class World : public WorldStatus
 
     Phase m_scheduled_pause_phase;
 
-    bool m_snap_camera;
-
     /** Set when the world needs to be deleted but you can't do it immediately
      * because you are e.g. within World::update()
      */
diff --git a/src/network/protocols/ranking.cpp b/src/network/protocols/ranking.cpp
deleted file mode 100644
index 1662faa6bcb..00000000000
--- a/src/network/protocols/ranking.cpp
+++ /dev/null
@@ -1,488 +0,0 @@
-//
-//  SuperTuxKart - a fun racing game with go-kart
-//  Copyright (C) 2024 SuperTuxKart-Team
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 3
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-
-#include "network/protocols/ranking.hpp"
-#include "io/xml_node.hpp"
-#include "utils/log.hpp"
-#include "utils/time.hpp"
-#include <bitset>
-#include <cmath>
-#include <vector>
-
-namespace
-{
-    /* Ranking related variables */
-    // If updating the base points, update the base points distribution in DB
-    const double BASE_RANKING_POINTS    = 4000.0; // Given to a new player on 1st connection to a ranked server
-    const double BASE_RATING_DEVIATION  = 1000.0; // Given to a new player on 1st connection to a ranked server
-    const double MIN_RATING_DEVIATION   = 100.0; // A server cron job makes RD go up if a player is inactive
-    const double BASE_RD_PER_DISCONNECT = 15.0;
-    const double VAR_RD_PER_DISCONNECT  = 3.0;
-    const double MAX_SCALING_TIME       = 360.0;
-    const double BASE_POINTS_PER_SECOND = 0.25;
-    const double HANDICAP_OFFSET        = 2000.0;
-}
-
-
-//-----------------------------------------------------------------------------
-RankingEntry::RankingEntry(uint32_t online_id): online_id(online_id)
-{
-    raw_score = BASE_RANKING_POINTS;
-    score     = BASE_RANKING_POINTS - 3*BASE_RATING_DEVIATION + 3*MIN_RATING_DEVIATION;
-    max_score = BASE_RANKING_POINTS - 3*BASE_RATING_DEVIATION + 3*MIN_RATING_DEVIATION;
-    deviation = BASE_RATING_DEVIATION;
-    disconnects = 0;
-    races = 0;
-}
-
-//-----------------------------------------------------------------------------
-/** Compute the new player's rankings used in ranked servers
- */
-void Ranking::computeNewRankings(std::vector<RaceResultData>& data, bool time_trial)
-{
-    // TODO : go over the variables and look
-    //        for things that can be simplified away.
-    //        e.g. can new/prev be simplified ?
-
-    std::vector<RankingEntry*> ranking_data;
-    for (const auto& result: data)
-    {
-        auto it = m_entries.find(result.online_id);
-        if (it == m_entries.end())
-        {
-            Log::fatal("Ranking", "Failed to obtain the saved ranking for online id %u", result.online_id);
-            return;
-        }
-        auto it2 = m_old_entries.find(result.online_id);
-        if (it2 == m_old_entries.end())
-            m_old_entries[result.online_id] = it->second.entry;
-        ranking_data.push_back(&(it->second.entry));
-    }
-
-    std::vector<double> raw_scores_change;
-    std::vector<double> new_raw_scores;
-    std::vector<double> prev_raw_scores;
-    std::vector<double> prev_scores;
-    std::vector<double> new_rating_deviations;
-    std::vector<double> prev_rating_deviations;
-    std::vector<uint64_t> prev_disconnects; //bitflag
-    std::vector<int>    disconnects;
-
-    unsigned player_count = data.size();
-
-    // Initialize data vectors
-    for (unsigned i = 0; i < player_count; i++)
-    {
-        double prev_raw_score = ranking_data[i]->raw_score;
-        new_raw_scores.push_back(prev_raw_score);
-        prev_raw_scores.push_back(prev_raw_score);
-
-        prev_scores.push_back(ranking_data[i]->score);
-
-        double prev_deviation = ranking_data[i]->deviation;
-        new_rating_deviations.push_back(prev_deviation);
-        prev_rating_deviations.push_back(prev_deviation);
-
-        prev_disconnects.push_back(ranking_data[i]->disconnects);
-    }
- 
-    // Update some variables
-    for (unsigned i = 0; i < player_count; i++)
-    {
-        //First, update the number of ranked races
-        ranking_data[i]->races++;
-
-        // Update the number of disconnects
-        // We store the last 64 results as bit flags in a 64-bit int.
-        // This way, shifting flushes the oldest result.
-        ranking_data[i]->disconnects <<= 1;
-
-        if (data[i].is_eliminated)
-            ranking_data[i]->disconnects++;
-
-        // std::popcount is C++20 only
-        std::bitset<64> b(ranking_data[i]->disconnects);
-        disconnects.push_back(b.count());
-    }
-
-    // In this loop, considering the race as a set
-    // of head to head minimatches, we compute :
-    // I - Point changes for each ordered player pair.
-    //     In a (p1, p2) pair, only p1's rating is changed.
-    //     However, the loop will also go over (p2, p1).
-    //     Point changes can be assymetric.
-    // II - Rating deviation changes
-    for (unsigned i = 0; i < player_count; i++)
-    {
-        raw_scores_change.push_back(0.0);
-
-        double player1_raw_scores = new_raw_scores[i];
-        if (data[i].handicap)
-            player1_raw_scores -= HANDICAP_OFFSET;
-
-        // If the player has quitted before the race end,
-        // the time value will be incorrect, but it will not be used
-        double player1_time  = data[i].time;
-        double player1_rd = prev_rating_deviations[i];
-
-        // On a disconnect, increase RD once,
-        // no matter how many opponents
-        if (data[i].is_eliminated && disconnects[i] >= 3)
-            new_rating_deviations[i] =  prev_rating_deviations[i]
-                                      + BASE_RD_PER_DISCONNECT
-                                      + VAR_RD_PER_DISCONNECT * (disconnects[i] - 3);
-
-        // Loop over all opponents
-        for (unsigned j = 0; j < player_count; j++)
-        {
-            // Don't compare a player with himself
-            if (i == j)
-                continue;
-
-            // No change between two quitting players
-            if (data[i].is_eliminated && data[j].is_eliminated)
-                continue;
-
-            double diff, result, expected_result, ranking_importance, max_time;
-            diff = result = expected_result = ranking_importance = max_time = 0.0;
-
-            double player2_raw_scores = new_raw_scores[j];
-            if (data[j].handicap)
-                player2_raw_scores -= HANDICAP_OFFSET;
-
-            double player2_time = data[j].time;
-            double player2_rd = prev_rating_deviations[j];
-
-            // Each result can be viewed as new data helping to refine our previous
-            // estimates. But first, we need to assess how reliable this new data is
-            // compared to existing estimates.
-
-            bool handicap_used = (data[i].handicap || data[j].handicap);
-            double accuracy = computeDataAccuracy(player1_rd, player2_rd, player1_raw_scores, player2_raw_scores, player_count, handicap_used);
-
-            // Now that we've computed the reliability value,
-            // we can proceed with computing the points gained or lost
-
-            // Compute the result and race ranking importance
-
-            double mode_factor = getModeFactor(time_trial);
-
-            if (data[i].is_eliminated)
-            {
-                // Recurring disconnects are punished through
-                // increased RD and higher RD floor,
-                // not through higher raw score loss
-                result = 0.0;
-                player1_time = player2_time * 1.2; // for getTimeSpread
-            }
-            else if (data[j].is_eliminated)
-            {
-                result = 1.0;
-                player2_time = player1_time * 1.2;
-            }
-            else
-            {
-                result = computeH2HResult(player1_time, player2_time);
-            }
-
-            max_time = std::min(MAX_SCALING_TIME, std::max(player1_time, player2_time));
-
-            ranking_importance = accuracy * mode_factor * scalingValueForTime(max_time);
-
-            // Compute the expected result using an ELO-like function
-            diff = player2_raw_scores - player1_raw_scores;
-
-            expected_result = 1.0/ (1.0 + std::pow(10.0,
-                diff / (  BASE_RANKING_POINTS / 2.0
-                        * getModeSpread(time_trial)
-                        * getTimeSpread(std::min(player1_time, player2_time)))));
-
-            // Compute the ranking change
-            raw_scores_change[i] += ranking_importance * (result - expected_result);
-
-            // We now update the rating deviation. The change
-            // depends on the current RD, on the result's accuracy,
-            // on how expected the result was (upsets can increase RD)
-
-            // If there was a disconnect in this race, RD was handled once already
-            if (!data[i].is_eliminated) {
-                // First the RD reduction based on accuracy and current RD
-                double rd_change_factor = accuracy * 0.0016;
-                double rd_change = (-1) * prev_rating_deviations[i] * rd_change_factor;
-
-                // If the unexpected result happened, we add a RD increase
-                // TODO : more reliable would be accumulating an expected_result/result
-                // differential over time, weighted through relative RDs.
-                // If that differential goes high, then increase RD while decaying
-                // the differential. Some work needed to ensure sensible maths.
-                double upset = std::abs(result - expected_result);
-                if (upset > 0.5)
-                {
-                    // Renormalize so expected result 50% is 1.0 and expected result 100% is 0.0
-                    upset = 2.0 - 2 * upset;
-                    upset = std::max(0.02, upset);
-
-                    // If upsets happen at the rate predicted by expected score,
-                    // this won't prevent the rating deviation from going down.
-                    // However, if upsets are at least twice more frequent than expected, RD will go up.
-                    rd_change += MIN_RATING_DEVIATION * rd_change_factor / upset;
-                }
-
-                // Minimum RD will be handled after all iterative RD change have been done,
-                // so as to avoid the order in which player pairs are computed changing results.
-                new_rating_deviations[i] += rd_change;
-            }
-        }
-    }
-
-    // Don't merge it in the main loop as new_scores value are used there
-    for (unsigned i = 0; i < player_count; i++)
-    {
-        new_raw_scores[i] += raw_scores_change[i];
-        ranking_data[i]->raw_score = new_raw_scores[i];
-
-        // Ensure RD doesn't go below the RD floor.
-        // The minimum RD is increased in case of repeated disconnects
-        double disconnects_floor = 0;
-        if (disconnects[i] >= 3)
-        {
-            int n = disconnects[i] - 3;
-            disconnects_floor =   (disconnects[i] - 2) * BASE_RD_PER_DISCONNECT
-                                + VAR_RD_PER_DISCONNECT * (n * (n + 1)) / 2;
-        }
-        new_rating_deviations[i] = std::max(new_rating_deviations[i], MIN_RATING_DEVIATION + disconnects_floor);
-        ranking_data[i]->deviation = new_rating_deviations[i];
-
-        // Update the main public rating. At min RD, it is equal to the raw score.
-        ranking_data[i]->score = ranking_data[i]->raw_score - 3 * new_rating_deviations[i] + 3 * MIN_RATING_DEVIATION;
-        if (ranking_data[i]->score > ranking_data[i]->max_score)
-            ranking_data[i]->max_score = ranking_data[i]->score;
-    }
-}   // computeNewRankings
-
-
-//-----------------------------------------------------------------------------
-/** Returns the mode race importance factor,
- *  used to make ranking move slower in more random modes.
- */
-double Ranking::getModeFactor(bool time_trial)
-{
-    if (time_trial)
-        return 1.0;
-    return 0.75;
-}   // getModeFactor
-
-//-----------------------------------------------------------------------------
-/** Returns the mode spread factor, used so that a similar difference in
- *  skill will result in a similar ranking difference in more random modes.
- */
-double Ranking::getModeSpread(bool time_trial)
-{
-    if (time_trial)
-        return 1.0;
-
-    //TODO: For 2.0, it would be more sensible to simply use
-    // a different ranking for time-trial and normal races, as
-    // some players perform better in one mode than in the other,
-    // so an unified list is always going to be flawed. Trying to
-    // patch these flaws is never going to work well.
-    return 1.25;
-}   // getModeSpread
-
-//-----------------------------------------------------------------------------
-/** Returns the time spread factor.
- *  Short races are more random, so the expected result changes depending
- *  on race duration.
- * TODO: collect real-world data on the relationship between race duration and
- * the likelihood of winning of players, and fit the formula based on it.
- */
-double Ranking::getTimeSpread(double time)
-{
-    return sqrt(120.0 / time);
-}   // getTimeSpread
-
-//-----------------------------------------------------------------------------
-/** Compute the scaling value of a given time
- *  This is linear to race duration, getTimeSpread takes care
- *  of expecting a more random result in shorter races.
- */
-double Ranking::scalingValueForTime(double time)
-{
-    return time * BASE_POINTS_PER_SECOND;
-}   // scalingValueForTime
-
-//-----------------------------------------------------------------------------
-/** Computes the score of a head-to-head minimatch.
- *  If time difference > 2,5% ; the result is 1 (complete win of player 1)
- *  or 0 (complete loss of player 1)
- *  Otherwise, it is averaged between 0 and 1.
- */
-double Ranking::computeH2HResult(double player1_time, double player2_time)
-{
-    double max_time = std::max(player1_time, player2_time);
-    double min_time = std::min(player1_time, player2_time);
-
-    double result = (max_time - min_time) / (min_time / 20.0);
-    result = std::min(1.0, 0.5 + result);
-
-    if (player2_time <= player1_time)
-        result = 1.0 - result;
-
-    return result;
-}   // computeH2HResult
-
-//-----------------------------------------------------------------------------
-/** Computes a relative factor indicating how much informative value
- *  the new race result gives us.
- *
- *  For a player with a high own rating deviation, the current rating is unreliable
- *  so any new data holds more importance. This is crucial to allow reasonably
- *  fast rating convergence of new players, provided they play accurately rated opponents.
- *
- *  When the opponent has a high rating deviation, the expected scores are likely off.
- *  Therefore, the information from such a result is much less valuable.
- *
- *  We also reduce rating changes when the player ratings are very different, even
- *  after considering the uncertainties from rating deviation.
- *  This is multi-purpose :
- *   - With a very high rating difference, random race events (very poor luck, disconnects)
- *     are very likely to be the cause of any upset, so the rate of legitimate upsets is
- *     unreliable. No rating method is safe.
- *   - Attempting to "farm" much lower rated players against which a practical 100% winrate
- *     may be reached (outside of random events) becomes very ineffective. Instead,
- *     to gain rating points, the player has incentive to play well-rated opponents.
- *   - The primary goal is to ensure that two players of equal rating would be about
- *     evenly matched in head-to-head. If two strong players each beat a much weaker third
- *     player, very little information is gained on how a direct head-to-head between the
- *     strong players would go.
- *  For the purposes of this rating computation, we assume that the informational value
- *  of a race is roughly proportional to the likelihood of the weaker player winning.
- * 
- *  A downside of this method is that a legitimate loss to a much lower rated player won't
- *  change the rating much, but these are rare enough that it's better to miss them than
- *  to reward "farming" and to incorrectly reward wins due to external factors.
- *
- *  In a race with many players, a single event can have a significant impact on the
- *  results of all the H2H. To avoid races with high players count having too strong
- *  rating swings, we apply a modifier scaling down accuracy.
- *
- *  Finally, while handicap is allowed in ranked races and a rating offset is applied
- *  to keep expected results realistic (without incentivizing playing handicap-only),
- *  the results of such races are much less reliable.
- */
-double Ranking::computeDataAccuracy(double player1_rd, double player2_rd, double player1_scores, double player2_scores, int player_count, bool handicap_used)
-{
-    double accuracy = player1_rd / (sqrt(player2_rd) * sqrt(MIN_RATING_DEVIATION));
-
-    double strong_lowerbound = (player1_scores > player2_scores) ? player1_scores - 350 - (player1_rd/2)
-                                                                 : player2_scores - 350 - (player2_rd/2);
-    double weak_upperbound   = (player1_scores > player2_scores) ? player2_scores + 350 + (player2_rd/2)
-                                                                 : player1_scores + 350 + (player1_rd/2);
-
-    if (weak_upperbound < strong_lowerbound)
-    {
-        double diff = strong_lowerbound - weak_upperbound;
-        diff = diff / (BASE_RANKING_POINTS / 2.0);
-
-        // The expected result is that of the weaker player and is between 0 and 0.5
-        double expected_result = 1.0/ (1.0 + std::pow(10.0, diff));
-        expected_result = std::max(0.05, 2*expected_result);
-
-        accuracy *= expected_result;
-    }
-
-    // Reduce the importance of single h2h in a race with many players.
-    // The overall impact of a race with more players is still always bigger.
-    double player_count_modifier = 2.0 / sqrt((double) player_count);
-    accuracy *= player_count_modifier;
-
-    // Races with handicap are unreliable for ranking
-    if (handicap_used)
-        accuracy *= 0.25;
-
-    return accuracy;
-}
-
-//-----------------------------------------------------------------------------
-void Ranking::cleanup()
-{
-    std::map<uint32_t, RankingEntryAndProfile> new_entries;
-    for (const auto& pair: m_entries)
-    {
-        auto profile = pair.second.profile;
-        if (!profile.expired())
-            new_entries.insert(pair);
-    }
-    std::swap(new_entries, m_entries);
-}
-
-//-----------------------------------------------------------------------------
-void Ranking::fill(uint32_t online_id, const XMLNode* result, std::shared_ptr<NetworkPlayerProfile> npp)
-{
-    RankingEntry entry(online_id);
-    result->get("scores", &entry.score);
-    result->get("max-scores", &entry.max_score);
-    result->get("num-races-done", &entry.races);
-    result->get("raw-scores", &entry.raw_score);
-    result->get("rating-deviation", &entry.deviation);
-    result->get("disconnects", &entry.disconnects);
-    m_entries[online_id] = {entry, npp};
-}
-
-//-----------------------------------------------------------------------------
-bool Ranking::has(uint32_t online_id)
-{
-    auto it = m_entries.find(online_id);
-    if (it == m_entries.end())
-        return false;
-    if (it->second.profile.expired())
-        return false;
-    return true;
-}
-
-//-----------------------------------------------------------------------------
-double Ranking::getDelta(uint32_t online_id)
-{
-    auto it = m_old_entries.find(online_id);
-    if (it == m_old_entries.end())
-        return 0.;
-    auto it2 = m_entries.find(online_id);
-    if (it2 == m_entries.end())
-        return 0.;
-    double result = it2->second.entry.score - it->second.score;
-    m_old_entries.erase(it);
-    return result;
-}
-
-//-----------------------------------------------------------------------------
-const RankingEntry Ranking::getScores(uint32_t online_id) const
-{
-    return m_entries.at(online_id).entry;
-}
-
-//-----------------------------------------------------------------------------
-const RankingEntry Ranking::getTemporaryPenalizedScores(uint32_t online_id) const
-{
-    RankingEntry entry = m_entries.at(online_id).entry;
-    entry.score -= 200.0;
-    entry.raw_score -= 200.0;
-    entry.races += 1;
-    entry.disconnects <<= 1;
-    entry.disconnects += 1;
-    return entry;
-}
\ No newline at end of file
diff --git a/src/network/protocols/ranking.hpp b/src/network/protocols/ranking.hpp
deleted file mode 100644
index 0812045823e..00000000000
--- a/src/network/protocols/ranking.hpp
+++ /dev/null
@@ -1,82 +0,0 @@
-//
-//  SuperTuxKart - a fun racing game with go-kart
-//  Copyright (C) 2024 SuperTuxKart-Team
-//
-//  This program is free software; you can redistribute it and/or
-//  modify it under the terms of the GNU General Public License
-//  as published by the Free Software Foundation; either version 3
-//  of the License, or (at your option) any later version.
-//
-//  This program is distributed in the hope that it will be useful,
-//  but WITHOUT ANY WARRANTY; without even the implied warranty of
-//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//  GNU General Public License for more details.
-//
-//  You should have received a copy of the GNU General Public License
-//  along with this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-
-#ifndef RANKING_HPP
-#define RANKING_HPP
-
-#include <map>
-#include <memory>
-#include <vector>
-
-class XMLNode;
-class NetworkPlayerProfile;
-
-struct RankingEntry
-{
-    uint32_t online_id;
-    double raw_score;
-    double score;
-    double max_score;
-    double deviation;
-    uint64_t disconnects;
-    unsigned races;
-
-    RankingEntry(uint32_t online_id = -1);
-};
-
-struct RaceResultData {
-    uint32_t online_id;
-    bool is_eliminated;
-    double time;
-    bool handicap;
-};
-
-struct RankingEntryAndProfile
-{
-    RankingEntry entry;
-    std::weak_ptr<NetworkPlayerProfile> profile;
-};
-
-class Ranking
-{
-private:
-    // A map that stores the actual scores.
-    std::map<uint32_t, RankingEntryAndProfile> m_entries;
-
-    // A map that stores the score before the last series of computeNewRankings calls has started.
-    std::map<uint32_t, RankingEntry> m_old_entries;
-
-    static double getModeFactor(bool time_trial);
-    static double getModeSpread(bool time_trial);
-    static double getTimeSpread(double time);
-    static double scalingValueForTime(double time);
-    static double computeH2HResult(double player1_time, double player2_time);
-    static double computeDataAccuracy(double player1_rd, double player2_rd,
-                               double player1_scores, double player2_scores,
-                               int player_count, bool handicap_used);
-public:
-    void computeNewRankings(std::vector<RaceResultData>& data, bool time_trial);
-    void cleanup();
-    void fill(uint32_t online_id, const XMLNode* result, std::shared_ptr<NetworkPlayerProfile> npp);
-    bool has(uint32_t online_id);
-    double getDelta(uint32_t online_id);
-    const RankingEntry getScores(uint32_t online_id) const;
-    const RankingEntry getTemporaryPenalizedScores(uint32_t online_id) const;
-};
-
-#endif
\ No newline at end of file
diff --git a/src/network/protocols/server_lobby.cpp b/src/network/protocols/server_lobby.cpp
index c305d708fb5..447eb4c9fd6 100644
--- a/src/network/protocols/server_lobby.cpp
+++ b/src/network/protocols/server_lobby.cpp
@@ -41,7 +41,6 @@
 #include "network/protocols/connect_to_peer.hpp"
 #include "network/protocols/game_protocol.hpp"
 #include "network/protocols/game_events_protocol.hpp"
-#include "network/protocols/ranking.hpp"
 #include "network/race_event_manager.hpp"
 #include "network/server_config.hpp"
 #include "network/socket_address.hpp"
@@ -71,17 +70,20 @@ int ServerLobby::m_fixed_laps = -1;
 class SubmitRankingRequest : public Online::XMLRequest
 {
 public:
-    SubmitRankingRequest(const RankingEntry& entry,
+    SubmitRankingRequest(uint32_t online_id, double scores,
+                         double max_scores, unsigned num_races,
+                         double raw_scores, double rating_deviation,
+                         uint64_t disconnects,
                          const std::string& country_code)
         : XMLRequest(Online::RequestManager::HTTP_MAX_PRIORITY)
     {
-        addParameter("id", entry.online_id);
-        addParameter("scores", entry.score);
-        addParameter("max-scores", entry.max_score);
-        addParameter("num-races-done", entry.races);
-        addParameter("raw-scores", entry.raw_score);
-        addParameter("rating-deviation", entry.deviation);
-        addParameter("disconnects", entry.disconnects);
+        addParameter("id", online_id);
+        addParameter("scores", scores);
+        addParameter("max-scores", max_scores);
+        addParameter("num-races-done", num_races);
+        addParameter("raw-scores", raw_scores);
+        addParameter("rating-deviation", rating_deviation);
+        addParameter("disconnects", disconnects);
         addParameter("country-code", country_code);
     }
     virtual void afterOperation()
@@ -176,8 +178,6 @@ ServerLobby::ServerLobby() : LobbyProtocol()
         Log::info("ServerLobby", "This server will submit ranking scores to "
             "the STK addons server. Don't bother hosting one without the "
             "corresponding permissions, as they would be rejected.");
-
-        m_ranking = std::make_shared<Ranking>();
     }
     m_result_ns = getNetworkString();
     m_result_ns->setSynchronous(true);
@@ -478,23 +478,6 @@ void ServerLobby::handleChat(Event* event)
     core::stringw message;
     event->data().decodeString16(&message, 360/*max_len*/);
 
-    // Check if the message starts with "(the name of main profile): " to prevent
-    // impersonation, see #5121.
-    std::string message_utf8 = StringUtils::wideToUtf8(message);
-    std::string prefix = StringUtils::wideToUtf8(
-        event->getPeer()->getPlayerProfiles()[0]->getName()) + ": ";
-    
-    if (!StringUtils::startsWith(message_utf8, prefix))
-    {
-        NetworkString* chat = getNetworkString();
-        chat->setSynchronous(true);
-        core::stringw warn = "Don't try to impersonate others!";
-        chat->addUInt8(LE_CHAT).encodeString16(warn);
-        event->getPeer()->sendPacket(chat, true/*reliable*/);
-        delete chat;
-        return;
-    }
-
     KartTeam target_team = KART_TEAM_NONE;
     if (event->data().size() > 0)
         target_team = (KartTeam)event->data().getUInt8();
@@ -799,7 +782,7 @@ void ServerLobby::asynchronousUpdate()
     updateServerOwner();
 
     if (ServerConfig::m_ranked && m_state.load() == WAITING_FOR_START_GAME)
-        m_ranking->cleanup();
+        clearDisconnectedRankedPlayer();
 
     if (allowJoinedPlayersWaiting() || (m_game_setup->isGrandPrix() &&
         m_state.load() == WAITING_FOR_START_GAME))
@@ -891,14 +874,9 @@ void ServerLobby::asynchronousUpdate()
     {
         if (ServerConfig::m_owner_less)
         {
-            // Ensure that a game can auto-start if the server meets the config's starting limit or if it's already full.
-            int starting_limit = std::min((int)ServerConfig::m_min_start_game_players, (int)ServerConfig::m_server_max_players);
-            if (ServerConfig::m_max_players_in_game > 0) // 0 here means it's not the limit
-                starting_limit = std::min(starting_limit, (int)ServerConfig::m_max_players_in_game);
-
             unsigned players = 0;
             STKHost::get()->updatePlayers(&players);
-            if (((int)players >= starting_limit ||
+            if (((int)players >= ServerConfig::m_min_start_game_players ||
                 m_game_setup->isGrandPrixStarted()) &&
                 m_timeout.load() == std::numeric_limits<int64_t>::max())
             {
@@ -906,7 +884,7 @@ void ServerLobby::asynchronousUpdate()
                     (int64_t)
                     (ServerConfig::m_start_game_counter * 1000.0f));
             }
-            else if ((int)players < starting_limit &&
+            else if ((int)players < ServerConfig::m_min_start_game_players &&
                 !m_game_setup->isGrandPrixStarted())
             {
                 resetPeersReady();
@@ -916,7 +894,7 @@ void ServerLobby::asynchronousUpdate()
             }
             if (m_timeout.load() < (int64_t)StkTime::getMonoTimeMs() ||
                 (checkPeersReady(true/*ignore_ai_peer*/) &&
-                (int)players >= starting_limit))
+                (int)players >= ServerConfig::m_min_start_game_players))
             {
                 resetPeersReady();
                 startSelection();
@@ -2363,14 +2341,28 @@ void ServerLobby::checkRaceFinished()
  */
 void ServerLobby::computeNewRankings()
 {
+    // TODO : go over the variables and look
+    //        for things that can be simplified away.
+    //        e.g. can new/prev be simplified ?
+
     // No ranking for battle mode
     if (!RaceManager::get()->modeHasLaps())
         return;
 
+    std::vector<double> raw_scores_change;
+    std::vector<double> new_raw_scores;
+    std::vector<double> prev_raw_scores;
+    std::vector<double> prev_scores;
+    std::vector<double> new_rating_deviations;
+    std::vector<double> prev_rating_deviations;
+    std::vector<uint64_t> prev_disconnects; //bitflag
+    std::vector<int>    disconnects;
+
     World* w = World::getWorld();
     assert(w);
 
     unsigned player_count = RaceManager::get()->getNumPlayers();
+    m_result_ns->addUInt8((uint8_t)player_count);
 
     // If all players quitted the race, we assume something went wrong
     // and skip entirely rating and statistics updates.
@@ -2381,32 +2373,347 @@ void ServerLobby::computeNewRankings()
         if ((i + 1) == player_count)
             return;
     }
-    
-    // Fill the results for the rankings to process
-    std::vector<RaceResultData> data;
+
+    // Initialize data vectors
     for (unsigned i = 0; i < player_count; i++)
     {
-        RaceResultData entry;
-        entry.online_id = RaceManager::get()->getKartInfo(i).getOnlineId();
-        entry.is_eliminated = w->getKart(i)->isEliminated();
-        entry.time = RaceManager::get()->getKartRaceTime(i);
-        entry.handicap = w->getKart(i)->getHandicap();
-        data.push_back(entry);
+        const uint32_t id = RaceManager::get()->getKartInfo(i).getOnlineId();
+        double prev_raw_score = m_raw_scores.at(id);
+        new_raw_scores.push_back(prev_raw_score);
+        prev_raw_scores.push_back(prev_raw_score);
+
+        prev_scores.push_back(m_scores.at(id));
+
+        double prev_deviation = m_rating_deviations.at(id);
+        new_rating_deviations.push_back(prev_deviation);
+        prev_rating_deviations.push_back(prev_deviation);
+
+        prev_disconnects.push_back(m_num_ranked_disconnects.at(id));
     }
+ 
+    // Update some variables
+    for (unsigned i = 0; i < player_count; i++)
+    {
+        const uint32_t id = RaceManager::get()->getKartInfo(i).getOnlineId();
+
+        //First, update the number of ranked races
+        m_num_ranked_races.at(id)++;
+
+        // Update the number of disconnects
+        // We store the last 64 results as bit flags in a 64-bit int.
+        // This way, shifting flushes the oldest result.
+        m_num_ranked_disconnects.at(id) <<= 1;
+
+        if (w->getKart(i)->isEliminated())
+            m_num_ranked_disconnects.at(id)++;
+
+        // std::popcount is C++20 only
+        std::bitset<64> b(m_num_ranked_disconnects.at(id));
+        disconnects.push_back(b.count());
+    }
+
+    // In this loop, considering the race as a set
+    // of head to head minimatches, we compute :
+    // I - Point changes for each ordered player pair.
+    //     In a (p1, p2) pair, only p1's rating is changed.
+    //     However, the loop will also go over (p2, p1).
+    //     Point changes can be assymetric.
+    // II - Rating deviation changes
+    for (unsigned i = 0; i < player_count; i++)
+    {
+        raw_scores_change.push_back(0.0);
+
+        double player1_raw_scores = new_raw_scores[i];
+        if (w->getKart(i)->getHandicap())
+            player1_raw_scores -= HANDICAP_OFFSET;
+
+        // If the player has quitted before the race end,
+        // the time value will be incorrect, but it will not be used
+        double player1_time  = RaceManager::get()->getKartRaceTime(i);
+        double player1_rd = prev_rating_deviations[i];
+
+        // On a disconnect, increase RD once,
+        // no matter how many opponents
+        if (w->getKart(i)->isEliminated() && disconnects[i] >= 3)
+            new_rating_deviations[i] =  prev_rating_deviations[i]
+                                      + BASE_RD_PER_DISCONNECT
+                                      + VAR_RD_PER_DISCONNECT * (disconnects[i] - 3);
+
+        // Loop over all opponents
+        for (unsigned j = 0; j < player_count; j++)
+        {
+            // Don't compare a player with himself
+            if (i == j)
+                continue;
+
+            // No change between two quitting players
+            if (   w->getKart(i)->isEliminated()
+                && w->getKart(j)->isEliminated())
+                continue;
+
+            double diff, result, expected_result, ranking_importance, max_time;
+            diff = result = expected_result = ranking_importance = max_time = 0.0;
+
+            double player2_raw_scores = new_raw_scores[j];
+            if (w->getKart(j)->getHandicap())
+                player2_raw_scores -= HANDICAP_OFFSET;
+
+            double player2_time = RaceManager::get()->getKartRaceTime(j);
+            double player2_rd = prev_rating_deviations[j];
+
+            // Each result can be viewed as new data helping to refine our previous
+            // estimates. But first, we need to assess how reliable this new data is
+            // compared to existing estimates.
+
+            bool handicap_used = w->getKart(i)->getHandicap() || w->getKart(j)->getHandicap();
+            double accuracy = computeDataAccuracy(player1_rd, player2_rd, player1_raw_scores, player2_raw_scores, player_count, handicap_used);
+
+            // Now that we've computed the reliability value,
+            // we can proceed with computing the points gained or lost
+
+            // Compute the result and race ranking importance
+
+            double mode_factor = getModeFactor();
+
+            if (w->getKart(i)->isEliminated())
+            {
+                // Recurring disconnects are punished through
+                // increased RD and higher RD floor,
+                // not through higher raw score loss
+                result = 0.0;
+                player1_time = player2_time * 1.2; // for getTimeSpread
+            }
+            else if (w->getKart(j)->isEliminated())
+            {
+                result = 1.0;
+                player2_time = player1_time * 1.2;
+            }
+            else
+            {
+                result = computeH2HResult(player1_time, player2_time);
+            }
+
+            max_time = std::min(MAX_SCALING_TIME, std::max(player1_time, player2_time));
+
+            ranking_importance = accuracy * mode_factor * scalingValueForTime(max_time);
+
+            // Compute the expected result using an ELO-like function
+            diff = player2_raw_scores - player1_raw_scores;
+
+            expected_result = 1.0/ (1.0 + std::pow(10.0,
+                diff / (  BASE_RANKING_POINTS / 2.0
+                        * getModeSpread()
+                        * getTimeSpread(std::min(player1_time, player2_time)))));
+
+            // Compute the ranking change
+            raw_scores_change[i] += ranking_importance * (result - expected_result);
+
+            // We now update the rating deviation. The change
+            // depends on the current RD, on the result's accuracy,
+            // on how expected the result was (upsets can increase RD)
+
+            // If there was a disconnect in this race, RD was handled once already
+            if (!w->getKart(i)->isEliminated()) {
+                // First the RD reduction based on accuracy and current RD
+                double rd_change_factor = accuracy * 0.0016;
+                double rd_change = (-1) * prev_rating_deviations[i] * rd_change_factor;
+
+                // If the unexpected result happened, we add a RD increase
+                // TODO : more reliable would be accumulating an expected_result/result
+                // differential over time, weighted through relative RDs.
+                // If that differential goes high, then increase RD while decaying
+                // the differential. Some work needed to ensure sensible maths.
+                double upset = std::abs(result - expected_result);
+                if (upset > 0.5)
+                {
+                    // Renormalize so expected result 50% is 1.0 and expected result 100% is 0.0
+                    upset = 2.0 - 2 * upset;
+                    upset = std::max(0.02, upset);
+
+                    // If upsets happen at the rate predicted by expected score,
+                    // this won't prevent the rating deviation from going down.
+                    // However, if upsets are at least twice more frequent than expected, RD will go up.
+                    rd_change += MIN_RATING_DEVIATION * rd_change_factor / upset;
+                }
+
+                // Minimum RD will be handled after all iterative RD change have been done,
+                // so as to avoid the order in which player pairs are computed changing results.
+                new_rating_deviations[i] += rd_change;
+            }
+        }
+    }
+
+    // Don't merge it in the main loop as new_scores value are used there
+    for (unsigned i = 0; i < player_count; i++)
+    {
+        new_raw_scores[i] += raw_scores_change[i];
+        const uint32_t id = RaceManager::get()->getKartInfo(i).getOnlineId();
+        m_raw_scores.at(id) = new_raw_scores[i];
+
+        // Ensure RD doesn't go below the RD floor.
+        // The minimum RD is increased in case of repeated disconnects
+        double disconnects_floor = 0;
+        if (disconnects[i] >= 3)
+        {
+            int n = disconnects[i] - 3;
+            disconnects_floor =   (disconnects[i]-2) * BASE_RD_PER_DISCONNECT
+                                + VAR_RD_PER_DISCONNECT * (n * (n+1)) / 2;
+        }
+        new_rating_deviations[i] = std::max(new_rating_deviations[i], MIN_RATING_DEVIATION + disconnects_floor);
+        m_rating_deviations.at(id) = new_rating_deviations[i];
 
-    for (int i = 0; i < 64; ++i) {
-        m_ranking->computeNewRankings(data, RaceManager::get()->isTimeTrialMode());
+        // Update the main public rating. At min RD, it is equal to the raw score.
+        m_scores.at(id) = m_raw_scores.at(id) - 3*new_rating_deviations[i] + 3*MIN_RATING_DEVIATION;
+        if (m_scores.at(id) > m_max_scores.at(id))
+            m_max_scores.at(id) = m_scores.at(id);
     }
 
     // Used to display rating change at the end of a race
-    m_result_ns->addUInt8((uint8_t)player_count);
     for (unsigned i = 0; i < player_count; i++)
     {
         const uint32_t id = RaceManager::get()->getKartInfo(i).getOnlineId();
-        double change = m_ranking->getDelta(id);
+        double change = m_scores.at(id) - prev_scores[i];
         m_result_ns->addFloat((float)change);
     }
 }   // computeNewRankings
+
+
+//-----------------------------------------------------------------------------
+/** Returns the mode race importance factor,
+ *  used to make ranking move slower in more random modes.
+ */
+double ServerLobby::getModeFactor()
+{
+    if (RaceManager::get()->isTimeTrialMode())
+        return 1.0;
+    return 0.75;
+}   // getModeFactor
+
+//-----------------------------------------------------------------------------
+/** Returns the mode spread factor, used so that a similar difference in
+ *  skill will result in a similar ranking difference in more random modes.
+ */
+double ServerLobby::getModeSpread()
+{
+    if (RaceManager::get()->isTimeTrialMode())
+        return 1.0;
+
+    //TODO: the value used here for normal races is a wild guess.
+    // When hard data to the spread tendencies of time-trial
+    // and normal mode becomes available, update this to make
+    // the spreads more comparable
+    return 1.25;
+}   // getModeSpread
+
+//-----------------------------------------------------------------------------
+/** Returns the time spread factor.
+ *  Short races are more random, so the expected result changes depending
+ *  on race duration.
+ */
+double ServerLobby::getTimeSpread(double time)
+{
+    return sqrt(120.0 / time);
+}   // getTimeSpread
+
+//-----------------------------------------------------------------------------
+/** Compute the scaling value of a given time
+ *  This is linear to race duration, getTimeSpread takes care
+ *  of expecting a more random result in shorter races.
+ */
+double ServerLobby::scalingValueForTime(double time)
+{
+    return time * BASE_POINTS_PER_SECOND;
+}   // scalingValueForTime
+
+//-----------------------------------------------------------------------------
+/** Computes the score of a head-to-head minimatch.
+ *  If time difference > 2,5% ; the result is 1 (complete win of player 1)
+ *  or 0 (complete loss of player 1)
+ *  Otherwise, it is averaged between 0 and 1.
+ */
+double ServerLobby::computeH2HResult(double player1_time, double player2_time)
+{
+    double max_time = std::max(player1_time, player2_time);
+    double min_time = std::min(player1_time, player2_time);
+
+    double result = (max_time - min_time) / (min_time / 20.0);
+    result = std::min(1.0, 0.5 + result);
+
+    if (player2_time <= player1_time)
+        result = 1.0 - result;
+
+    return result;
+}   // computeH2HResult
+
+//-----------------------------------------------------------------------------
+/** Computes a relative factor indicating how much informative value
+ *  the new race result gives us.
+ *
+ *  For a player with a high own rating deviation, the current rating is unreliable
+ *  so any new data holds more importance. This is crucial to allow reasonably
+ *  fast rating convergence of new players, provided they play accurately rated opponents.
+ *
+ *  When the opponent has a high rating deviation, the expected scores are likely off.
+ *  Therefore, the information from such a result is much less valuable.
+ *
+ *  We also reduce rating changes when the player ratings are very different, even
+ *  after considering the uncertainties from rating deviation.
+ *  This is multi-purpose :
+ *   - With a very high rating difference, random race events (very poor luck, disconnects)
+ *     are very likely to be the cause of any upset, so the rate of legitimate upsets is
+ *     unreliable. No rating method is safe.
+ *   - Attempting to "farm" much lower rated players against which a practical 100% winrate
+ *     may be reached (outside of random events) becomes very ineffective. Instead,
+ *     to gain rating points, the player has incentive to play well-rated opponents.
+ *   - The primary goal is to ensure that two players of equal rating would be about
+ *     evenly matched in head-to-head. If two strong players each beat a much weaker third
+ *     player, very little information is gained on how a direct head-to-head between the
+ *     strong players would go.
+ *  For the purposes of this rating computation, we assume that the informational value
+ *  of a race is roughly proportional to the likelihood of the weaker player winning.
+ *  We cap the effect so that losing to a much weaker player still costs rating points.
+ *
+ *  In a race with many players, a single event can have a significant impact on the
+ *  results of all the H2H. To avoid races with high players count having too strong
+ *  rating swings, we apply a modifier scaling down accuracy.
+ *
+ *  Finally, while handicap is allowed in ranked races and a rating offset is applied
+ *  to keep expected results realistic (without incentivizing playing handicap-only),
+ *  the results of such races are much less reliable.
+ */
+double ServerLobby::computeDataAccuracy(double player1_rd, double player2_rd, double player1_scores, double player2_scores, int player_count, bool handicap_used)
+{
+    double accuracy = player1_rd / (sqrt(player2_rd) * sqrt(MIN_RATING_DEVIATION));
+
+    double strong_lowerbound = (player1_scores > player2_scores) ? player1_scores - 3 * player1_rd
+                                                                 : player2_scores - 3 * player2_rd;
+    double weak_upperbound   = (player1_scores > player2_scores) ? player2_scores + 3 * player2_rd
+                                                                 : player1_scores + 3 * player1_rd;
+
+    if (weak_upperbound < strong_lowerbound)
+    {
+        double diff = strong_lowerbound - weak_upperbound;
+        diff = diff / (BASE_RANKING_POINTS / 2.0);
+
+        // The expected result is that of the weaker player and is between 0 and 0.5
+        double expected_result = 1.0/ (1.0 + std::pow(10.0, diff));
+        expected_result = std::max(0.2, sqrt(2*expected_result));
+
+        accuracy *= expected_result;
+    }
+
+    // Reduce the importance of single h2h in a race with many players.
+    // The overall impact of a race with more players is still always bigger.
+    double player_count_modifier = 2.0 / sqrt((double) player_count);
+    accuracy *= player_count_modifier;
+
+    // Races with handicap are unreliable for ranking
+    if (handicap_used)
+        accuracy *= 0.25;
+
+    return accuracy;
+}
+
 //-----------------------------------------------------------------------------
 /** Called when a client disconnects.
  *  \param event The disconnect event.
@@ -2449,6 +2756,29 @@ void ServerLobby::clientDisconnected(Event* event)
 #endif
 }   // clientDisconnected
 
+//-----------------------------------------------------------------------------
+void ServerLobby::clearDisconnectedRankedPlayer()
+{
+    for (auto it = m_ranked_players.begin(); it != m_ranked_players.end();)
+    {
+        if (it->second.expired())
+        {
+            const uint32_t id = it->first;
+            m_scores.erase(id);
+            m_max_scores.erase(id);
+            m_num_ranked_races.erase(id);
+            m_raw_scores.erase(id);
+            m_rating_deviations.erase(id);
+            m_num_ranked_disconnects.erase(id);
+            it = m_ranked_players.erase(it);
+        }
+        else
+        {
+            it++;
+        }
+    }
+}   // clearDisconnectedRankedPlayer
+
 //-----------------------------------------------------------------------------
 void ServerLobby::kickPlayerWithReason(STKPeer* peer, const char* reason) const
 {
@@ -3574,17 +3904,42 @@ void ServerLobby::getRankingForPlayer(std::shared_ptr<NetworkPlayerProfile> p)
     const XMLNode* result = request->getXMLData();
     std::string rec_success;
 
-    bool success = false;
+    // Default result
+    double raw_score = BASE_RANKING_POINTS;
+    double score     = BASE_RANKING_POINTS - 3*BASE_RATING_DEVIATION + 3*MIN_RATING_DEVIATION;
+    double max_score = BASE_RANKING_POINTS - 3*BASE_RATING_DEVIATION + 3*MIN_RATING_DEVIATION;
+    unsigned num_races = 0;
+    double rating_deviation = BASE_RATING_DEVIATION;
+    uint64_t disconnects = 0;
     if (result->get("success", &rec_success))
+    {
         if (rec_success == "yes")
-            success = true;
-
-    if (!success)
+        {
+            result->get("scores", &score);
+            result->get("max-scores", &max_score);
+            result->get("num-races-done", &num_races);
+            result->get("raw-scores", &raw_score);
+            result->get("rating-deviation", &rating_deviation);
+            result->get("disconnects", &disconnects);
+        }
+        else
+        {
+            Log::error("ServerLobby", "No ranking info found for player %s.",
+                StringUtils::wideToUtf8(p->getName()).c_str());
+            // Kick the player to avoid his score being reset in case
+            // connection to stk addons is broken
+            auto peer = p->getPeer();
+            if (peer)
+            {
+                peer->kick();
+                return;
+            }
+        }
+    }
+    else
     {
         Log::error("ServerLobby", "No ranking info found for player %s.",
             StringUtils::wideToUtf8(p->getName()).c_str());
-        // Kick the player to avoid his score being reset in case
-        // connection to stk addons is broken
         auto peer = p->getPeer();
         if (peer)
         {
@@ -3592,7 +3947,13 @@ void ServerLobby::getRankingForPlayer(std::shared_ptr<NetworkPlayerProfile> p)
             return;
         }
     }
-    m_ranking->fill(id, result, p);
+    m_ranked_players[id] = p;
+    m_scores[id] = score;
+    m_max_scores[id] = max_score;
+    m_num_ranked_races[id] = num_races;
+    m_raw_scores[id] = raw_score;
+    m_rating_deviations[id] = rating_deviation;
+    m_num_ranked_disconnects[id] = disconnects;
 }   // getRankingForPlayer
 
 //-----------------------------------------------------------------------------
@@ -3605,14 +3966,16 @@ void ServerLobby::submitRankingsToAddons()
     for (unsigned i = 0; i < RaceManager::get()->getNumPlayers(); i++)
     {
         const uint32_t id = RaceManager::get()->getKartInfo(i).getOnlineId();
-        const RankingEntry& scores = m_ranking->getScores(id);
         auto request = std::make_shared<SubmitRankingRequest>
-            (scores, RaceManager::get()->getKartInfo(i).getCountryCode());
+            (id, m_scores.at(id), m_max_scores.at(id),
+            m_num_ranked_races.at(id), m_raw_scores.at(id),
+            m_rating_deviations.at(id), m_num_ranked_disconnects.at(id),
+            RaceManager::get()->getKartInfo(i).getCountryCode());
         NetworkConfig::get()->setUserDetails(request, "submit-ranking");
-        Log::info("ServerLobby", "Submitting ranking for %s (%d) : %lf, %lf %d",
+        Log::info("ServerLobby", "Submiting ranking for %s (%d) : %lf, %lf %d",
             StringUtils::wideToUtf8(
             RaceManager::get()->getKartInfo(i).getPlayerName()).c_str(), id,
-            scores.score, scores.max_score, scores.races);
+            m_scores.at(id), m_max_scores.at(id), m_num_ranked_races.at(id));
         request->queue();
     }
 }   // submitRankingsToAddons
@@ -3723,7 +4086,10 @@ void ServerLobby::addWaitingPlayersToGame()
             }
         }
         uint32_t online_id = profile->getOnlineId();
-        if (ServerConfig::m_ranked && !m_ranking->has(online_id))
+        if (ServerConfig::m_ranked &&
+            (m_ranked_players.find(online_id) == m_ranked_players.end() ||
+            (m_ranked_players.find(online_id) != m_ranked_players.end() &&
+            m_ranked_players.at(online_id).expired())))
         {
             getRankingForPlayer(peer->getPlayerProfiles()[0]);
         }
@@ -4075,9 +4441,12 @@ void ServerLobby::handlePlayerDisconnection() const
                 // Real score will be submitted later in computeNewRankings
                 const uint32_t id =
                     RaceManager::get()->getKartInfo(i).getOnlineId();
-                RankingEntry penalized = m_ranking->getTemporaryPenalizedScores(id);
+                unsigned num_races = m_num_ranked_races.at(id);
+                uint64_t disconnects = m_num_ranked_disconnects.at(id) << 1;
                 auto request = std::make_shared<SubmitRankingRequest>
-                    (penalized,
+                    (id, m_scores.at(id) - 200.0, m_max_scores.at(id),
+                    ++num_races, m_raw_scores.at(id) - 200.0,
+                    m_rating_deviations.at(id), ++disconnects,
                     RaceManager::get()->getKartInfo(i).getCountryCode());
                 NetworkConfig::get()->setUserDetails(request,
                     "submit-ranking");
@@ -4377,12 +4746,7 @@ std::set<std::shared_ptr<STKPeer>> ServerLobby::getSpectatorsByLimit()
     auto peers = STKHost::get()->getPeers();
     std::set<std::shared_ptr<STKPeer>> always_spectate_peers;
 
-    unsigned player_limit = ServerConfig::m_server_max_players;
-    // If the server has an in-game player limit lower than the lobby limit, apply it,
-    // A value of 0 for this parameter means no limit.
-    if (ServerConfig::m_max_players_in_game > 0)
-        player_limit = std::min(player_limit, (unsigned)ServerConfig::m_max_players_in_game);
-
+    unsigned player_limit = ServerConfig::m_max_players_in_game;
     // only 10 players allowed for battle or soccer
     if (RaceManager::get()->isBattleMode() || RaceManager::get()->isSoccerMode())
         player_limit = std::min(player_limit, 10u);
diff --git a/src/network/protocols/server_lobby.hpp b/src/network/protocols/server_lobby.hpp
index 0c5998eeb9b..fc18cfeca43 100644
--- a/src/network/protocols/server_lobby.hpp
+++ b/src/network/protocols/server_lobby.hpp
@@ -41,7 +41,6 @@ class NetworkString;
 class NetworkPlayerProfile;
 class STKPeer;
 class SocketAddress;
-class Ranking;
 
 namespace Online
 {
@@ -155,7 +154,39 @@ class ServerLobby : public LobbyProtocol
 
     std::map<std::string, uint64_t> m_pending_peer_connection;
 
-    std::shared_ptr<Ranking> m_ranking;
+    /* Ranking related variables */
+    // If updating the base points, update the base points distribution in DB
+    const double BASE_RANKING_POINTS    = 4000.0; // Given to a new player on 1st connection to a ranked server
+    const double BASE_RATING_DEVIATION  = 1000.0; // Given to a new player on 1st connection to a ranked server
+    const double MIN_RATING_DEVIATION   = 100.0; // A server cron job makes RD go up if a player is inactive
+    const double BASE_RD_PER_DISCONNECT = 15.0;
+    const double VAR_RD_PER_DISCONNECT  = 3.0;
+    const double MAX_SCALING_TIME       = 360.0;
+    const double BASE_POINTS_PER_SECOND = 0.18;
+    const double HANDICAP_OFFSET        = 2000.0;
+
+    /** Online id to profile map, handling disconnection in ranked server */
+    std::map<uint32_t, std::weak_ptr<NetworkPlayerProfile> > m_ranked_players;
+
+    /** Multi-session rating for each current player */
+    std::map<uint32_t, double> m_raw_scores;
+
+    /** The rating uncertainty for each current player */
+    std::map<uint32_t, double> m_rating_deviations;
+
+    /** A single number compounding "raw score" and RD,
+      * for rating display to players and rankings */
+    std::map<uint32_t, double> m_scores;
+
+    /** The maximum rating obtained for each current player.
+      * This is based on m_scores, not m_raw_scores */
+    std::map<uint32_t, double> m_max_scores;
+
+    /** Number of disconnects in the previous 64 ranked races for each current players */
+    std::map<uint32_t, uint64_t> m_num_ranked_disconnects;
+
+    /** Number of ranked races done for each current players */
+    std::map<uint32_t, unsigned> m_num_ranked_races;
 
     /* Saved the last game result */
     NetworkString* m_result_ns;
@@ -275,6 +306,16 @@ class ServerLobby : public LobbyProtocol
     void getRankingForPlayer(std::shared_ptr<NetworkPlayerProfile> p);
     void submitRankingsToAddons();
     void computeNewRankings();
+    void clearDisconnectedRankedPlayer();
+    double getModeFactor();
+    double getModeSpread();
+    double getTimeSpread(double time);
+    double getUncertaintySpread(uint32_t online_id);
+    double scalingValueForTime(double time);
+    double computeH2HResult(double player1_time, double player2_time);
+    double computeDataAccuracy(double player1_rd, double player2_rd,
+                               double player1_scores, double player2_scores,
+                               int player_count, bool handicap_used);
     void checkRaceFinished();
     void getHitCaptureLimit();
     void configPeersStartTime();
diff --git a/src/network/server_config.cpp b/src/network/server_config.cpp
index c58bfe63905..5d22927a1ff 100644
--- a/src/network/server_config.cpp
+++ b/src/network/server_config.cpp
@@ -341,10 +341,8 @@ void loadServerLobbyFromConfig()
         m_server_max_players > 10)
         m_server_max_players = 10;
 
-    // Parameters should only be sanity checked, not modified for interpretation (see #5173).
-    // A parameter of 0 here means no limit is to be applied.
-    if (m_max_players_in_game < 0)
-        m_max_players_in_game = 0;
+    m_max_players_in_game = (m_max_players_in_game <= 0) ? m_server_max_players :
+        std::min(m_max_players_in_game, m_server_max_players);
 
     if (m_ipv6_connection)
     {
@@ -362,6 +360,8 @@ void loadServerLobbyFromConfig()
     }
     if (m_owner_less)
     {
+        if (m_min_start_game_players > m_max_players_in_game)
+            m_min_start_game_players = 1;
         if (!m_live_players)
             m_team_choosing = false;
         m_server_configurable = false;
diff --git a/src/race/race_manager.cpp b/src/race/race_manager.cpp
index f58d51985c3..3feb801962e 100644
--- a/src/race/race_manager.cpp
+++ b/src/race/race_manager.cpp
@@ -138,6 +138,7 @@ RaceManager::RaceManager()
     m_flag_deactivated_ticks = stk_config->time2Ticks(3.0f);
     m_skipped_tracks_in_gp = 0;
     m_gp_time_target = 0.0f;
+    m_gp_total_laps = 0;
     setMaxGoal(0);
     setTimeTarget(0.0f);
     setReverseTrack(false);
@@ -316,6 +317,15 @@ void RaceManager::setDifficulty(Difficulty diff)
     m_difficulty = diff;
 }   // setDifficulty
 
+//---------------------------------------------------------------------------------------------
+/** Sets the difficulty to use.
+ *  \param diff The difficulty to use.
+ */
+//void RaceManager::setTireCount(int tires)
+//{
+//    m_tire_count = tires;
+//}   // setDifficulty
+
 //---------------------------------------------------------------------------------------------
 /** Sets a single track to be used in the next race.
  *  \param track The identifier of the track to use.
@@ -431,7 +441,10 @@ void RaceManager::startNew(bool from_overworld)
                     m_skipped_tracks_in_gp = m_saved_gp->getSkippedTracks();
                     Log::info("RaceManager","%d",isLapTrialMode());
                     if (isLapTrialMode())
+                    {
                         m_gp_time_target = m_saved_gp->getTimeTarget();
+                        m_gp_total_laps = m_saved_gp->getPlayerTotalLaps();
+                    }
                 }   // if m_saved_gp==NULL
             }   // if m_continue_saved_gp
         }   // if !network_world
@@ -791,7 +804,7 @@ void RaceManager::saveGP()
             m_grand_prix.getReverseType(),
             m_skipped_tracks_in_gp,
             isLapTrialMode() ? m_gp_time_target : 0.0f,
-            0,
+            isLapTrialMode() ? m_gp_total_laps : 0,
             m_kart_status);
 
         // If a new GP is saved, delete any other saved data for this
@@ -1344,4 +1357,4 @@ void RaceManager::setBenchmarking(bool benchmark)
 void RaceManager::scheduleBenchmark()
 {
     m_scheduled_benchmark = true;
-}   // scheduleBenchmark
\ No newline at end of file
+}   // scheduleBenchmark
diff --git a/src/race/race_manager.hpp b/src/race/race_manager.hpp
index 18870138048..19682171c1a 100644
--- a/src/race/race_manager.hpp
+++ b/src/race/race_manager.hpp
@@ -300,6 +300,9 @@ class RaceManager
     /** The selected difficulty. */
     Difficulty                       m_difficulty;
 
+    /** The amount of starting tires. */
+    //int                              m_tire_count;
+
     /** The major mode (single race, GP). */
     MajorRaceModeType                m_major_mode;
 
@@ -600,6 +603,9 @@ class RaceManager
     /** Returns the difficulty. */
     Difficulty getDifficulty() const { return m_difficulty; }
     // ----------------------------------------------------------------------------------------
+    /** Returns the tire count for three strikes battle. */
+    //int getTireAmount() const { return m_tire_count; }
+    // ----------------------------------------------------------------------------------------
     /** Returns the specified difficulty as a string. */
     std::string getDifficultyAsString(Difficulty diff) const
     {
@@ -936,6 +942,10 @@ class RaceManager
     // ----------------------------------------------------------------------------------------
     void setGPTimeTarget(float time_target) { m_gp_time_target = time_target; }
     // ----------------------------------------------------------------------------------------
+    int getGPTotalLaps() const { return m_gp_total_laps; }
+    // ----------------------------------------------------------------------------------------
+    void addGPTotalLaps(int laps) { m_gp_total_laps += laps; }
+    // ----------------------------------------------------------------------------------------
     /** Whether the current game mode allow live joining even the current game
      *. started in network*/
     bool supportsLiveJoining() const
diff --git a/src/states_screens/dialogs/custom_video_settings.cpp b/src/states_screens/dialogs/custom_video_settings.cpp
index 738f9b0a79f..9aad0d9ba92 100644
--- a/src/states_screens/dialogs/custom_video_settings.cpp
+++ b/src/states_screens/dialogs/custom_video_settings.cpp
@@ -103,9 +103,7 @@ void CustomVideoSettingsDialog::beforeAddingWidgets()
     shadows->addLabel(_("Low"));        // 1
     shadows->addLabel(_("Medium"));     // 2
     shadows->addLabel(_("High"));       // 3
-    shadows->addLabel(_("Very High"));  // 4
-    shadows->setValue(UserConfigParams::m_shadows_resolution == 4096 ? 4 :
-                      UserConfigParams::m_shadows_resolution == 2048 ? 3 :
+    shadows->setValue(UserConfigParams::m_shadows_resolution == 2048 ? 3 :
                       UserConfigParams::m_shadows_resolution == 1024 ? 2 :
                       UserConfigParams::m_shadows_resolution ==  512 ? 1 : 0);
 
@@ -163,8 +161,7 @@ GUIEngine::EventPropagation CustomVideoSettingsDialog::processEvent(const std::s
                 UserConfigParams::m_shadows_resolution =
                     getWidget<SpinnerWidget>("shadows")->getValue() == 1 ?  512 :
                     getWidget<SpinnerWidget>("shadows")->getValue() == 2 ? 1024 :
-                    getWidget<SpinnerWidget>("shadows")->getValue() == 3 ? 2048 :
-                    getWidget<SpinnerWidget>("shadows")->getValue() == 4 ? 4096 : 0;
+                    getWidget<SpinnerWidget>("shadows")->getValue() == 3 ? 2048 : 0;
             }
             else
             {
diff --git a/src/states_screens/help/help_screen_1.cpp b/src/states_screens/help/help_screen_1.cpp
index eda76f31db2..bb6c6d5ba75 100644
--- a/src/states_screens/help/help_screen_1.cpp
+++ b/src/states_screens/help/help_screen_1.cpp
@@ -21,10 +21,6 @@
 #include "guiengine/widgets/button_widget.hpp"
 #include "modes/tutorial_utils.hpp"
 
-#ifdef ANDROID
-#include <SDL_system.h>
-#endif
-
 using namespace GUIEngine;
 
 // -----------------------------------------------------------------------------
@@ -41,22 +37,6 @@ void HelpScreen1::loadedFromFile()
 
 // -----------------------------------------------------------------------------
 
-void HelpScreen1::beforeAddingWidget()
-{
-#ifdef ANDROID
-    if (SDL_IsAndroidTV())
-    {
-        Widget* tutorial = getWidget("startTutorial");
-        if (tutorial)
-            tutorial->setVisible(false);
-
-        Widget* tutorial_icon = getWidget("tutorialIcon");
-        if (tutorial_icon)
-            tutorial_icon->setVisible(false);
-    }
-#endif
-}
-
 void HelpScreen1::eventCallback(Widget* widget, const std::string& name, const int playerID)
 {
     if (name == "startTutorial")
diff --git a/src/states_screens/help/help_screen_1.hpp b/src/states_screens/help/help_screen_1.hpp
index 2676718e49e..e517f721c73 100644
--- a/src/states_screens/help/help_screen_1.hpp
+++ b/src/states_screens/help/help_screen_1.hpp
@@ -35,9 +35,6 @@ class HelpScreen1 : public GUIEngine::Screen, public GUIEngine::ScreenSingleton<
 
     /** \brief implement callback from parent class GUIEngine::Screen */
     virtual void loadedFromFile() OVERRIDE;
-    
-    /** \brief implement callback from parent class GUIEngine::Screen */
-    virtual void beforeAddingWidget() OVERRIDE;
 
     /** \brief implement callback from parent class GUIEngine::Screen */
     virtual void eventCallback(GUIEngine::Widget* widget, const std::string& name,
diff --git a/src/states_screens/kart_selection.cpp b/src/states_screens/kart_selection.cpp
index ac48e611fe5..e9cc2715bf2 100644
--- a/src/states_screens/kart_selection.cpp
+++ b/src/states_screens/kart_selection.cpp
@@ -279,12 +279,12 @@ void KartSelectionScreen::beforeAddingWidget()
     );
     if (useContinueButton())
     {
-        getWidget("karts")->m_properties[GUIEngine::PROP_WIDTH] = "85%";
+        getWidget("kartlist")->m_properties[GUIEngine::PROP_WIDTH] = "85%";
         getWidget("continue")->setVisible(true);
     }
     else
     {
-        getWidget("karts")->m_properties[GUIEngine::PROP_WIDTH] = "100%";
+        getWidget("kartlist")->m_properties[GUIEngine::PROP_WIDTH] = "100%";
         getWidget("continue")->setVisible(false);
     }
     // Remove dispatcher from m_widgets before calculateLayout otherwise a
@@ -354,7 +354,7 @@ void KartSelectionScreen::beforeAddingWidget()
     kart_class->m_properties[GUIEngine::PROP_MIN_VALUE] = "0";
     kart_class->m_properties[GUIEngine::PROP_MAX_VALUE] = StringUtils::toString(classes.size());
     
-    for (unsigned int i = 0; i < classes.size(); i++)
+    for (int i = 0; i < classes.size(); i++)
     {
         // Make the first letter upper-case
         std::string class_str = classes[i];
@@ -418,6 +418,9 @@ void KartSelectionScreen::init()
 
     DynamicRibbonWidget* w = getWidget<DynamicRibbonWidget>("karts");
     assert( w != NULL );
+    // Only allow keyboard and gamepad to choose kart without continue button in
+    // multitouch GUI, so mouse (touch) clicking can be used as previewing karts
+    w->setEventCallbackActive(Input::IT_MOUSEBUTTON, !useContinueButton());
 
     KartHoverListener* karthoverListener = new KartHoverListener(this);
     w->registerHoverListener(karthoverListener);
@@ -522,10 +525,8 @@ void KartSelectionScreen::tearDown()
     m_kart_widgets.clearAndDeleteAll();
 
     if (m_must_delete_on_back)
-    {
-        elementsWereDeleted();
         GUIEngine::removeScreen(this);
-    }
+
 }   // tearDown
 
 // ----------------------------------------------------------------------------
@@ -1214,9 +1215,9 @@ void KartSelectionScreen::eventCallback(Widget* widget,
         assert(w != NULL);
         const std::string selection = w->getSelectionIDString(player_id);
 
-        if (getWidget<CheckBoxWidget>("favorite")->getState() &&
-            player_id == PLAYER_ID_GAME_MASTER &&
-            selection != RANDOM_KART_ID && !selection.empty())
+        if (getWidget<CheckBoxWidget>("favorite")->getState()
+         && player_id == PLAYER_ID_GAME_MASTER
+         && selection != RANDOM_KART_ID)
         {
             const KartProperties *kp = kart_properties_manager->getKart(selection);
 
@@ -1230,7 +1231,7 @@ void KartSelectionScreen::eventCallback(Widget* widget,
             }
             setKartsFromCurrentGroup();
         }
-        else if (m_kart_widgets.size() > unsigned(player_id) && !useContinueButton())
+        else if (m_kart_widgets.size() > unsigned(player_id))
             playerConfirm(player_id);
     }
     else if (name == "kart_class")
@@ -1632,7 +1633,7 @@ PtrVector<const KartProperties, REF> KartSelectionScreen::getUsableKarts(
             prop->getName().make_lower().find(search_text.c_str()) == -1)
             continue;
         
-        if (kart_class->getValue() != (int)classes.size() &&
+        if (kart_class->getValue() != classes.size() &&
             classes[kart_class->getValue()] != prop->getKartType())
             continue;
 
diff --git a/src/states_screens/main_menu_screen.cpp b/src/states_screens/main_menu_screen.cpp
index ccd4a461383..bb35a2d8d4d 100644
--- a/src/states_screens/main_menu_screen.cpp
+++ b/src/states_screens/main_menu_screen.cpp
@@ -72,10 +72,6 @@
 
 #include <IrrlichtDevice.h>
 
-#ifdef ANDROID
-#include <SDL_system.h>
-#endif
-
 using namespace GUIEngine;
 using namespace Online;
 
@@ -123,15 +119,6 @@ void MainMenuScreen::beforeAddingWidget()
     if (w)
         w->setVisible(false);
 #endif
-
-#ifdef ANDROID
-    if (SDL_IsAndroidTV())
-    {
-        Widget* tutorial = getWidget("startTutorial");
-        if (tutorial)
-            tutorial->setVisible(false);
-    }
-#endif
 }
 
 // ----------------------------------------------------------------------------
@@ -340,12 +327,6 @@ void MainMenuScreen::onUpdate(float delta)
     if (player->getUseFrequency() != 0)
         return;
 
-#ifdef ANDROID
-    // Don't show tutorial dialog on Android TV
-    if (SDL_IsAndroidTV())
-        return;
-#endif
-
     player->incrementUseFrequency();
     class PlayTutorial :
           public MessageDialog::IConfirmDialogListener
diff --git a/src/states_screens/online/networking_lobby.cpp b/src/states_screens/online/networking_lobby.cpp
index 94caa412429..217653c33fa 100644
--- a/src/states_screens/online/networking_lobby.cpp
+++ b/src/states_screens/online/networking_lobby.cpp
@@ -841,7 +841,6 @@ void NetworkingLobby::eventCallback(Widget* widget, const std::string& name,
     {
         onEnterPressed(m_chat_box->getText());
         m_chat_box->setText("");
-        m_chat_box->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
     }   // send chat message
     else if (name == m_emoji_button->m_properties[PROP_ID] &&
         !ScreenKeyboard::isActive())
diff --git a/src/states_screens/online/tracks_screen.cpp b/src/states_screens/online/tracks_screen.cpp
index f0d9c5e33fe..b6d2ec407d2 100644
--- a/src/states_screens/online/tracks_screen.cpp
+++ b/src/states_screens/online/tracks_screen.cpp
@@ -343,7 +343,7 @@ void TracksScreen::beforeAddingWidget()
 
     RibbonWidget* tabs = getWidget<RibbonWidget>("trackgroups");
     tabs->clearAllChildren();
-
+    
     RaceManager::MinorRaceModeType minor_mode = RaceManager::get()->getMinorMode();
     bool is_soccer = minor_mode == RaceManager::MINOR_MODE_SOCCER;
     bool is_arena = is_soccer || RaceManager::get()->isBattleMode();
diff --git a/src/states_screens/options/options_common.cpp b/src/states_screens/options/options_common.cpp
index 104fedc09ed..d134301ba26 100644
--- a/src/states_screens/options/options_common.cpp
+++ b/src/states_screens/options/options_common.cpp
@@ -43,19 +43,4 @@ namespace OptionsCommon
     	if(screen)
         	StateManager::get()->replaceTopMostScreen(screen);
 	}
-
-	// In the in-game pause options, disable the players and language tabs
-	void setTabStatus()
-	{
-		if (StateManager::get()->getGameState() == GUIEngine::INGAME_MENU)
-		{
-	    	GUIEngine::getWidget("tab_players")->setActive(false);
-	    	GUIEngine::getWidget("tab_language")->setActive(false);			
-		}
-		else
-		{
-			GUIEngine::getWidget("tab_players")->setActive(true);
-	    	GUIEngine::getWidget("tab_language")->setActive(true);
-	    }
-	} // setTabStatus
 }
\ No newline at end of file
diff --git a/src/states_screens/options/options_common.hpp b/src/states_screens/options/options_common.hpp
index 9a618f06070..9bafe3e26c3 100644
--- a/src/states_screens/options/options_common.hpp
+++ b/src/states_screens/options/options_common.hpp
@@ -52,7 +52,6 @@
 namespace OptionsCommon
 {
 	void switchTab(std::string selected_tab);
-	void setTabStatus();
 }
 
 #endif
\ No newline at end of file
diff --git a/src/states_screens/options/options_screen_audio.cpp b/src/states_screens/options/options_screen_audio.cpp
index 97174de5d00..0bcad71bfc4 100644
--- a/src/states_screens/options/options_screen_audio.cpp
+++ b/src/states_screens/options/options_screen_audio.cpp
@@ -41,8 +41,6 @@ void OptionsScreenAudio::loadedFromFile()
 void OptionsScreenAudio::init()
 {
     Screen::init();
-    OptionsCommon::setTabStatus();
-
     RibbonWidget* ribbon = this->getWidget<RibbonWidget>("options_choice");
     assert(ribbon != NULL);
     ribbon->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
@@ -72,6 +70,7 @@ void OptionsScreenAudio::init()
         getWidget<SpinnerWidget>("sfx_volume")->setActive(false);
     if(!UserConfigParams::m_music)
         getWidget<SpinnerWidget>("music_volume")->setActive(false);
+
 }   // init
 
 // -----------------------------------------------------------------------------
diff --git a/src/states_screens/options/options_screen_device.cpp b/src/states_screens/options/options_screen_device.cpp
index 7f0fbd32cab..209f21113be 100644
--- a/src/states_screens/options/options_screen_device.cpp
+++ b/src/states_screens/options/options_screen_device.cpp
@@ -63,8 +63,6 @@ void OptionsScreenDevice::beforeAddingWidget()
 void OptionsScreenDevice::init()
 {
     Screen::init();
-    OptionsCommon::setTabStatus();
-
     RibbonWidget* tabBar = getWidget<RibbonWidget>("options_choice");
     assert(tabBar != NULL);
     // Focus is set to the actions list later in the init
@@ -184,7 +182,9 @@ void OptionsScreenDevice::init()
     actions->setSelectionID(0);
 
     // Disable deleting or disabling configuration mid-race
-    if (StateManager::get()->getGameState() == GUIEngine::INGAME_MENU)
+    bool in_game = StateManager::get()->getGameState() == GUIEngine::INGAME_MENU;
+    
+    if (in_game)
     {
         delete_button->setActive(false);
         disable_toggle->setActive(false);
diff --git a/src/states_screens/options/options_screen_display.cpp b/src/states_screens/options/options_screen_display.cpp
index 09148348eda..68f1bc81434 100644
--- a/src/states_screens/options/options_screen_display.cpp
+++ b/src/states_screens/options/options_screen_display.cpp
@@ -66,8 +66,6 @@ void OptionsScreenDisplay::loadedFromFile()
 void OptionsScreenDisplay::init()
 {
     Screen::init();
-    OptionsCommon::setTabStatus();
-
     RibbonWidget* ribbon = getWidget<RibbonWidget>("options_choice");
     assert(ribbon != NULL);
     ribbon->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
diff --git a/src/states_screens/options/options_screen_general.cpp b/src/states_screens/options/options_screen_general.cpp
index b83e7c4b1cf..1dca1dc2cb5 100644
--- a/src/states_screens/options/options_screen_general.cpp
+++ b/src/states_screens/options/options_screen_general.cpp
@@ -72,8 +72,6 @@ void OptionsScreenGeneral::init()
     assert( show_login!= NULL );
     show_login->setState( UserConfigParams::m_always_show_login_screen);
 
-    OptionsCommon::setTabStatus();
-
 #ifdef MOBILE_STK
     if (ExtractMobileAssets::hasFullAssets())
     {
diff --git a/src/states_screens/options/options_screen_input.cpp b/src/states_screens/options/options_screen_input.cpp
index b58a50744ff..15289a5ea67 100644
--- a/src/states_screens/options/options_screen_input.cpp
+++ b/src/states_screens/options/options_screen_input.cpp
@@ -154,8 +154,6 @@ void OptionsScreenInput::buildDeviceList()
 void OptionsScreenInput::init()
 {
     Screen::init();
-    OptionsCommon::setTabStatus();
-
     RibbonWidget* tabBar = this->getWidget<RibbonWidget>("options_choice");
     assert(tabBar != NULL);
     tabBar->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
diff --git a/src/states_screens/options/options_screen_ui.cpp b/src/states_screens/options/options_screen_ui.cpp
index 6caa85f3df8..de9ee66b39e 100644
--- a/src/states_screens/options/options_screen_ui.cpp
+++ b/src/states_screens/options/options_screen_ui.cpp
@@ -148,7 +148,6 @@ void OptionsScreenUI::loadedFromFile()
 void OptionsScreenUI::init()
 {
     Screen::init();
-    OptionsCommon::setTabStatus();
 
     bool in_game = StateManager::get()->getGameState() == GUIEngine::INGAME_MENU;
 
diff --git a/src/states_screens/options/options_screen_video.cpp b/src/states_screens/options/options_screen_video.cpp
index 8bed1953014..98807468938 100644
--- a/src/states_screens/options/options_screen_video.cpp
+++ b/src/states_screens/options/options_screen_video.cpp
@@ -64,7 +64,7 @@ void OptionsScreenVideo::initPresets()
 
     m_presets.push_back // Level 4
     ({
-        true /* light */, 0 /* shadow */, false /* bloom */, false /* lightshaft */,
+        true /* light */, 0 /* shadow */, false /* bloom */, true /* lightshaft */,
         true /* glow */, true /* mlaa */, false /* ssao */, true /* light scatter */,
         true /* animatedCharacters */, 2 /* particles */, 2 /* image_quality */,
         false /* degraded IBL */, 3 /* Geometry Detail */
@@ -81,7 +81,7 @@ void OptionsScreenVideo::initPresets()
     m_presets.push_back // Level 6
     ({
         true /* light */, 1024 /* shadow */, true /* bloom */, true /* lightshaft */,
-        true /* glow */, true /* mlaa */, false /* ssao */, true /* light scatter */,
+        true /* glow */, true /* mlaa */, true /* ssao */, true /* light scatter */,
         true /* animatedCharacters */, 2 /* particles */, 3 /* image_quality */,
         false /* degraded IBL */, 4 /* Geometry Detail */
     });
@@ -94,25 +94,17 @@ void OptionsScreenVideo::initPresets()
         false /* degraded IBL */, 5 /* Geometry Detail */
     });
 
-    m_presets.push_back // Level 8
-    ({
-        true /* light */, 4096 /* shadow */, true /* bloom */, true /* lightshaft */,
-        true /* glow */, true /* mlaa */, true /* ssao */, true /* light scatter */,
-        true /* animatedCharacters */, 2 /* particles */, 3 /* image_quality */,
-        false /* degraded IBL */, 5 /* Geometry Detail */
-    });
-
-    m_blur_presets.push_back // Level 0
+    m_blur_presets.push_back
     ({
         false /* motionblur */, false /* depth of field */
     });
 
-    m_blur_presets.push_back // Level 1
+    m_blur_presets.push_back
     ({
         true  /* motionblur */, false /* depth of field */
     });
 
-    m_blur_presets.push_back // Level 2
+    m_blur_presets.push_back
     ({
         true  /* motionblur */, true  /* depth of field */
     });
@@ -132,9 +124,6 @@ void OptionsScreenVideo::initPresets()
     m_scale_rtts_custom_presets.push_back({ 0.9f });
     m_scale_rtts_custom_presets.push_back({ 0.95f });
     m_scale_rtts_custom_presets.push_back({ 1.0f });
-    m_scale_rtts_custom_presets.push_back({ 1.25f });
-    m_scale_rtts_custom_presets.push_back({ 1.5f });
-    m_scale_rtts_custom_presets.push_back({ 2.0f });
 
 }   // initPresets
 
@@ -220,7 +209,7 @@ OptionsScreenVideo::OptionsScreenVideo() : Screen("options/options_video.stkgui"
 void OptionsScreenVideo::loadedFromFile()
 {
     m_inited = false;
-    assert(m_presets.size() == 8);
+    assert(m_presets.size() == 7);
     assert(m_blur_presets.size() == 3);
 
     GUIEngine::SpinnerWidget* gfx =
@@ -241,8 +230,6 @@ void OptionsScreenVideo::loadedFromFile()
 void OptionsScreenVideo::init()
 {
     Screen::init();
-    OptionsCommon::setTabStatus();
-
     m_prev_adv_pipline = UserConfigParams::m_dynamic_lights;
     m_prev_img_quality = getImageQuality();
     RibbonWidget* ribbon = getWidget<RibbonWidget>("options_choice");
@@ -303,9 +290,6 @@ void OptionsScreenVideo::init()
     scale_rtts->addLabel("90%");
     scale_rtts->addLabel("95%");
     scale_rtts->addLabel("100%");
-    scale_rtts->addLabel("125%");
-    scale_rtts->addLabel("150%");
-    scale_rtts->addLabel("200%");
 
     // --- set gfx settings values
     updateGfxSlider();
diff --git a/src/states_screens/race_gui.cpp b/src/states_screens/race_gui.cpp
index 0f692d78283..cf6940d0b31 100644
--- a/src/states_screens/race_gui.cpp
+++ b/src/states_screens/race_gui.cpp
@@ -519,22 +519,14 @@ void RaceGUI::drawLiveDifference()
     video::SColor time_color;
 
     // Change color depending on value
-    if (live_difference > 2.5f)
+    if (live_difference > 1.0f)
         time_color = video::SColor(255, 255, 0, 0);
-    else if (live_difference > 1.0f)
-        time_color = video::SColor(255, 255, 60, 0);
-    else if (live_difference > 0.3f)
-        time_color = video::SColor(255, 255, 120, 0);
     else if (live_difference > 0.0f)
-        time_color = video::SColor(255, 255, 180, 0);
-    else if (live_difference > -0.3f)
-        time_color = video::SColor(255, 210, 230, 0);
+        time_color = video::SColor(255, 255, 160, 0);
     else if (live_difference > -1.0f)
-        time_color = video::SColor(255, 105, 255, 0);
-    else if (live_difference > -2.5f)
-        time_color = video::SColor(255, 0, 210, 30);
+        time_color = video::SColor(255, 160, 255, 0);
     else
-        time_color = video::SColor(255, 0, 160, 60);
+        time_color = video::SColor(255, 0, 255, 0);
 
     int dist_from_right = 10 + timer_width;
 
diff --git a/src/states_screens/race_gui_overworld.cpp b/src/states_screens/race_gui_overworld.cpp
index f72d6a39635..a82c5dd95fa 100644
--- a/src/states_screens/race_gui_overworld.cpp
+++ b/src/states_screens/race_gui_overworld.cpp
@@ -58,11 +58,6 @@
 #include <IrrlichtDevice.h>
 #include <ISceneCollisionManager.h>
 #include <ISceneManager.h>
-
-#ifdef ANDROID
-#include <SDL_system.h>
-#endif
-
 using namespace irr;
 
 #include <algorithm>
@@ -531,11 +526,6 @@ void RaceGUIOverworld::drawGlobalMiniMap()
 
             if (challenges[n].m_challenge_id == "tutorial")
             {
-#ifdef ANDROID
-                if (SDL_IsAndroidTV())
-                    continue;
-#endif
-
                 gui::ScalableFont* font = GUIEngine::getTitleFont();
                 font->draw(_("Tutorial"), pos, video::SColor(255,255,255,255),
                            false, true /* vcenter */, NULL);
diff --git a/src/states_screens/race_result_gui.cpp b/src/states_screens/race_result_gui.cpp
index a487a73dc47..49a317c611d 100644
--- a/src/states_screens/race_result_gui.cpp
+++ b/src/states_screens/race_result_gui.cpp
@@ -207,6 +207,27 @@ void RaceResultGUI::init()
         MessageQueue::add(MessageQueue::MT_GENERIC, tips_string);
     }
 #endif
+    
+    if (RaceManager::get()->getMajorMode() == RaceManager::MAJOR_MODE_GRAND_PRIX &&
+        !NetworkConfig::get()->isNetworking() &&
+        (RaceManager::get()->getMinorMode() == RaceManager::MINOR_MODE_NORMAL_RACE || RaceManager::get()->getMinorMode() == RaceManager::MINOR_MODE_TIME_TRIAL ||
+        RaceManager::get()->isLapTrialMode()))
+    {
+        const AbstractKart* k = RaceManager::get()->getKartWithGPRank(RaceManager::get()->getLocalPlayerGPRank(PLAYER_ID_GAME_MASTER));
+        RaceManager::get()->addGPTotalLaps(World::getWorld()->getFinishedLapsOfKart(k->getWorldKartId()));
+        if (RaceManager::get()->getNumOfTracks() == RaceManager::get()->getTrackNumber() + 1
+           && !RaceManager::get()->getGrandPrix().isRandomGP() && RaceManager::get()->getSkippedTracksInGP() == 0)
+        {
+            Highscores* highscores = World::getWorld()->getGPHighscores();
+            float full_time;
+            if (RaceManager::get()->isLapTrialMode())
+                full_time = static_cast<float>(RaceManager::get()->getGPTotalLaps());
+            else
+                full_time = RaceManager::get()->getOverallTime(RaceManager::get()->getLocalPlayerGPRank(PLAYER_ID_GAME_MASTER));
+            std::string gp_name = RaceManager::get()->getGrandPrix().getId();
+            highscores->addGPData(k->getIdent(), k->getController()->getName(), gp_name, full_time);
+        }
+    }
 }   // init
 
 //-----------------------------------------------------------------------------
@@ -235,15 +256,6 @@ void RaceResultGUI::enableAllButtons()
     operations->setActive(true);
     operations->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
 
-    auto makeContinueButton
-    {
-        [](GUIEngine::IconButtonWidget *button)
-        {
-            button->setLabel(_("Continue"));
-            button->setImage("gui/icons/green_check.png");
-        }
-    };
-
     if (RaceManager::get()->getMajorMode() == RaceManager::MAJOR_MODE_GRAND_PRIX)
     {
         enableGPProgress();
@@ -269,7 +281,8 @@ void RaceResultGUI::enableAllButtons()
     // If we're in a network world, change the buttons text
     if (World::getWorld()->isNetworkWorld())
     {
-        makeContinueButton(right);
+        right->setLabel(_("Continue"));
+        right->setImage("gui/icons/green_check.png");
         right->setVisible(true);
         operations->select("right", PLAYER_ID_GAME_MASTER);
         middle->setVisible(false);
@@ -291,7 +304,8 @@ void RaceResultGUI::enableAllButtons()
          (RaceManager::get()->getMajorMode() != RaceManager::MAJOR_MODE_GRAND_PRIX ||
           RaceManager::get()->getTrackNumber() + 1 == RaceManager::get()->getNumOfTracks() ) )
     {
-        makeContinueButton(middle);
+        middle->setLabel(_("Continue"));
+        middle->setImage("gui/icons/green_check.png");
         middle->setVisible(true);
         operations->select("middle", PLAYER_ID_GAME_MASTER);
     }
@@ -299,14 +313,16 @@ void RaceResultGUI::enableAllButtons()
     {
         // In case of a GP:
         // ----------------
-        makeContinueButton(middle);
+        middle->setLabel(_("Continue"));
+        middle->setImage("gui/icons/green_check.png");
         middle->setVisible(false);
         middle->setFocusable(false);
         left->setVisible(false);
         left->setFocusable(false);
 
         // Two continue buttons to make sure the buttons in the bar is balanced
-        makeContinueButton(right);
+        right->setLabel(_("Continue"));
+        right->setImage("gui/icons/green_check.png");
         right->setVisible(true);
 
         if (RaceManager::get()->getTrackNumber() + 1 < RaceManager::get()->getNumOfTracks())
@@ -657,6 +673,7 @@ void RaceResultGUI::displayCTFResults()
     //Draw win text
     core::stringw result_text;
     video::SColor color = video::SColor(255, 255, 255, 255);
+    video::SColor red_color = video::SColor(255, 255, 0, 0);
     gui::IGUIFont* font = GUIEngine::getTitleFont();
     int team_icon_height = font->getDimension(L"A").Height;
     int current_x = UserConfigParams::m_width / 2;
@@ -722,44 +739,18 @@ void RaceResultGUI::displayCTFResults()
 
     // The red team player scores:
     current_y += rect.Height / 2 + rect.Height / 4;
-    drawCTFScorers(KART_TEAM_RED, current_x, current_y, height);
-    current_x += UserConfigParams::m_width / 2;
-    drawCTFScorers(KART_TEAM_BLUE, current_x, current_y, height);
-#endif
-} // displayCTFResults
-
-//-----------------------------------------------------------------------------
-/** Displays the CTF scorers for a team
- *  \param team The team for which to draw the scorers
- *  \param x Left limit of the scorers lists (both blue and red)
- *  \param y Top limit of the scorers lists
- *  \param height Maximum y of the table area (??) */
-void RaceResultGUI::drawCTFScorers(KartTeam team, int x, int y, int height)
-{
-#ifndef SERVER_ONLY
-    CaptureTheFlag* ctf = dynamic_cast<CaptureTheFlag*>(World::getWorld());
-    gui::IGUIFont* font = GUIEngine::getSmallFont();
+    font = GUIEngine::getSmallFont();
     irr::video::ITexture* kart_icon;
 
-    core::stringw result_text;
-    video::SColor color = video::SColor(255, 255, 255, 255);
-    video::SColor red_color = video::SColor(255, 255, 0, 0);
-
-    int current_x = x;
-    int current_y = y;
-    core::dimension2du rect;
-    core::rect<s32> pos(current_x, current_y, current_x, current_y);
-
+    int prev_y = current_y;
     const unsigned num_karts = ctf->getNumKarts();
     for (unsigned int i = 0; i < num_karts; i++)
     {
         AbstractKart* kart = ctf->getKartAtPosition(i + 1);
         unsigned kart_id = kart->getWorldKartId();
-        if (ctf->getKartTeam(kart_id) != team)
+        if (ctf->getKartTeam(kart_id) != KART_TEAM_RED)
             continue;
         result_text = kart->getController()->getName();
-
-        // add the country flag if available
         if (RaceManager::get()->getKartGlobalPlayerId(kart_id) > -1)
         {
             const core::stringw& flag = StringUtils::getCountryFlag(
@@ -777,9 +768,9 @@ void RaceResultGUI::drawCTFScorers(KartTeam team, int x, int y, int height)
         }
         else
         {
-            result_text.append(StringUtils::toWString(ctf->getKartScore(kart_id)));
+            result_text.append(
+                StringUtils::toWString(ctf->getKartScore(kart_id)));
         }
-
         rect = font->getDimension(result_text.c_str());
         current_y += rect.Height;
 
@@ -790,15 +781,63 @@ void RaceResultGUI::drawCTFScorers(KartTeam team, int x, int y, int height)
             kart->getController()->isLocalPlayerController() ?
             red_color : color, true, false);
         kart_icon = kart->getKartProperties()->getIconMaterial()->getTexture();
-        core::recti source_rect = core::recti(core::vector2di(0, 0), kart_icon->getSize());
+        source_rect = core::recti(core::vector2di(0, 0), kart_icon->getSize());
         irr::u32 offset_x =
             (irr::u32)(font->getDimension(result_text.c_str()).Width / 1.5f);
-        core::recti dest_rect = core::recti(current_x - offset_x - m_width_icon, current_y,
+        dest_rect = core::recti(current_x - offset_x - m_width_icon, current_y,
+            current_x - offset_x, current_y + m_width_icon);
+        draw2DImage(kart_icon, dest_rect, source_rect, NULL, NULL, true);
+    }
+
+    // The blue team player scores:
+    current_y = prev_y;
+    current_x += UserConfigParams::m_width / 2;
+    for (unsigned int i = 0; i < num_karts; i++)
+    {
+        AbstractKart* kart = ctf->getKartAtPosition(i + 1);
+        unsigned kart_id = kart->getWorldKartId();
+        if (ctf->getKartTeam(kart_id) != KART_TEAM_BLUE)
+            continue;
+        result_text = kart->getController()->getName();
+        if (RaceManager::get()->getKartGlobalPlayerId(kart_id) > -1)
+        {
+            const core::stringw& flag = StringUtils::getCountryFlag(
+                RaceManager::get()->getKartInfo(kart_id).getCountryCode());
+            if (!flag.empty())
+            {
+                result_text += L" ";
+                result_text += flag;
+            }
+        }
+        result_text.append("  ");
+        if (kart->isEliminated())
+        {
+            continue;
+        }
+        else
+        {
+            result_text.append(
+                StringUtils::toWString(ctf->getKartScore(kart_id)));
+        }
+        rect = font->getDimension(result_text.c_str());
+        current_y += rect.Height;
+
+        if (current_y > height) break;
+
+        pos = core::rect<s32>(current_x, current_y, current_x, current_y);
+        font->draw(result_text, pos,
+            kart->getController()->isLocalPlayerController() ?
+            red_color : color, true, false);
+        kart_icon = kart->getKartProperties()->getIconMaterial()->getTexture();
+        source_rect = core::recti(core::vector2di(0, 0), kart_icon->getSize());
+        irr::u32 offset_x = (irr::u32)
+            (font->getDimension(result_text.c_str()).Width / 1.5f);
+        dest_rect = core::recti(current_x - offset_x - m_width_icon, current_y,
             current_x - offset_x, current_y + m_width_icon);
         draw2DImage(kart_icon, dest_rect, source_rect, NULL, NULL, true);
     }
 #endif
-} // drawCTFScorers
+} // displayCTFResults
 
 //-----------------------------------------------------------------------------
 void RaceResultGUI::unload()
@@ -964,12 +1003,11 @@ void RaceResultGUI::determineTableLayout()
     // The time the first phase is being displayed: add the start time
     // of the last kart to the duration of the scroll plus some time
     // of rest before the next phase starts
-    m_extra_scroll_time = 1.0f;
     m_time_overall_scroll = (num_karts - 1)*m_time_between_rows
-        + m_time_single_scroll + m_extra_scroll_time;
+        + m_time_single_scroll + 2.0f;
 
     // The time to increase the number of points.
-    m_time_for_points = 2.0f;
+    m_time_for_points = 1.0f;
 
     // Determine text height
     r = m_font->getDimension(L"Y");
@@ -1104,9 +1142,6 @@ void RaceResultGUI::renderGlobal(float dt)
     assert(World::getWorld()->getPhase() == WorldStatus::RESULT_DISPLAY_PHASE);
     unsigned int num_karts = (unsigned int)m_all_row_infos.size();
     float time_overall_scroll = m_time_overall_scroll;
-    // TODO after 1.5: Avoid the point increase being too slow for low point amounts
-    // float time_for_points = std::min(0.3f + 0.2f*m_most_points, m_time_for_points);
-    float time_for_points = m_time_for_points;
 
     // First: Update the finite state machine
     // ======================================
@@ -1126,7 +1161,7 @@ void RaceResultGUI::renderGlobal(float dt)
         // GP mode has a continue button so no extra time is needed
         if (RaceManager::get()->getMajorMode() ==
             RaceManager::MAJOR_MODE_GRAND_PRIX)
-            time_overall_scroll -= m_extra_scroll_time;
+            time_overall_scroll -= 2.0f;
         if (m_timer > time_overall_scroll)
         {
             // Make sure that all lines are aligned to the left
@@ -1175,7 +1210,7 @@ void RaceResultGUI::renderGlobal(float dt)
         break;
     case RR_INCREASE_POINTS:
         // Have one second delay before the resorting starts.
-        if (m_timer > 1 + time_for_points)
+        if (m_timer > 1 + m_time_for_points)
         {
             m_animation_state = RR_RESORT_TABLE;
             if (m_gp_position_was_changed)
@@ -1272,13 +1307,20 @@ void RaceResultGUI::renderGlobal(float dt)
             {
                 WorldWithRank *wwr = dynamic_cast<WorldWithRank*>(World::getWorld());
                 assert(wwr);
-                ri->m_current_displayed_points += dt * m_most_points / time_for_points;
+                int most_points;
+                if (RaceManager::get()->isFollowMode())
+                    most_points = wwr->getScoreForPosition(2);
+                else
+                    most_points = wwr->getScoreForPosition(1);
+                ri->m_current_displayed_points +=
+                    dt*most_points / m_time_for_points;
                 if (ri->m_current_displayed_points > ri->m_new_overall_points)
                 {
                     ri->m_current_displayed_points =
                         (float)ri->m_new_overall_points;
                 }
-                ri->m_new_points -= dt * m_most_points / time_for_points;
+                ri->m_new_points -=
+                    dt*most_points / m_time_for_points;
                 if (ri->m_new_points < 0)
                     ri->m_new_points = 0;
                 break;
@@ -1324,7 +1366,6 @@ void RaceResultGUI::determineGPLayout()
         max_time = std::max(RaceManager::get()->getOverallTime(kart_id), max_time);
     }
 
-    m_most_points = 0.;
     for (unsigned int kart_id = 0; kart_id < num_karts; kart_id++)
     {
         int rank = RaceManager::get()->getKartGPRank(kart_id);
@@ -1365,6 +1406,17 @@ void RaceResultGUI::determineGPLayout()
         ri->m_y_pos = (float)(m_top + rank*m_distance_between_rows);
         int p = RaceManager::get()->getKartPrevScore(kart_id);
         ri->m_current_displayed_points = (float)p;
+        if (kart->isEliminated() && !(RaceManager::get()->isFollowMode()))
+        {
+            ri->m_new_points = 0;
+        }
+        else
+        {
+            WorldWithRank *wwr = dynamic_cast<WorldWithRank*>(World::getWorld());
+            assert(wwr);
+            ri->m_new_points =
+                (float)wwr->getScoreForPosition(kart->getPosition());
+        }
     }
 
     // Now update the GP ranks, and determine the new position
@@ -1381,8 +1433,6 @@ void RaceResultGUI::determineGPLayout()
         ri->m_centre_point = m_top + (gp_position + j)*m_distance_between_rows*0.5f;
         int p = RaceManager::get()->getKartScore(i);
         ri->m_new_overall_points = p;
-        ri->m_new_points = ri->m_new_overall_points - ri->m_current_displayed_points;
-        m_most_points = std::max(m_most_points, ri->m_new_points);
         ri->m_new_gp_rank = gp_position;
         ri->m_laps = World::getWorld()->getFinishedLapsOfKart(i);
     }   // i < num_karts
diff --git a/src/states_screens/race_result_gui.hpp b/src/states_screens/race_result_gui.hpp
index e6b3b2831df..5aba04c346d 100644
--- a/src/states_screens/race_result_gui.hpp
+++ b/src/states_screens/race_result_gui.hpp
@@ -134,9 +134,6 @@ class RaceResultGUI : public RaceGUIBase,
         This includes a small waiting time at the end. */
     float                      m_time_overall_scroll;
 
-    /** The small waiting time for the above. */
-    float                      m_extra_scroll_time;
-
     /** Distance between each row of the race results */
     unsigned int               m_distance_between_rows;
 
@@ -189,9 +186,6 @@ class RaceResultGUI : public RaceGUIBase,
     /** For highscores */
     int m_highscore_rank;
 
-    /** Maximum number of points earned by a player in this game (used in animation). */
-    float m_most_points;
-
     unsigned int m_width_all_points;
 
     int m_max_tracks;
@@ -216,7 +210,6 @@ class RaceResultGUI : public RaceGUIBase,
     int  displayLapDifficulty(int x, int y, bool increase_density);
     int  displayChallengeInfo(int x, int y, bool increase_density);
     void displayCTFResults();
-    void drawCTFScorers(KartTeam team, int x, int y, int height);
     void displaySoccerResults();
     void drawTeamScorers(KartTeam team, int x, int y, int height);
     void displayBenchmarkSummary();
diff --git a/src/states_screens/track_info_screen.cpp b/src/states_screens/track_info_screen.cpp
index aca3e167c44..dcff8606eb3 100644
--- a/src/states_screens/track_info_screen.cpp
+++ b/src/states_screens/track_info_screen.cpp
@@ -77,7 +77,9 @@ void TrackInfoScreen::loadedFromFile()
     m_ai_kart_spinner       = getWidget<SpinnerWidget>("ai-spinner");
     m_ai_kart_label         = getWidget<LabelWidget>("ai-text");
     m_option                = getWidget<CheckBoxWidget>("option");
+    m_tire_stealing         = getWidget<CheckBoxWidget>("tire-stealing");
     m_record_race           = getWidget<CheckBoxWidget>("record");
+    m_tire_stealing->setState(false);
     m_option->setState(false);
     m_record_race->setState(false);
 
@@ -251,14 +253,23 @@ void TrackInfoScreen::init()
         m_target_type_label->setText(_("Game mode"), false);
         m_target_type_spinner->clearLabels();
         m_target_type_spinner->addLabel(_("3 Strikes Battle"));
+                
         m_target_type_spinner->addLabel(_("Free-For-All"));
         m_target_type_spinner->setValue(UserConfigParams::m_use_ffa_mode ? 1 : 0);
-
-        m_target_value_label->setText(_("Maximum time (min.)"), false);
         m_target_value_spinner->setValue(UserConfigParams::m_ffa_time_limit);
+        if (UserConfigParams::m_use_ffa_mode)
+            m_target_value_label->setText(_("Maximum time (min.)"), false);
+            
+		else
+		    m_target_value_label->setText(_("Starting tires"), false);
+        
+        m_tire_stealing->setVisible(!UserConfigParams::m_use_ffa_mode);
+        getWidget<LabelWidget>("tire-stealing-text")->setVisible(!UserConfigParams::m_use_ffa_mode);
+		getWidget<LabelWidget>("tire-stealing-text")->setText(_("Steal tires"), false);
+        m_tire_stealing->setState(UserConfigParams::m_tire_steal);
 
-        m_target_value_label->setVisible(UserConfigParams::m_use_ffa_mode);
-        m_target_value_spinner->setVisible(UserConfigParams::m_use_ffa_mode);
+        m_target_value_label->setVisible(true);
+        m_target_value_spinner->setVisible(true);
     }
 
     // Lap count m_lap_spinner
@@ -286,12 +297,13 @@ void TrackInfoScreen::init()
         m_target_value_label->setText(_("Maximum time (min.)"), false);
         m_target_value_spinner->setValue(UserConfigParams::m_lap_trial_time_limit);
     }
-    // Reverse track or random item in arena
+    // Reverse track or tire stealing and random item in arena
     // -------------
     const bool reverse_available =     m_track->reverseAvailable()
                                    && !(RaceManager::get()->isEggHuntMode());
     const bool random_item = m_track->hasNavMesh();
 
+
     m_option->setVisible(reverse_available || random_item);
     getWidget<LabelWidget>("option-text")->setVisible(reverse_available || random_item);
     if (reverse_available)
@@ -663,9 +675,14 @@ void TrackInfoScreen::eventCallback(Widget* widget, const std::string& name,
         {
             const bool enable_ffa = target_value != 0;
             UserConfigParams::m_use_ffa_mode = enable_ffa;
+            
+            m_tire_stealing->setVisible(!enable_ffa);
+            getWidget<LabelWidget>("tire-stealing-text")->setVisible(!enable_ffa);
 
-            m_target_value_label->setVisible(enable_ffa);
-            m_target_value_spinner->setVisible(enable_ffa);
+            if (enable_ffa)
+                m_target_value_label->setText(_("Maximum time (min.)"), false);
+		    else
+		        m_target_value_label->setText(_("Starting tires"), false);
         }
     }
     else if (name == "target-value-spinner")
@@ -682,8 +699,7 @@ void TrackInfoScreen::eventCallback(Widget* widget, const std::string& name,
         {
             const bool enable_ffa = m_target_type_spinner->getValue() != 0;
 
-            if (enable_ffa)
-                UserConfigParams::m_ffa_time_limit = m_target_value_spinner->getValue();
+            UserConfigParams::m_ffa_time_limit = m_target_value_spinner->getValue();
         }
         else if (m_is_lap_trial)
         {
@@ -712,6 +728,10 @@ void TrackInfoScreen::eventCallback(Widget* widget, const std::string& name,
             // checkbox.
             updateHighScores();
         }
+    }
+     else if (name == "tire-stealing")
+    {
+        UserConfigParams::m_tire_steal = m_tire_stealing->getState();
     }
     else if (name == "record")
     {
diff --git a/src/states_screens/track_info_screen.hpp b/src/states_screens/track_info_screen.hpp
index 6ccc66e62bd..13e67e72012 100644
--- a/src/states_screens/track_info_screen.hpp
+++ b/src/states_screens/track_info_screen.hpp
@@ -90,6 +90,9 @@ class TrackInfoScreen : public GUIEngine::Screen,
     /** Check box for reverse mode or random item in arena. */
     GUIEngine::CheckBoxWidget* m_option;
 
+    /** Check box for tire stealing. */
+    GUIEngine::CheckBoxWidget* m_tire_stealing;
+
     /** Check box for record race. */
     GUIEngine::CheckBoxWidget* m_record_race;
 
diff --git a/src/tracks/track.cpp b/src/tracks/track.cpp
index 66a595c0c30..738037c2124 100644
--- a/src/tracks/track.cpp
+++ b/src/tracks/track.cpp
@@ -541,8 +541,8 @@ void Track::loadTrackInfo()
     m_sun_specular_color    = video::SColor(255, 255, 255, 255);
     m_sun_diffuse_color     = video::SColor(255, 255, 255, 255);
     m_sun_position          = core::vector3df(0, 10, 10);
-    irr_driver->setSSAORadius(0.5);
-    irr_driver->setSSAOK(3.);
+    irr_driver->setSSAORadius(1.);
+    irr_driver->setSSAOK(1.5);
     irr_driver->setSSAOSigma(1.);
     XMLNode *root           = file_manager->createXMLTree(m_filename);
 
diff --git a/src/utils/crash_reporting.cpp b/src/utils/crash_reporting.cpp
index 3e34c9bced5..cd1d4ebf5d6 100644
--- a/src/utils/crash_reporting.cpp
+++ b/src/utils/crash_reporting.cpp
@@ -101,9 +101,9 @@
                 getCallStack(callstack);
 
             std::string msg =   "SuperTuxKart crashed!\n"
-                                "If you continue to encounter this issue, please hit Ctrl+C to copy this error "
-                                "to the clipboard and report the problem to the developers on our bug tracker:\n"
-                                "https://github.com/supertuxkart/stk-code/issues\n"
+                                "If you continue to encounter this issue, please hit Ctrl+C to copy this error\n"
+                                "to the clipboard and report the problem to the developers on our forum:\n"
+                                "http://forum.freegamedev.net/viewforum.php?f=17\n"
                                 "\n"
                                 "Call stack:\n";
             msg += callstack;

From 908db4d70fcea088d6a26101532360fba6e23ee6 Mon Sep 17 00:00:00 2001
From: bart <bart@bbun>
Date: Wed, 12 Feb 2025 17:27:40 +0100
Subject: [PATCH 2/9] changes to three strike battle

---
 src/audio/music.hpp                           |   1 -
 src/audio/music_information.cpp               |  40 +-
 src/audio/music_information.hpp               |  16 +-
 src/audio/music_ogg.cpp                       |  22 +-
 src/audio/music_ogg.hpp                       |   2 +-
 src/audio/sfx_manager.cpp                     |   2 +-
 src/config/favorite_status.cpp                |   6 -
 src/config/favorite_status.hpp                |   2 -
 src/config/player_profile.cpp                 |  19 +-
 src/config/saved_grand_prix.hpp               |   4 -
 src/graphics/camera/camera.hpp                |   2 +
 src/graphics/camera/camera_normal.cpp         |  59 +-
 src/graphics/irr_driver.cpp                   |   2 +-
 src/graphics/lighting_passes.cpp              |  27 +-
 src/graphics/lighting_passes.hpp              |   6 +-
 src/graphics/post_processing.cpp              |  52 +-
 src/graphics/post_processing.hpp              |   2 +-
 src/graphics/shader_based_renderer.cpp        |  38 +-
 src/graphics/shadow_matrices.cpp              |  14 +-
 src/graphics/shadow_matrices.hpp              |  11 +-
 src/graphics/sp/sp_base.cpp                   |  23 +-
 src/guiengine/event_handler.cpp               |  65 +--
 src/guiengine/event_handler.hpp               |   4 +-
 src/guiengine/skin.cpp                        |   5 +-
 src/guiengine/widgets/ribbon_widget.cpp       |  24 +
 src/guiengine/widgets/ribbon_widget.hpp       |   7 +
 src/input/device_manager.cpp                  |  18 +
 src/input/device_manager.hpp                  |   6 +-
 src/items/attachment.cpp                      |  31 +-
 src/items/item.cpp                            |  92 ++--
 src/items/item.hpp                            |   3 +
 .../controller/local_player_controller.cpp    |   6 +-
 src/karts/controller/spare_tire_ai.cpp        |  17 +-
 src/karts/kart_model.cpp                      |   3 +-
 src/karts/kart_properties_manager.cpp         |   2 +-
 src/main.cpp                                  |  48 +-
 src/modes/linear_world.cpp                    |  19 +-
 src/modes/overworld.cpp                       |   9 +
 src/modes/world.cpp                           |  91 ++--
 src/modes/world.hpp                           |   2 +
 src/network/protocols/ranking.cpp             | 488 +++++++++++++++++
 src/network/protocols/ranking.hpp             |  82 +++
 src/network/protocols/server_lobby.cpp        | 504 +++---------------
 src/network/protocols/server_lobby.hpp        |  45 +-
 src/network/server_config.cpp                 |   8 +-
 src/race/race_manager.cpp                     |  17 +-
 src/race/race_manager.hpp                     |  10 -
 .../dialogs/custom_video_settings.cpp         |   7 +-
 src/states_screens/help/help_screen_1.cpp     |  20 +
 src/states_screens/help/help_screen_1.hpp     |   3 +
 src/states_screens/kart_selection.cpp         |  23 +-
 src/states_screens/main_menu_screen.cpp       |  19 +
 .../online/networking_lobby.cpp               |   1 +
 src/states_screens/online/tracks_screen.cpp   |   2 +-
 src/states_screens/options/options_common.cpp |  15 +
 src/states_screens/options/options_common.hpp |   1 +
 .../options/options_screen_audio.cpp          |   3 +-
 .../options/options_screen_device.cpp         |   6 +-
 .../options/options_screen_display.cpp        |   2 +
 .../options/options_screen_general.cpp        |   2 +
 .../options/options_screen_input.cpp          |   2 +
 .../options/options_screen_ui.cpp             |   1 +
 .../options/options_screen_video.cpp          |  28 +-
 src/states_screens/race_gui.cpp               |  16 +-
 src/states_screens/race_gui_overworld.cpp     |  10 +
 src/states_screens/race_result_gui.cpp        | 170 +++---
 src/states_screens/race_result_gui.hpp        |   7 +
 src/tracks/track.cpp                          |   4 +-
 src/utils/crash_reporting.cpp                 |   6 +-
 69 files changed, 1335 insertions(+), 969 deletions(-)
 create mode 100644 src/network/protocols/ranking.cpp
 create mode 100644 src/network/protocols/ranking.hpp

diff --git a/src/audio/music.hpp b/src/audio/music.hpp
index a848fb6e50f..120b46f42b1 100644
--- a/src/audio/music.hpp
+++ b/src/audio/music.hpp
@@ -35,7 +35,6 @@ class Music : public NoCopy
     virtual bool pauseMusic  ()                            = 0;
     virtual bool resumeMusic ()                            = 0;
     virtual void setVolume   (float volume)                = 0;
-    virtual void updateFaster(float percent, float pitch)  = 0;
     virtual void update      ()                            = 0;
     virtual bool isPlaying   ()                            = 0;
 
diff --git a/src/audio/music_information.cpp b/src/audio/music_information.cpp
index e211664d4ff..511768b4be6 100644
--- a/src/audio/music_information.cpp
+++ b/src/audio/music_information.cpp
@@ -84,8 +84,7 @@ MusicInformation::MusicInformation(const XMLNode *root,
     m_fast_loop_end     = -1.0f;
     m_enable_fast       = false;
     m_music_waiting     = false;
-    m_faster_time       = 1.0f;
-    m_max_pitch         = 0.1f;
+    m_faster_time       = 1.5f;
     m_gain              = 1.0f;
 
 
@@ -107,6 +106,8 @@ MusicInformation::MusicInformation(const XMLNode *root,
     root->get("fast-loop-start", &m_fast_loop_start  );
     root->get("fast-loop-end",   &m_fast_loop_end    );
 
+    m_temporary_volume = m_gain;
+
     // Get the path from the filename and add it to the ogg filename
     std::string path  = StringUtils::getPath(filename);
     m_normal_filename = path + "/" + m_normal_filename;
@@ -273,31 +274,15 @@ void MusicInformation::update(float dt)
         {
             m_mode=SOUND_FAST;
             m_normal_music->stopMusic();
+            m_fast_music->setVolume(m_temporary_volume);
             m_fast_music->update();
             return;
         }
         float fraction=m_time_since_faster/m_faster_time;
-        m_normal_music->setVolume(1-fraction);
-        m_fast_music->setVolume(fraction);
+        m_normal_music->setVolume(m_temporary_volume * (1-fraction));
+        m_fast_music->setVolume(m_temporary_volume * fraction);
         m_normal_music->update();
         m_fast_music->update();
-        break;
-                       }
-    case SOUND_FASTER: {
-        if ( m_normal_music == NULL ) break;
-
-        m_time_since_faster +=dt;
-        if(m_time_since_faster>=m_faster_time)
-        {
-            // Once the pitch is adjusted, just switch back to normal
-            // mode. We can't switch to fast music mode, since this would
-            // play m_fast_music, which isn't available.
-            m_mode=SOUND_NORMAL;
-            return;
-        }
-        float fraction=m_time_since_faster/m_faster_time;
-        m_normal_music->updateFaster(fraction, m_max_pitch);
-
         break;
                        }
     case SOUND_NORMAL:
@@ -354,6 +339,7 @@ void MusicInformation::resumeMusic()
 //-----------------------------------------------------------------------------
 void MusicInformation::setDefaultVolume()
 {
+    m_temporary_volume = m_gain;
     if (m_normal_music && m_normal_music->isPlaying())
         m_normal_music->setVolume(m_gain);
     if (m_fast_music && m_fast_music->isPlaying())
@@ -366,11 +352,14 @@ void MusicInformation::setDefaultVolume()
  */
 void MusicInformation::setTemporaryVolume(float volume)
 {
-    if (m_normal_music != NULL) m_normal_music->setVolume(volume);
-    if (m_fast_music   != NULL) m_fast_music->setVolume(volume);
+    m_temporary_volume = m_gain * volume;
+    if (m_normal_music != NULL) m_normal_music->setVolume(m_temporary_volume);
+    if (m_fast_music   != NULL) m_fast_music->setVolume(m_temporary_volume);
 }
 
 //-----------------------------------------------------------------------------
+/** If there is a fast music available, switch to it.
+ *  */
 void MusicInformation::switchToFastMusic()
 {
     if(!m_enable_fast) return;
@@ -381,11 +370,6 @@ void MusicInformation::switchToFastMusic()
         m_fast_music->playMusic();
         m_fast_music->setVolume(0);
     }
-    else
-    {
-        // FIXME: for now this music is too annoying,
-        m_mode = SOUND_FASTER;
-    }
 }   // switchToFastMusic
 
 //-----------------------------------------------------------------------------
diff --git a/src/audio/music_information.hpp b/src/audio/music_information.hpp
index fd2406f3a9c..183a9e2ef64 100644
--- a/src/audio/music_information.hpp
+++ b/src/audio/music_information.hpp
@@ -53,8 +53,7 @@ class MusicInformation : public NoCopy
      *  was told not to start right away). */
     bool                    m_music_waiting;
 
-    /** If faster music is enabled at all (either separate file or using
-     *  the pitch shift approach). */
+    /** If faster music is enabled at all. */
     bool                     m_enable_fast;
 
     float                    m_gain;
@@ -64,18 +63,19 @@ class MusicInformation : public NoCopy
     float                    m_normal_loop_end;
     float                    m_fast_loop_end;
 
-    /** Either time for fading faster music in, or time to change pitch. */
+    /** Time for fading faster music in. */
     float                    m_faster_time;
-    /** Maximum pitch for faster music. */
-    float                    m_max_pitch;
+
+    /* Avoid the temporary volume being forgotten */
+    float                    m_temporary_volume;
+
     static const int         LOOP_FOREVER=-1;
     mutable std::mutex       m_music_mutex;
     Music                   *m_normal_music,
                             *m_fast_music;
     enum {SOUND_NORMAL,     //!< normal music is played
           SOUND_FADING,     //!< normal music fading out, faster fading in
-          SOUND_FASTER,     //!< change pitch of normal music
-          SOUND_FAST}       //!< playing faster music or max pitch reached
+          SOUND_FAST}       //!< playing faster music
                              m_mode;
     float                    m_time_since_faster;
 
@@ -127,8 +127,6 @@ class MusicInformation : public NoCopy
     // ------------------------------------------------------------------------
     /** If available, returns the file name of the faster/last-lap music. */
     const std::string& getFastFilename() const { return m_fast_filename; }
-    // ------------------------------------------------------------------------
-    float getMaxPitch() const { return m_max_pitch; }
 
 };   // MusicInformation
 #endif
diff --git a/src/audio/music_ogg.cpp b/src/audio/music_ogg.cpp
index 8b8c421d6b8..72db0e122b8 100644
--- a/src/audio/music_ogg.cpp
+++ b/src/audio/music_ogg.cpp
@@ -35,6 +35,7 @@ MusicOggStream::MusicOggStream(float loop_start, float loop_end)
     m_soundSource     = -1;
     m_pausedMusic     = true;
     m_playing.store(false);
+    m_play_initialized.store(false);
     m_loop_start      = loop_start;
     m_loop_end        = loop_end;
 }   // MusicOggStream
@@ -166,6 +167,7 @@ bool MusicOggStream::release()
 
     m_soundSource = -1;
     m_playing.store(false);
+    m_play_initialized.store(false);
 
     return true;
 }   // release
@@ -187,6 +189,7 @@ bool MusicOggStream::playMusic()
     alSourcePlay(m_soundSource);
     m_pausedMusic = false;
     m_playing.store(true);
+    m_play_initialized.store(true);
     check("playMusic");
     return true;
 }   // playMusic
@@ -195,15 +198,6 @@ bool MusicOggStream::playMusic()
 bool MusicOggStream::isPlaying()
 {
     return m_playing.load();
-
-    /*
-    if (m_soundSource == -1) return false;
-
-    ALenum state;
-    alGetSourcei(m_soundSource, AL_SOURCE_STATE, &state);
-
-    return (state == AL_PLAYING);
-     */
 }   // isPlaying
 
 //-----------------------------------------------------------------------------
@@ -237,7 +231,8 @@ bool MusicOggStream::resumeMusic()
         return true;
     }
 
-    m_playing.store(true);
+    if(m_play_initialized.load()) // Avoid #5204
+        m_playing.store(true);
 
     alSourcePlay(m_soundSource);
     m_pausedMusic= false;
@@ -255,13 +250,6 @@ void MusicOggStream::setVolume(float volume)
     check("volume music");   // clear errors
 }   // setVolume
 
-//-----------------------------------------------------------------------------
-void MusicOggStream::updateFaster(float percent, float max_pitch)
-{
-    alSourcef(m_soundSource,AL_PITCH,1+max_pitch*percent);
-    update();
-}   // updateFaster
-
 //-----------------------------------------------------------------------------
 void MusicOggStream::update()
 {
diff --git a/src/audio/music_ogg.hpp b/src/audio/music_ogg.hpp
index 37c2c352c1e..7f7a80a7c25 100644
--- a/src/audio/music_ogg.hpp
+++ b/src/audio/music_ogg.hpp
@@ -49,7 +49,6 @@ class MusicOggStream : public Music
     virtual ~MusicOggStream();
 
     virtual void update();
-    virtual void updateFaster(float percent, float max_pitch);
 
     virtual bool load(const std::string& filename);
 
@@ -78,6 +77,7 @@ class MusicOggStream : public Music
     bool            m_error;
 
     std::atomic_bool m_playing;
+    std::atomic_bool m_play_initialized;
 
     ALuint m_soundBuffers[2];
     ALuint m_soundSource;
diff --git a/src/audio/sfx_manager.cpp b/src/audio/sfx_manager.cpp
index 66aeb38b69f..ce6b6623640 100644
--- a/src/audio/sfx_manager.cpp
+++ b/src/audio/sfx_manager.cpp
@@ -438,7 +438,7 @@ void SFXManager::mainLoop(void *obj)
             current->m_music_information->pauseMusic();           break;
         case SFX_MUSIC_RESUME:
             current->m_music_information->resumeMusic();
-            // This might be necessasary if the volume was changed
+            // This might be necessary if the volume was changed
             // in the in-game menu
             current->m_music_information->setDefaultVolume();     break;
         case SFX_MUSIC_SWITCH_FAST:
diff --git a/src/config/favorite_status.cpp b/src/config/favorite_status.cpp
index 85240cb2027..968e506d94c 100644
--- a/src/config/favorite_status.cpp
+++ b/src/config/favorite_status.cpp
@@ -61,12 +61,6 @@ FavoriteStatus::FavoriteStatus(const XMLNode* node, std::string parse_type)
     }
 }   // FavoriteStatus
 
-//------------------------------------------------------------------------------
-FavoriteStatus::~FavoriteStatus()
-{
-
-}   // ~FavoriteStatus
-
 //------------------------------------------------------------------------------
 /** Adds a new favorite track to this player profile and to the group
  * of favorite tracks of the Track Manager.
diff --git a/src/config/favorite_status.hpp b/src/config/favorite_status.hpp
index 522ae3dd550..cde113b1bc9 100644
--- a/src/config/favorite_status.hpp
+++ b/src/config/favorite_status.hpp
@@ -55,8 +55,6 @@ class FavoriteStatus
     /** Parse all <(parse_type)/> in <favorite> in xml node */
     FavoriteStatus(const XMLNode *node, std::string parse_type);
 
-    virtual ~FavoriteStatus();
-
     void save(UTFWriter &out);
 
     bool isFavorite(std::string ident);
diff --git a/src/config/player_profile.cpp b/src/config/player_profile.cpp
index e2d1aa9f739..8a4a8ee13a2 100644
--- a/src/config/player_profile.cpp
+++ b/src/config/player_profile.cpp
@@ -105,9 +105,22 @@ PlayerProfile::PlayerProfile(const XMLNode* node)
 //------------------------------------------------------------------------------
 PlayerProfile::~PlayerProfile()
 {
-    delete m_story_mode_status;
-    delete m_achievements_status;
-    delete m_favorite_track_status;
+    if (m_story_mode_status)
+    {
+        delete m_story_mode_status;
+    }
+    if (m_achievements_status)
+    {
+        delete m_achievements_status;
+    }
+    if (m_favorite_track_status)
+    {
+        delete m_favorite_track_status;
+    }
+    if (m_favorite_kart_status)
+    {
+        delete m_favorite_kart_status;
+    }
 #ifdef DEBUG
     m_magic_number = 0xDEADBEEF;
 #endif
diff --git a/src/config/saved_grand_prix.hpp b/src/config/saved_grand_prix.hpp
index a5c8eb70433..8d12d7d26a8 100644
--- a/src/config/saved_grand_prix.hpp
+++ b/src/config/saved_grand_prix.hpp
@@ -158,10 +158,6 @@ class SavedGrandPrix
     /** Returns time target used in Lap Trial mode */
     float getTimeTarget() const { return m_time_target; }
 
-    // ------------------------------------------------------------------------
-    /** Returns total laps in GP */
-    int getPlayerTotalLaps() const { return m_player_total_laps; }
-
     // ------------------------------------------------------------------------
     /** Sets the index of the last track finished. */
     void setNextTrack(int next_track) { m_next_track = next_track; }
diff --git a/src/graphics/camera/camera.hpp b/src/graphics/camera/camera.hpp
index 753b5af1b59..06372528dbe 100644
--- a/src/graphics/camera/camera.hpp
+++ b/src/graphics/camera/camera.hpp
@@ -185,6 +185,8 @@ class Camera : public NoCopy
     /** Returns the type of this camera. */
     CameraType getType() { return m_type; }
     // ------------------------------------------------------------------------
+    bool isNormal() { return (m_type == CM_TYPE_NORMAL); }
+    // ------------------------------------------------------------------------
     /** Sets the field of view for the irrlicht camera. */
     void setFoV() { m_camera->setFOV(m_fov); }
     // ------------------------------------------------------------------------
diff --git a/src/graphics/camera/camera_normal.cpp b/src/graphics/camera/camera_normal.cpp
index a1056985074..7ba5353afbb 100644
--- a/src/graphics/camera/camera_normal.cpp
+++ b/src/graphics/camera/camera_normal.cpp
@@ -31,6 +31,7 @@
 #include "karts/kart.hpp"
 #include "karts/kart_properties.hpp"
 #include "karts/skidding.hpp"
+#include "network/rewind_manager.hpp"
 #include "tracks/track.hpp"
 
 // ============================================================================
@@ -81,6 +82,8 @@ void CameraNormal::moveCamera(float dt, bool smooth, float cam_angle, float dist
 {
     if(!m_kart) return;
 
+    if (RewindManager::get()->isRewinding()) return;
+
     Kart *kart = dynamic_cast<Kart*>(m_kart);
     if (kart->isFlying())
     {
@@ -102,23 +105,34 @@ void CameraNormal::moveCamera(float dt, bool smooth, float cam_angle, float dist
     float skid_factor = ks->getVisualSkidRotation();
 
     float skid_angle = asinf(skid_factor);
-    float ratio = current_speed / max_speed_without_zipper;
 
+    // Adjust the distance of the camera to the kart with speed
+    // Note that distance is negative (< 0)
+    float ratio = current_speed / max_speed_without_zipper;
     ratio = ratio > -0.12f ? ratio : -0.12f;
+    float speed_factor = ((distance - 2.0f) - 1.0f * ratio) / (distance - 2.0f);
+    float camera_distance = distance * speed_factor;
 
-    // distance of camera from kart in x and z plane
-    float camera_distance = -1.25f - 2.5f * ratio;
-    float min_distance = (distance * 2.0f);
-    if (distance > 0) camera_distance += distance + 1; // note that distance < 0
-    if (camera_distance > min_distance) camera_distance = min_distance; // don't get too close to the kart
-
+    // Adjust the camera angle
     float tan_up = 0;
-    if (cam_angle > 0) tan_up = tanf(cam_angle) * distance;
-
-    // Defines how far camera should be from player kart.
-    Vec3 wanted_camera_offset(camera_distance * sinf(skid_angle / 2),
-        (0.85f + ratio / 2.5f) - tan_up,
-        camera_distance * cosf(skid_angle / 2));
+    if (cam_angle > 0) tan_up = tanf(cam_angle) * std::max(distance - 1.0f, distance * (1.0f + 0.25f * ratio));
+    // Avoid a camera razing the ground (it generates a lot of terrain clipping with the current near value of 1.0)
+    if (tan_up > -0.5f)
+        tan_up = -0.5f;
+
+    // Defines how far the camera should be from the player's kart.
+    float squared_x = distance * sinf(skid_angle / 2);
+    squared_x *= squared_x;
+    float squared_y = tan_up;
+    squared_y *= squared_y;
+    float squared_z = distance * cosf(skid_angle / 2);
+    squared_z *= squared_z;
+    float length = sqrt(squared_x + squared_y + squared_z);
+    float camera_distance_factor = -camera_distance * camera_distance / length;
+
+    Vec3 wanted_camera_offset(camera_distance_factor * sinf(skid_angle / 2),
+        -tan_up,
+        camera_distance_factor * cosf(skid_angle / 2));
 
     float delta = 1;
     float delta2 = 1;
@@ -177,7 +191,8 @@ void CameraNormal::moveCamera(float dt, bool smooth, float cam_angle, float dist
 //-----------------------------------------------------------------------------
 void CameraNormal::snapToPosition()
 {
-    moveCamera(1.0f, false, 0, 0);
+    float angle = UserConfigParams::m_camera_forward_up_angle * DEGREE_TO_RAD;
+    moveCamera(1.0f, false, angle, -m_distance);
 }   // snapToPosition
 
 //-----------------------------------------------------------------------------
@@ -192,6 +207,22 @@ void CameraNormal::getCameraSettings(float *above_kart, float *cam_angle,
                                      float *sideway, float *distance,
                                      bool *smoothing, float *cam_roll_angle)
 {
+    // Update the standard camera for users updating to 1.5
+    if(!UserConfigParams::m_camera_updated_one_five)
+    {
+        UserConfigParams::m_standard_camera_fov.revertToDefaults();
+        UserConfigParams::m_standard_camera_distance.revertToDefaults();
+        UserConfigParams::m_standard_camera_forward_up_angle.revertToDefaults();
+        if (UserConfigParams::m_camera_present == 1) // Currently using a standard camera 
+        {
+            UserConfigParams::m_camera_fov.revertToDefaults();
+            UserConfigParams::m_camera_distance.revertToDefaults();
+            UserConfigParams::m_camera_forward_up_angle.revertToDefaults();
+            m_distance = UserConfigParams::m_camera_distance;
+        }
+        UserConfigParams::m_camera_updated_one_five = true;
+    }
+
     switch(getMode())
     {
     case CM_NORMAL:
diff --git a/src/graphics/irr_driver.cpp b/src/graphics/irr_driver.cpp
index da4fc1aea84..5b598c4f674 100644
--- a/src/graphics/irr_driver.cpp
+++ b/src/graphics/irr_driver.cpp
@@ -803,7 +803,7 @@ void IrrDriver::initDevice()
 
     if (UserConfigParams::m_shadows_resolution != 0 &&
         (UserConfigParams::m_shadows_resolution < 512 ||
-         UserConfigParams::m_shadows_resolution > 2048))
+         UserConfigParams::m_shadows_resolution > 4096))
     {
         Log::warn("irr_driver",
                "Invalid value for UserConfigParams::m_shadows_resolution : %i",
diff --git a/src/graphics/lighting_passes.cpp b/src/graphics/lighting_passes.cpp
index d30c6cf4c7e..76459bb8954 100644
--- a/src/graphics/lighting_passes.cpp
+++ b/src/graphics/lighting_passes.cpp
@@ -170,7 +170,7 @@ class PointLightScatterShader : public TextureShader<PointLightScatterShader,
 };
 
 // ============================================================================
-class IBLShader : public TextureShader<IBLShader, 4>
+class IBLShader : public TextureShader<IBLShader, 6>
 {
 public:
     IBLShader()
@@ -181,12 +181,14 @@ class IBLShader : public TextureShader<IBLShader, 4>
         assignSamplerNames(0, "ntex",  ST_NEAREST_FILTERED,
                            1, "dtex",  ST_NEAREST_FILTERED,
                            2, "probe", ST_TRILINEAR_CUBEMAP,
-                           3, "albedo",ST_NEAREST_FILTERED);
+                           3, "albedo",ST_NEAREST_FILTERED,
+                           4, "ssao",  ST_NEAREST_FILTERED,
+                           5, "ctex",  ST_NEAREST_FILTERED);
     }   // IBLShader
 };   // IBLShader
 
 // ============================================================================
-class DegradedIBLShader : public TextureShader<DegradedIBLShader, 1>
+class DegradedIBLShader : public TextureShader<DegradedIBLShader, 2>
 {
 public:
     DegradedIBLShader()
@@ -194,7 +196,8 @@ class DegradedIBLShader : public TextureShader<DegradedIBLShader, 1>
         loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "degraded_ibl.frag");
         assignUniforms();
-        assignSamplerNames(0, "ntex", ST_NEAREST_FILTERED);
+        assignSamplerNames(0, "ntex", ST_NEAREST_FILTERED,
+                           1, "ssao", ST_NEAREST_FILTERED);
     }   // DegradedIBLShader
 };   // DegradedIBLShader
 
@@ -298,7 +301,9 @@ static void renderPointLights(unsigned count,
 void LightingPasses::renderEnvMap(GLuint normal_depth_texture,
                                   GLuint depth_stencil_texture,
                                   GLuint specular_probe,
-                                  GLuint albedo_buffer)
+                                  GLuint albedo_buffer,
+                                  GLuint ssao_texture,
+                                  GLuint diffuse_color_texture)
 {
     glDisable(GL_DEPTH_TEST);
     glEnable(GL_BLEND);
@@ -311,7 +316,7 @@ void LightingPasses::renderEnvMap(GLuint normal_depth_texture,
         glBindVertexArray(SharedGPUObjects::getFullScreenQuadVAO());
 
         DegradedIBLShader::getInstance()
-            ->setTextureUnits(normal_depth_texture);
+            ->setTextureUnits(normal_depth_texture, ssao_texture);
         DegradedIBLShader::getInstance()->setUniforms();
     }
     else
@@ -323,7 +328,9 @@ void LightingPasses::renderEnvMap(GLuint normal_depth_texture,
             normal_depth_texture,
             depth_stencil_texture,
             specular_probe,
-            albedo_buffer);
+            albedo_buffer,
+            ssao_texture,
+            diffuse_color_texture);
         IBLShader::getInstance()->setUniforms();
     }
 
@@ -434,6 +441,8 @@ void LightingPasses::renderLights(  bool has_shadow,
                                     GLuint depth_stencil_texture,
                                     GLuint albedo_texture,
                                     const FrameBuffer* shadow_framebuffer,
+                                    GLuint ssao_texture,
+                                    GLuint diffuse_color_texture,
                                     GLuint specular_probe)
 {
     {
@@ -441,7 +450,9 @@ void LightingPasses::renderLights(  bool has_shadow,
         renderEnvMap(normal_depth_texture,
                      depth_stencil_texture,
                      specular_probe,
-                     albedo_texture);
+                     albedo_texture,
+                     ssao_texture,
+                     diffuse_color_texture);
     }
 
     // Render sunlight if and only if track supports shadow
diff --git a/src/graphics/lighting_passes.hpp b/src/graphics/lighting_passes.hpp
index 2655a4f50d8..aef150a52bc 100644
--- a/src/graphics/lighting_passes.hpp
+++ b/src/graphics/lighting_passes.hpp
@@ -47,7 +47,9 @@ class LightingPasses
     void renderEnvMap(GLuint normal_depth_texture,
                       GLuint depth_stencil_texture,
                       GLuint specular_probe,
-                      GLuint albedo_buffer);
+                      GLuint albedo_buffer,
+                      GLuint ssao_buffer,
+                      GLuint diffuse_color_texture);
 
     /** Generate diffuse and specular map */
     void         renderSunlight(const core::vector3df &direction,
@@ -65,6 +67,8 @@ class LightingPasses
                         GLuint depth_stencil_texture,
                         GLuint albedo_texture,
                         const FrameBuffer* shadow_framebuffer,
+                        GLuint ssao_texture,
+                        GLuint diffuse_color_texture,
                         GLuint specular_probe);
     void renderLightsScatter(GLuint depth_stencil_texture,
                              const FrameBuffer& half1_framebuffer,
diff --git a/src/graphics/post_processing.cpp b/src/graphics/post_processing.cpp
index 092dfeaf1e7..98b2f6831b4 100644
--- a/src/graphics/post_processing.cpp
+++ b/src/graphics/post_processing.cpp
@@ -181,18 +181,18 @@ class Gaussian6HBlurShader : public TextureShader<Gaussian6HBlurShader, 1,
 };   // Gaussian6HBlurShader
 
 // ============================================================================
-class Gaussian17TapHShader : public TextureShader<Gaussian17TapHShader, 2,
+class Gaussian9TapHShader : public TextureShader<Gaussian9TapHShader, 2,
                                            core::vector2df>
 {
 public:
-    Gaussian17TapHShader()
+    Gaussian9TapHShader()
     {
         loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "bilateralH.frag");
         assignUniforms("pixel");
         assignSamplerNames(0, "tex", ST_BILINEAR_CLAMPED_FILTERED,
                            1, "depth", ST_BILINEAR_CLAMPED_FILTERED);
-    }   // Gaussian17TapHShader
+    }   // Gaussian9TapHShader
     // ------------------------------------------------------------------------
     void render(const FrameBuffer &fb, const FrameBuffer &linear_depth,
                 int width, int height)
@@ -202,15 +202,15 @@ class Gaussian17TapHShader : public TextureShader<Gaussian17TapHShader, 2,
         drawFullScreenEffect(core::vector2df(1.0f/width, 1.0f/height));
 
     }   // render
-};   // Gaussian17TapHShader
+};   // Gaussian9TapHShader
 
 // ============================================================================
-class ComputeGaussian17TapHShader : public TextureShader<ComputeGaussian17TapHShader, 2,
+class ComputeGaussian9TapHShader : public TextureShader<ComputeGaussian9TapHShader, 2,
                                                   core::vector2df>
 {
 public:
     GLuint m_dest_tu;
-    ComputeGaussian17TapHShader()
+    ComputeGaussian9TapHShader()
     {
 #if !defined(USE_GLES2)
         loadProgram(OBJECT,  GL_COMPUTE_SHADER, "bilateralH.comp");
@@ -220,7 +220,7 @@ class ComputeGaussian17TapHShader : public TextureShader<ComputeGaussian17TapHSh
                            1, "depth", ST_NEARED_CLAMPED_FILTERED);
         assignTextureUnit(m_dest_tu, "dest");
 #endif
-    }   // ComputeGaussian17TapHShader
+    }   // ComputeGaussian9TapHShader
     // ------------------------------------------------------------------------
     void render(const FrameBuffer &fb, const FrameBuffer &auxiliary,
                 const FrameBuffer &linear_depth,
@@ -234,18 +234,18 @@ class ComputeGaussian17TapHShader : public TextureShader<ComputeGaussian17TapHSh
         glBindImageTexture(m_dest_tu, auxiliary.getRTT()[0], 0, false,
                            0, GL_WRITE_ONLY, GL_R16F);
         setUniforms(core::vector2df(1.0f/width, 1.0f/height));
-        glDispatchCompute((int)width / 8 + 1, (int)height / 8 + 1, 1);
+        glDispatchCompute((int)width / 4 + 1, (int)height / 4 + 1, 1);
 #endif
     }   // render
-};   // ComputeGaussian17TapHShader
+};   // ComputeGaussian9TapHShader
 
 
 // ============================================================================
-class Gaussian17TapVShader : public TextureShader<Gaussian17TapVShader, 2,
+class Gaussian9TapVShader : public TextureShader<Gaussian9TapVShader, 2,
                                            core::vector2df>
 {
 public:
-    Gaussian17TapVShader()
+    Gaussian9TapVShader()
     {
         loadProgram(OBJECT, GL_VERTEX_SHADER, "screenquad.vert",
                             GL_FRAGMENT_SHADER, "bilateralV.frag");
@@ -253,7 +253,7 @@ class Gaussian17TapVShader : public TextureShader<Gaussian17TapVShader, 2,
 
         assignSamplerNames(0, "tex", ST_BILINEAR_CLAMPED_FILTERED,
                            1, "depth", ST_BILINEAR_CLAMPED_FILTERED);
-    }   // Gaussian17TapVShader
+    }   // Gaussian9TapVShader
     // ------------------------------------------------------------------------
     void render(const FrameBuffer &auxiliary, const FrameBuffer &linear_depth,
                 int width, int height)
@@ -263,16 +263,16 @@ class Gaussian17TapVShader : public TextureShader<Gaussian17TapVShader, 2,
         drawFullScreenEffect(core::vector2df(1.0f/width, 1.0f/height));
 
     }   // render
-};   // Gaussian17TapVShader
+};   // Gaussian9TapVShader
 
 // ============================================================================
-class ComputeGaussian17TapVShader : public TextureShader<ComputeGaussian17TapVShader, 2,
+class ComputeGaussian9TapVShader : public TextureShader<ComputeGaussian9TapVShader, 2,
                                                   core::vector2df>
 {
 public:
     GLuint m_dest_tu;
 
-    ComputeGaussian17TapVShader()
+    ComputeGaussian9TapVShader()
     {
 #if !defined(USE_GLES2)
         loadProgram(OBJECT, GL_COMPUTE_SHADER, "bilateralV.comp");
@@ -282,7 +282,7 @@ class ComputeGaussian17TapVShader : public TextureShader<ComputeGaussian17TapVSh
                            1, "depth", ST_NEARED_CLAMPED_FILTERED);
         assignTextureUnit(m_dest_tu, "dest");
 #endif
-    }   // ComputeGaussian17TapVShader
+    }   // ComputeGaussian9TapVShader
     // ------------------------------------------------------------------------
     void render(const FrameBuffer &auxiliary, const FrameBuffer &fb,
                 const FrameBuffer &linear_depth,
@@ -297,11 +297,11 @@ class ComputeGaussian17TapVShader : public TextureShader<ComputeGaussian17TapVSh
         glBindImageTexture(m_dest_tu, fb.getRTT()[0], 0, false, 0,
                            GL_WRITE_ONLY, GL_R16F);
         setUniforms(core::vector2df(1.0f/width, 1.0f/height));
-        glDispatchCompute((int)fb.getWidth()  / 8 + 1,
-                          (int)fb.getHeight() / 8 + 1, 1);
+        glDispatchCompute((int)fb.getWidth()  / 4 + 1,
+                          (int)fb.getHeight() / 4 + 1, 1);
 #endif
     }   // render
-};   // ComputeGaussian17TapVShader
+};   // ComputeGaussian9TapVShader
 
 // ============================================================================
 class BloomShader : public TextureShader<BloomShader, 1, float>
@@ -896,13 +896,13 @@ void PostProcessing::renderHorizontalBlur(const FrameBuffer &in_fbo,
 
 
 // ----------------------------------------------------------------------------
-void PostProcessing::renderGaussian17TapBlur(const FrameBuffer &in_fbo,
+void PostProcessing::renderGaussian9TapBlur(const FrameBuffer &in_fbo,
                                              const FrameBuffer &auxiliary,
                                              const FrameBuffer &linear_depth) const
 {
     assert(in_fbo.getWidth() == auxiliary.getWidth() &&
            in_fbo.getHeight() == auxiliary.getHeight());
-           
+     
 #if !defined(USE_GLES2)
     if (CVS->supportsComputeShadersFiltering())
         glMemoryBarrier(GL_FRAMEBUFFER_BARRIER_BIT);
@@ -912,14 +912,14 @@ void PostProcessing::renderGaussian17TapBlur(const FrameBuffer &in_fbo,
         if (!CVS->supportsComputeShadersFiltering())
         {
             auxiliary.bind();
-            Gaussian17TapHShader::getInstance()->render(in_fbo,
+            Gaussian9TapHShader::getInstance()->render(in_fbo,
                                                         linear_depth,
                                                         in_fbo.getWidth(),
                                                         in_fbo.getHeight());
         }
         else
         {
-            ComputeGaussian17TapHShader::getInstance()->render(in_fbo,
+            ComputeGaussian9TapHShader::getInstance()->render(in_fbo,
                                                                auxiliary,
                                                                linear_depth,
                                                                in_fbo.getWidth(),
@@ -936,14 +936,14 @@ void PostProcessing::renderGaussian17TapBlur(const FrameBuffer &in_fbo,
         if (!CVS->supportsComputeShadersFiltering())
         {
             in_fbo.bind();
-            Gaussian17TapVShader::getInstance()->render(auxiliary,
+            Gaussian9TapVShader::getInstance()->render(auxiliary,
                                                         linear_depth,
                                                         in_fbo.getWidth(),
                                                         in_fbo.getHeight());
         }
         else
         {
-            ComputeGaussian17TapVShader::getInstance()->render(auxiliary,
+            ComputeGaussian9TapVShader::getInstance()->render(auxiliary,
                                                                in_fbo, 
                                                                linear_depth,
                                                                in_fbo.getWidth(),
@@ -955,7 +955,7 @@ void PostProcessing::renderGaussian17TapBlur(const FrameBuffer &in_fbo,
     if (CVS->supportsComputeShadersFiltering())
         glMemoryBarrier(GL_TEXTURE_FETCH_BARRIER_BIT);
 #endif
-}   // renderGaussian17TapBlur
+}   // renderGaussian9TapBlur
 
 // ----------------------------------------------------------------------------
 void PostProcessing::renderPassThrough(GLuint tex, unsigned width,
diff --git a/src/graphics/post_processing.hpp b/src/graphics/post_processing.hpp
index fa2fc4cbd37..264d6540f5c 100644
--- a/src/graphics/post_processing.hpp
+++ b/src/graphics/post_processing.hpp
@@ -65,7 +65,7 @@ class PostProcessing
                               float sigmaV, float sigmaH) const;
 	void renderHorizontalBlur(const FrameBuffer &in_fbo, const FrameBuffer &auxiliary) const;
 
-    void renderGaussian17TapBlur(const FrameBuffer &in_fbo,
+    void renderGaussian9TapBlur(const FrameBuffer &in_fbo,
                                  const FrameBuffer &auxiliary,
                                  const FrameBuffer &linear_depth) const;
 
diff --git a/src/graphics/shader_based_renderer.cpp b/src/graphics/shader_based_renderer.cpp
index 943b8348fff..6f1f17e7c8c 100644
--- a/src/graphics/shader_based_renderer.cpp
+++ b/src/graphics/shader_based_renderer.cpp
@@ -138,7 +138,7 @@ void ShaderBasedRenderer::renderSSAO() const
     FrameBuffer::blit(m_rtts->getFBO(FBO_SSAO),
                       m_rtts->getFBO(FBO_HALF1_R), 
                       GL_COLOR_BUFFER_BIT, GL_LINEAR);
-    m_post_processing->renderGaussian17TapBlur(m_rtts->getFBO(FBO_HALF1_R), 
+    m_post_processing->renderGaussian9TapBlur(m_rtts->getFBO(FBO_HALF1_R), 
                                                m_rtts->getFBO(FBO_HALF2_R),
                                                m_rtts->getFBO(FBO_LINEAR_DEPTH));
 
@@ -195,7 +195,7 @@ void ShaderBasedRenderer::renderShadows()
 }
 
 // ============================================================================
-class CombineDiffuseColor : public TextureShader<CombineDiffuseColor, 7,
+class CombineDiffuseColor : public TextureShader<CombineDiffuseColor, 6,
                                                  std::array<float, 4> >
 {
 public:
@@ -206,17 +206,16 @@ class CombineDiffuseColor : public TextureShader<CombineDiffuseColor, 7,
         assignUniforms("bg_color");
         assignSamplerNames(0, "diffuse_map", ST_NEAREST_FILTERED,
                            1, "specular_map", ST_NEAREST_FILTERED,
-                           2, "ssao_tex", ST_NEAREST_FILTERED,
-                           3, "normal_color", ST_NEAREST_FILTERED,
-                           4, "diffuse_color", ST_NEAREST_FILTERED,
-                           5, "depth_stencil", ST_NEAREST_FILTERED,
-                           6, "light_scatter", ST_NEAREST_FILTERED);
+                           2, "normal_color", ST_NEAREST_FILTERED,
+                           3, "diffuse_color", ST_NEAREST_FILTERED,
+                           4, "depth_stencil", ST_NEAREST_FILTERED,
+                           5, "light_scatter", ST_NEAREST_FILTERED);
     }   // CombineDiffuseColor
     // ------------------------------------------------------------------------
-    void render(GLuint dm, GLuint sm, GLuint st, GLuint nt, GLuint dc,
+    void render(GLuint dm, GLuint sm, GLuint nt, GLuint dc,
                 GLuint ds, GLuint lt, const std::array<float, 4> & bg_color)
     {
-        setTextureUnits(dm, sm, st, nt, dc, ds, lt);
+        setTextureUnits(dm, sm, nt, dc, ds, lt);
         drawFullScreenEffect(bg_color);
     }   // render
 };   // CombineDiffuseColor
@@ -266,6 +265,15 @@ void ShaderBasedRenderer::renderSceneDeferred(scene::ICameraSceneNode * const ca
         SP::draw(SP::RP_1ST, SP::DCT_NORMAL);
     }
 
+    // Handle SSAO
+    {
+        PROFILER_PUSH_CPU_MARKER("- SSAO", 0xFF, 0xFF, 0x00);
+        ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SSAO));
+        if (UserConfigParams::m_ssao)
+            renderSSAO();
+        PROFILER_POP_CPU_MARKER();
+    }
+
     glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
     // Lights
     {
@@ -282,19 +290,12 @@ void ShaderBasedRenderer::renderSceneDeferred(scene::ICameraSceneNode * const ca
                                         m_rtts->getDepthStencilTexture(),
                                         m_rtts->getRenderTarget(RTT_COLOR),
                                         m_rtts->getShadowFrameBuffer(),
+                                        m_rtts->getRenderTarget(RTT_HALF1_R),
+                                        m_rtts->getRenderTarget(RTT_SP_DIFF_COLOR),
                                         specular_probe);
         PROFILER_POP_CPU_MARKER();
     }
 
-    // Handle SSAO
-    {
-        PROFILER_PUSH_CPU_MARKER("- SSAO", 0xFF, 0xFF, 0x00);
-        ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_SSAO));
-        if (UserConfigParams::m_ssao)
-            renderSSAO();
-        PROFILER_POP_CPU_MARKER();
-    }
-
     const Track * const track = Track::getCurrentTrack();
     // Render discrete lights scattering
     if (UserConfigParams::m_light_scatter && track && track->isFogEnabled())
@@ -349,7 +350,6 @@ void ShaderBasedRenderer::renderSceneDeferred(scene::ICameraSceneNode * const ca
         CombineDiffuseColor::getInstance()->render(
             m_rtts->getRenderTarget(RTT_DIFFUSE),
             m_rtts->getRenderTarget(RTT_SPECULAR),
-            m_rtts->getRenderTarget(RTT_HALF1_R),
             m_rtts->getRenderTarget(RTT_NORMAL_AND_DEPTH),
             m_rtts->getRenderTarget(RTT_SP_DIFF_COLOR),
             m_rtts->getDepthStencilTexture(),
diff --git a/src/graphics/shadow_matrices.cpp b/src/graphics/shadow_matrices.cpp
index 1d048f721e2..c655e1b0c74 100644
--- a/src/graphics/shadow_matrices.cpp
+++ b/src/graphics/shadow_matrices.cpp
@@ -143,11 +143,9 @@ static std::vector<vector3df> getFrustrumVertex(const scene::SViewFrustum &frust
  *  and 1.
  *  \param transform a transform matrix.
  *  \param pointsInside a vector of point in 3d space.
- *  \param size returns the size (width, height) of shadowmap coverage
  */
-core::matrix4 ShadowMatrices::getTighestFitOrthoProj(const core::matrix4 &transform,
-                                    const std::vector<vector3df> &pointsInside,
-                                    std::pair<float, float> &size)
+core::matrix4 ShadowMatrices::getTightestFitOrthoProj(const core::matrix4 &transform,
+                                    const std::vector<vector3df> &pointsInside)
 {
     float xmin = std::numeric_limits<float>::infinity();
     float xmax = -std::numeric_limits<float>::infinity();
@@ -173,9 +171,6 @@ core::matrix4 ShadowMatrices::getTighestFitOrthoProj(const core::matrix4 &transf
     float up = ymin;
     float down = ymax;
 
-    size.first = right - left;
-    size.second = down - up;
-
     core::matrix4 tmp_matrix;
     // Prevent Matrix without extend
     if (left == right || up == down)
@@ -184,7 +179,7 @@ core::matrix4 ShadowMatrices::getTighestFitOrthoProj(const core::matrix4 &transf
         down, up,
         zmin - 100, zmax);
     return tmp_matrix;
-}   // getTighestFitOrthoProj
+}   // getTightestFitOrthoProj
 
 // ----------------------------------------------------------------------------
 /** Generate View, Projection, Inverse View, Inverse Projection, ViewProjection
@@ -280,8 +275,7 @@ void ShadowMatrices::computeMatrixesAndCameras(scene::ICameraSceneNode *const ca
             memcpy(m_shadows_cam[i], tmp, 24 * sizeof(float));
 
             std::vector<vector3df> vectors = getFrustrumVertex(*frustrum);
-            tmp_matrix = getTighestFitOrthoProj(sun_cam_view_matrix, vectors,
-                                                m_shadow_scales[i]);
+            tmp_matrix = getTightestFitOrthoProj(sun_cam_view_matrix, vectors);
 
 
             m_shadow_cam_nodes[i]->setProjectionMatrix(tmp_matrix, true);
diff --git a/src/graphics/shadow_matrices.hpp b/src/graphics/shadow_matrices.hpp
index 82918955a90..183438f9226 100644
--- a/src/graphics/shadow_matrices.hpp
+++ b/src/graphics/shadow_matrices.hpp
@@ -46,16 +46,14 @@ class ShadowMatrices
     std::vector<core::matrix4> m_sun_ortho_matrices;
     scene::ICameraSceneNode   *m_sun_cam;
     scene::ICameraSceneNode   *m_shadow_cam_nodes[4];
-    std::pair<float, float>    m_shadow_scales[4];
     core::matrix4              m_rsm_matrix;
     bool                       m_rsm_matrix_initialized;
     float                      m_shadows_cam[4][24];
     bool                       m_rsm_map_available;
     float                      m_mat_ubo[16 * 9 + 2];
 
-    core::matrix4 getTighestFitOrthoProj(const core::matrix4 &transform,
-                              const std::vector<core::vector3df> &pointsInside,
-                              std::pair<float, float> &size);
+    core::matrix4 getTightestFitOrthoProj(const core::matrix4 &transform,
+                              const std::vector<core::vector3df> &pointsInside);
     void renderWireFrameFrustrum(float *tmp, unsigned i);
 public:
 
@@ -84,11 +82,6 @@ class ShadowMatrices
         return m_sun_ortho_matrices;
     }
     // ------------------------------------------------------------------------
-    const std::pair<float, float>* getShadowScales() const
-    {
-        return m_shadow_scales;
-    }
-    // ------------------------------------------------------------------------
     const float* getMatricesData() const { return m_mat_ubo; }
 
 };   // class ShadowMatrices
diff --git a/src/graphics/sp/sp_base.cpp b/src/graphics/sp/sp_base.cpp
index cc9265b33ee..f05fd30cec0 100644
--- a/src/graphics/sp/sp_base.cpp
+++ b/src/graphics/sp/sp_base.cpp
@@ -123,7 +123,7 @@ unsigned g_skinning_offset = 0;
 // ----------------------------------------------------------------------------
 std::vector<SPMeshNode*> g_skinning_mesh;
 // ----------------------------------------------------------------------------
-int g_skinning_tbo_limit = 0;
+bool g_skinning_use_tbo = false;
 // ----------------------------------------------------------------------------
 int sp_cur_shadow_cascade = 0;
 // ----------------------------------------------------------------------------
@@ -319,12 +319,13 @@ void initSkinning()
     else
     {
 #ifndef USE_GLES2
-        glGetIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE, &g_skinning_tbo_limit);
-        if (stk_config->m_max_skinning_bones << 6 > (unsigned)g_skinning_tbo_limit)
+        int skinning_tbo_limit;
+        glGetIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE, &skinning_tbo_limit);
+        if (stk_config->m_max_skinning_bones << 6 > (unsigned)skinning_tbo_limit)
         {
             Log::warn("SharedGPUObjects", "Too many bones for skinning, max: %d",
-                      g_skinning_tbo_limit >> 6);
-            stk_config->m_max_skinning_bones = g_skinning_tbo_limit >> 6;
+                      skinning_tbo_limit >> 6);
+            stk_config->m_max_skinning_bones = skinning_tbo_limit >> 6;
         }
         Log::info("SharedGPUObjects", "Hardware Skinning enabled, method: TBO, "
                   "max bones: %u", stk_config->m_max_skinning_bones);
@@ -444,7 +445,14 @@ void init()
 
     if (CVS->isARBTextureBufferObjectUsable())
     {
-        glGetIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE_ARB, &g_skinning_tbo_limit);
+        int skinning_tbo_limit;
+        glGetIntegerv(GL_MAX_TEXTURE_BUFFER_SIZE_ARB, &skinning_tbo_limit);
+        
+        g_skinning_use_tbo = skinning_tbo_limit >= stk_config->m_max_skinning_bones << 6;
+    }
+    else
+    {
+        g_skinning_use_tbo = false;
     }
 
     initSkinning();
@@ -655,8 +663,7 @@ SPShader* getNormalVisualizer()
 // ----------------------------------------------------------------------------
 bool skinningUseTBO()
 {
-    return CVS->isARBTextureBufferObjectUsable()
-        && g_skinning_tbo_limit >= 64 * stk_config->m_max_skinning_bones;
+    return g_skinning_use_tbo;
 }
 
 
diff --git a/src/guiengine/event_handler.cpp b/src/guiengine/event_handler.cpp
index a30c1c24e19..c931c6d2cd6 100644
--- a/src/guiengine/event_handler.cpp
+++ b/src/guiengine/event_handler.cpp
@@ -446,7 +446,7 @@ void EventHandler::sendNavigationEvent(const NavigationDirection nav, const int
 
     if (!handled_by_widget)
     {
-        navigate(nav, playerID);
+        navigate(nav, GUIEngine::getFocusForPlayer(playerID), playerID);
     }
 } // sendNavigationEvent
 
@@ -456,11 +456,9 @@ void EventHandler::sendNavigationEvent(const NavigationDirection nav, const int
  *
  * \param nav Determine in which direction to navigate
  */
-void EventHandler::navigate(const NavigationDirection nav, const int playerID)
+void EventHandler::navigate(const NavigationDirection nav, Widget* starting_widget, const int playerID)
 {
-    Widget* w = GUIEngine::getFocusForPlayer(playerID);
-
-    int next_id = findIDClosestWidget(nav, playerID, w, false);
+    int next_id = findIDClosestWidget(nav, playerID, starting_widget, false);
 
     if (next_id != -1)
     {
@@ -482,9 +480,10 @@ void EventHandler::navigate(const NavigationDirection nav, const int playerID)
             assert(ribbon != NULL);
             if (ribbon->getRibbonType() == GUIEngine::RibbonType::RIBBON_VERTICAL_TABS)
             {
-                int new_selection = (nav == NAV_UP) ?
-                                   ribbon->getActiveChildrenNumber(playerID) - 1 : 0;
-                ribbon->setSelection(new_selection, playerID);
+                // Some of the tabs may be disabled. So we navigate until an active tab is found
+                (nav == NAV_UP) ? ribbon->setLastSelection(playerID)
+                                : ribbon->setFirstSelection(playerID);
+
                 // The tab selection triggers an action
                 sendEventToUser(ribbon, ribbon->m_properties[PROP_ID], playerID);
             }
@@ -506,19 +505,19 @@ void EventHandler::navigate(const NavigationDirection nav, const int playerID)
 } // navigate
 
 /**
- * This function use simple heuristic to find the closest widget
- * in the requested direction,
+ * This function use simple heuristics to find the closest widget
+ * in the requested direction.
  * It prioritize widgets close vertically to widget close horizontally,
  * as it is expected behavior in any direction.
  * Several hardcoded values are used, having been found to work well
  * experimentally while keeping simple heuristics.
  */
 int EventHandler::findIDClosestWidget(const NavigationDirection nav, const int playerID,
-                                      GUIEngine::Widget* w, bool ignore_disabled, int recursion_counter)
+                                      Widget* w, bool ignore_disabled, int recursion_counter)
 {
     int closest_widget_id = -1;
     int distance = 0;
-    // So that the UI behavior don't change when it is upscaled
+    // So that the UI behavior doesn't change when it is upscaled
     const int BIG_DISTANCE = irr_driver->getActualScreenSize().Width*100;
     int smallest_distance = BIG_DISTANCE;
     // Used when there is no suitable widget in the requested direction
@@ -538,7 +537,7 @@ int EventHandler::findIDClosestWidget(const NavigationDirection nav, const int p
         // - it doesn't match a widget
         // - it doesn't match a focusable widget
         // - it corresponds to the current widget
-        // - it corresponds to an invisible or disabled widget
+        // - it corresponds to an invisible or disabled widget (while ignore_disabled is true)
         // - the player is not allowed to select it
         // - Its base coordinates are negative (such as buttons within ribbons)
         if (w_test == NULL || !Widget::isFocusableId(i) || w == w_test ||
@@ -581,16 +580,13 @@ int EventHandler::findIDClosestWidget(const NavigationDirection nav, const int p
 
         if (nav == NAV_UP || nav == NAV_DOWN)
         {
+            // Compare current top point with other widget lowest point
             if (nav == NAV_UP)
-            {
-                // Compare current top point with other widget lowest point
                 distance = w->m_y - (w_test->m_y + w_test->m_h);
-            }
+
+            // compare current lowest point with other widget top point
             else
-            {
-                // compare current lowest point with other widget top point
                 distance = w_test->m_y - (w->m_y + w->m_h);
-            }
 
             // Better select an item on the side that one much higher,
             // so make the vertical distance matter much more
@@ -612,16 +608,14 @@ int EventHandler::findIDClosestWidget(const NavigationDirection nav, const int p
         }
         else if (nav == NAV_LEFT || nav == NAV_RIGHT)
         {
+            // compare current leftmost point with other widget rightmost
             if (nav == NAV_LEFT)
-            {
-                // compare current leftmost point with other widget rightmost
                 distance = w->m_x - rightmost;
-            }
+
+            // compare current rightmost point with other widget leftmost
             else
-            {
-                // compare current rightmost point with other widget leftmost
                 distance = w_test->m_x - (w->m_x + w->m_w);
-            }
+
             wrapping_distance = distance;
 
             int down_offset = std::max(0, w_test->m_y - w->m_y);
@@ -676,6 +670,7 @@ int EventHandler::findIDClosestWidget(const NavigationDirection nav, const int p
 
     int closest_id = (smallest_distance < BIG_DISTANCE) ? closest_widget_id :
                                                           closest_wrapping_widget_id;
+
     Widget* w_test = GUIEngine::getWidget(closest_id);
     
     if (w_test == NULL)
@@ -686,21 +681,19 @@ int EventHandler::findIDClosestWidget(const NavigationDirection nav, const int p
     // This allows to skip over disabled/invisible widgets in a grid
     if (!w_test->isVisible() || !w_test->isActivated())
     {
-        // Can skip over at most 3 consecutive disabled/invisible widget
+        // Can skip over at most 3 consecutive disabled/invisible widgets
         if (recursion_counter <=2)
-        {
-            recursion_counter++;
-            return findIDClosestWidget(nav, playerID, w_test, /*ignore disabled*/ false, recursion_counter);
-        }
-        // If nothing has been found, do a search ignoring disabled/invisible widgets,
-        // restarting from the initial focused widget (otherwise, it could lead to weird results) 
+            closest_id = findIDClosestWidget(nav, playerID, w_test, /*ignore disabled*/ false, recursion_counter + 1);
+        // We have only found disabled/invisible widgets on our path
         else if (recursion_counter == 3)
-        {
-            Widget* w_focus = GUIEngine::getFocusForPlayer(playerID);
-            return findIDClosestWidget(nav, playerID, w_focus, /*ignore disabled*/ true, recursion_counter);
-        }
+            closest_id = -1;
     }
 
+    // If nothing has been found or if we looped back to the starting widget (see issue #5283),
+    // do a search ignoring disabled/invisible widgets, restarting from the initial widget
+    if (recursion_counter == 0 && (closest_id == -1 || GUIEngine::getWidget(closest_id) == w))
+        closest_id = findIDClosestWidget(nav, playerID, w, /*ignore disabled*/ true, 1 /* avoid infinite loops */);
+
     return closest_id;
 } // findIDClosestWidget
 
diff --git a/src/guiengine/event_handler.hpp b/src/guiengine/event_handler.hpp
index ab8f6471986..b032b4977c2 100644
--- a/src/guiengine/event_handler.hpp
+++ b/src/guiengine/event_handler.hpp
@@ -72,7 +72,7 @@ namespace GUIEngine
         EventPropagation onGUIEvent(const irr::SEvent& event);
         EventPropagation onWidgetActivated(Widget* w, const int playerID, Input::InputType type);
         void sendNavigationEvent(const NavigationDirection nav, const int playerID);
-        void navigate(const NavigationDirection nav, const int playerID);
+        void navigate(const NavigationDirection nav, Widget* starting_widget, const int playerID);
 
         /** \brief          send an event to the GUI module user's event callback
           * \param widget   the widget that triggerred this event
@@ -114,7 +114,7 @@ namespace GUIEngine
         
         void setAcceptEvents(bool value) { m_accept_events = value; }
         int findIDClosestWidget(const NavigationDirection nav, const int playerID,
-                                Widget* w, bool ignore_disabled, int recursion_counter=1);
+                                Widget* w, bool ignore_disabled, int recursion_counter=0);
     };
 
 }
diff --git a/src/guiengine/skin.cpp b/src/guiengine/skin.cpp
index 9a674c75b16..e4e1569d6eb 100644
--- a/src/guiengine/skin.cpp
+++ b/src/guiengine/skin.cpp
@@ -1424,10 +1424,11 @@ void Skin::drawRibbonChild(const core::recti &rect, Widget* widget,
         }
 
         const bool mark_focused =
-            focused || (parent_focused && parentRibbonWidget != NULL &&
+            (focused || (parent_focused && parentRibbonWidget != NULL &&
                           parentRibbonWidget->m_mouse_focus == widget) ||
                        (mark_selected && !always_show_selection &&
-                          parent_focused);
+                          parent_focused)) &&
+                        widget->m_properties[PROP_FOCUS_ICON].size() == 0;
 
         /* draw "selection bubble" if relevant */
         if (always_show_selection && mark_selected)
diff --git a/src/guiengine/widgets/ribbon_widget.cpp b/src/guiengine/widgets/ribbon_widget.cpp
index a252ecc3394..1b8b76ef728 100644
--- a/src/guiengine/widgets/ribbon_widget.cpp
+++ b/src/guiengine/widgets/ribbon_widget.cpp
@@ -307,6 +307,30 @@ void RibbonWidget::removeChildNamed(const char* name)
     }
 }
 
+// ----------------------------------------------------------------------------
+
+ /** Sets the first active item within the ribbon as selected,
+  * or the last one if 'reverse_order' is true. */
+void RibbonWidget::setFirstSelection(const int playerID, bool reverse_order)
+{
+    // Despite the name, "active children" includes elements that have been created
+    // and disabled with setActive(false)
+    // TODO: rename it to be clearer
+    int id = (reverse_order) ? getActiveChildrenNumber(playerID) - 1 : 0;
+    while (id >= 0 && id <= (getActiveChildrenNumber(playerID) - 1))
+    {
+        if (m_active_children[id].isActivated())
+            break;
+
+        id = (reverse_order) ? id - 1 : id + 1;
+    }
+
+    // If every single element within the ribbon is desactivated, we will pick
+    // the last (first) even if disabled, but this case should not arise.
+    m_selection[playerID] = id;
+    updateSelection();
+}   // setFirstSelection
+
 // ----------------------------------------------------------------------------
 
 void RibbonWidget::select(std::string item, const int mousePlayerID)
diff --git a/src/guiengine/widgets/ribbon_widget.hpp b/src/guiengine/widgets/ribbon_widget.hpp
index 5cb05414052..bbcd3b905d4 100644
--- a/src/guiengine/widgets/ribbon_widget.hpp
+++ b/src/guiengine/widgets/ribbon_widget.hpp
@@ -173,6 +173,13 @@ namespace GUIEngine
         /** Sets the ID of the selected item within the ribbon */
         void setSelection(const int i, const int playerID)
                              { m_selection[playerID] = i; updateSelection(); }
+
+        /** Sets the first active item within the ribbon as selected */
+        void setFirstSelection(const int playerID, bool reverse_order = false);
+
+        /** Sets the last active item within the ribbon as selected */
+        void setLastSelection(const int playerID)
+                             { setFirstSelection(playerID, true); }
         
         /** Select an item in the ribbon by its internal name */
         void select(std::string item, const int playerID);
diff --git a/src/input/device_manager.cpp b/src/input/device_manager.cpp
index 6a423b516cc..189172c9fa2 100644
--- a/src/input/device_manager.cpp
+++ b/src/input/device_manager.cpp
@@ -611,6 +611,24 @@ KeyboardDevice* DeviceManager::getKeyboardFromBtnID(const int button_id)
     return NULL;
 }   // getKeyboardFromButtonID
 
+// -----------------------------------------------------------------------------
+GamePadDevice* DeviceManager::getGamePad(const int i)
+{
+    if (i>= 0 && i < (int)m_gamepads.size())
+        return m_gamepads.get(i);
+    else
+        return NULL;
+}
+
+// -----------------------------------------------------------------------------
+KeyboardDevice* DeviceManager::getKeyboard(const int i)
+{
+    if (i >= 0 && i < (int)m_keyboards.size())
+        return m_keyboards.get(i);
+    else
+        return NULL;
+}
+
 // -----------------------------------------------------------------------------
 
 void DeviceManager::shutdown()
diff --git a/src/input/device_manager.hpp b/src/input/device_manager.hpp
index 126718679d6..b6ca0366b3e 100644
--- a/src/input/device_manager.hpp
+++ b/src/input/device_manager.hpp
@@ -98,8 +98,6 @@ class DeviceManager: public NoCopy
     void shutdown();
 
 public:
-
-
     DeviceManager();
     ~DeviceManager();
 
@@ -111,7 +109,7 @@ class DeviceManager: public NoCopy
     void addGamepad(GamePadDevice* d);
     int getGamePadAmount() const                            { return m_gamepads.size(); }
     int getGamePadConfigAmount() const                      { return m_gamepad_configs.size(); }
-    GamePadDevice*      getGamePad(const int i)             { return m_gamepads.get(i); }
+    GamePadDevice*      getGamePad(const int i);
     GamepadConfig*      getGamepadConfig(const int i)       { return m_gamepad_configs.get(i); }
     GamePadDevice*      getGamePadFromIrrID(const int i);
     void                clearGamepads();
@@ -135,7 +133,7 @@ class DeviceManager: public NoCopy
         return active;
     }
     int                 getKeyboardConfigAmount() const     { return m_keyboard_configs.size(); }
-    KeyboardDevice*     getKeyboard(const int i)            { return m_keyboards.get(i); }
+    KeyboardDevice*     getKeyboard(const int i);
     KeyboardConfig*     getKeyboardConfig(const int i)      { return m_keyboard_configs.get(i); }
     KeyboardDevice*     getKeyboardFromBtnID(const int btnID);
 
diff --git a/src/items/attachment.cpp b/src/items/attachment.cpp
index 739432556bf..78da8a2986f 100644
--- a/src/items/attachment.cpp
+++ b/src/items/attachment.cpp
@@ -617,9 +617,34 @@ void Attachment::updateGraphics(float dt)
             World::getWorld()->getTicksSinceStart()) / 0.7f;
         if (scale_ratio > 0.0f)
         {
-            float scale = 0.3f * scale_ratio +
-                wanted_node_scale * (1.0f - scale_ratio);
-            m_node->setScale(core::vector3df(scale, scale, scale));
+            if (m_type == ATTACH_PARACHUTE)
+            {
+                const float progress = 1.0f - scale_ratio;
+
+                const float x = 0.2f * atan(25.0f * progress - 5.0f) + 0.69f;
+                const float y = x;
+                const float z = 1.0f - pow(2.0f, -20.f * progress);
+
+                m_node->setScale(core::vector3df(x * wanted_node_scale,
+                                                 y * wanted_node_scale,
+                                                 z * wanted_node_scale));
+            }
+            else
+            {
+                if (is_shield)
+                {
+                    // Taken from https://easings.net/#easeInElastic
+                    const float c4 = (2.0f * PI) / 3.0f;
+                    const float x = scale_ratio;
+
+                    scale_ratio = x <= 0 ? 0 : x >= 1 ? 1
+                      : -pow(2, 10 * x - 10) * sin((x * 10 - 10.75) * c4);
+                }
+
+                float scale = 0.3f * scale_ratio +
+                    wanted_node_scale * (1.0f - scale_ratio);
+                m_node->setScale(core::vector3df(scale, scale, scale));
+            }
         }
         else
         {
diff --git a/src/items/item.cpp b/src/items/item.cpp
index 7514d5e79aa..79f1b6f2781 100644
--- a/src/items/item.cpp
+++ b/src/items/item.cpp
@@ -223,7 +223,8 @@ Item::Item(ItemType type, const Vec3& xyz, const Vec3& normal,
 {
     m_icon_node = NULL;
     m_was_available_previously = true;
-    m_animation_start_ticks = 0;
+    // Prevent appear animation at start
+    m_animation_start_ticks = -9999;
     m_distance_2        = 1.2f;
     initItem(type, xyz, normal);
     m_graphical_type    = getGrahpicalType();
@@ -251,6 +252,7 @@ Item::Item(ItemType type, const Vec3& xyz, const Vec3& normal,
         // when already quite far.
         lodnode->autoComputeLevel(24); // The distance grows with the square root of the scaling factor
         m_node = lodnode;
+        m_appear_anime_node = irr_driver->getSceneManager()->addEmptySceneNode(m_node);
     }
     setType(type);
     handleNewMesh(getGrahpicalType());
@@ -273,7 +275,7 @@ Item::Item(ItemType type, const Vec3& xyz, const Vec3& normal,
     {
         scene::ISceneNode* billboard =
             irr_driver->addBillboard(core::dimension2df(SPARK_SIZE, SPARK_SIZE),
-                                     "item_spark.png", m_node);
+                                     "item_spark.png", m_appear_anime_node);
 #ifdef DEBUG
         billboard->setName("spark");
 #endif
@@ -361,9 +363,11 @@ Item::~Item()
     if (m_node != NULL)
     {
         for (auto* node : m_spark_nodes)
-            m_node->removeChild(node);
+            m_appear_anime_node->removeChild(node);
         if (m_icon_node)
-            m_node->removeChild(m_icon_node);
+            m_appear_anime_node->removeChild(m_icon_node);
+        
+        m_node->removeChild(m_appear_anime_node);
 
         irr_driver->removeNode(m_node);
         m_node->drop();
@@ -380,7 +384,7 @@ Item::~Item()
 void Item::reset()
 {
     m_was_available_previously = true;
-    m_animation_start_ticks = 0;
+    m_animation_start_ticks = -9999;
     ItemState::reset();
 
     if (m_node != NULL)
@@ -410,14 +414,14 @@ void Item::handleNewMesh(ItemType type)
     m_node->setRotation(hpr.toIrrHPR());
 
     if (m_icon_node)
-        m_node->removeChild(m_icon_node);
+        m_appear_anime_node->removeChild(m_icon_node);
     m_icon_node = NULL;
     auto icon = ItemManager::getIcon(type);
 
     if (!icon.empty())
     {
         m_icon_node = irr_driver->addBillboard(core::dimension2df(1.0f, 1.0f),
-                                        icon, m_node);
+                                        icon, m_appear_anime_node);
 
         m_icon_node->setPosition(core::vector3df(0.0f, 0.5f, 0.0f));
         m_icon_node->setVisible(false);
@@ -503,60 +507,54 @@ void Item::updateGraphics(float dt)
         m_node->setRotation(hpr.toIrrHPR());
     } // if item is available
 
-    for (size_t i = 0; i < SPARK_AMOUNT; i++)
+    bool is_in_appear_anime = time_since_return < 1.0f
+                             || (!isAvailable() && time_till_return < 1.0f);
+    m_appear_anime_node->setVisible(is_in_appear_anime);
+
+    if (is_in_appear_anime)
     {
-        if (time_since_return >= 1.0f)
+        for (size_t i = 0; i < SPARK_AMOUNT; i++)
         {
-            m_spark_nodes[i]->setVisible(false);
-            continue;
-        }
+            float t = time_since_return + 0.5f;
+            float t2 = time_since_return + 1.0f;
 
-        float t = time_since_return + 0.5f;
-        float t2 = time_since_return + 1.0f;
+            float node_angle = !rotating() ? 0.0f :
+                    fmodf((float)World::getWorld()->getTicksSinceStart() / 40.0f,
+                    M_PI * 2);
 
-        float node_angle = !rotating() ? 0.0f :
-                fmodf((float)World::getWorld()->getTicksSinceStart() / 40.0f,
-                M_PI * 2);
+            float x = sin(float(i) / float(SPARK_AMOUNT) * 2.0f * M_PI - node_angle)
+                        * t * SPARK_SPEED_H;
+            float y = 2.0f * t2 - t2 * t2 - 0.5f;
+            float z = cos(float(i) / float(SPARK_AMOUNT) * 2.0f * M_PI - node_angle)
+                        * t * SPARK_SPEED_H;
 
-        float x = sin(float(i) / float(SPARK_AMOUNT) * 2.0f * M_PI - node_angle)
-                    * t * SPARK_SPEED_H;
-        float y = 2.0f * t2 - t2 * t2 - 0.5f;
-        float z = cos(float(i) / float(SPARK_AMOUNT) * 2.0f * M_PI - node_angle)
-                    * t * SPARK_SPEED_H;
+            m_spark_nodes[i]->setPosition(core::vector3df(x, y, z));
 
-        m_spark_nodes[i]->setPosition(core::vector3df(x, y, z));
+            float factor = std::max(0.0f, 1.0f - t / 2.0f);
 
-        float factor = std::max(0.0f, 1.0f - t / 2.0f);
-
-        if (factor < 0.001f)
-        {
-            m_spark_nodes[i]->setVisible(false);
-        }
-        else
-        {
             m_spark_nodes[i]->setVisible(true);
 
             ((scene::IBillboardSceneNode*)m_spark_nodes[i])
                     ->setSize(core::dimension2df(factor * SPARK_SIZE,
-                                                 factor * SPARK_SIZE));
+                                                factor * SPARK_SIZE));
         }
-    }
 
-    if (m_icon_node)
-    {
-        if (!isAvailable() && time_till_return <= 1.0f)
-        {
-            m_icon_node->setVisible(true);
-            float size = 1.0f / (pow(6.0f, -time_till_return - 0.2f) *
-                        (-time_till_return - 0.2f)) + 7.0f;
-
-            ((scene::IBillboardSceneNode*)m_icon_node)
-                    ->setSize(core::dimension2df(size * ICON_SIZE,
-                                                 size * ICON_SIZE));
-        }
-        else
+        if (m_icon_node)
         {
-            m_icon_node->setVisible(false);
+            if (!isAvailable())
+            {
+                m_icon_node->setVisible(true);
+                float size = 1.0f / (pow(6.0f, -time_till_return - 0.2f) *
+                            (-time_till_return - 0.2f)) + 7.0f;
+
+                ((scene::IBillboardSceneNode*)m_icon_node)
+                        ->setSize(core::dimension2df(size * ICON_SIZE,
+                                                    size * ICON_SIZE));
+            }
+            else
+            {
+                m_icon_node->setVisible(false);
+            }
         }
     }
 
diff --git a/src/items/item.hpp b/src/items/item.hpp
index 4f218513b7b..6e319cf4fd4 100644
--- a/src/items/item.hpp
+++ b/src/items/item.hpp
@@ -330,6 +330,9 @@ class Item : public ItemState, public NoCopy
     /** Graphical type of the mesh. */
     ItemType m_graphical_type;
 
+    /** The parent of m_spark_nodes and m_icon_node */
+    scene::ISceneNode* m_appear_anime_node;
+
     /** Vector containing the sparks */
     std::vector<scene::ISceneNode*> m_spark_nodes;
 
diff --git a/src/karts/controller/local_player_controller.cpp b/src/karts/controller/local_player_controller.cpp
index 87cacd5e050..f1498910a77 100644
--- a/src/karts/controller/local_player_controller.cpp
+++ b/src/karts/controller/local_player_controller.cpp
@@ -24,6 +24,7 @@
 #include "config/stk_config.hpp"
 #include "config/user_config.hpp"
 #include "graphics/camera/camera.hpp"
+#include "graphics/camera/camera_normal.hpp"
 #include "graphics/irr_driver.hpp"
 #include "graphics/particle_emitter.hpp"
 #include "graphics/particle_kind.hpp"
@@ -56,7 +57,7 @@
 
 #include "LinearMath/btTransform.h"
 
-/** The constructor for a loca player kart, i.e. a player that is playing
+/** The constructor for a local player kart, i.e. a player that is playing
  *  on this machine (non-local player would be network clients).
  *  \param kart_name Name of the kart.
  *  \param position The starting position (1 to n).
@@ -269,7 +270,10 @@ void LocalPlayerController::update(int ticks)
         else
         {
             if (camera->getMode() == Camera::CM_REVERSE)
+            {
                 camera->setMode(Camera::CM_NORMAL);
+                dynamic_cast<CameraNormal*>(camera)->snapToPosition();
+            }
         }
         if (m_sky_particles_emitter)
         {
diff --git a/src/karts/controller/spare_tire_ai.cpp b/src/karts/controller/spare_tire_ai.cpp
index 4d51d89ec03..09210fabc24 100644
--- a/src/karts/controller/spare_tire_ai.cpp
+++ b/src/karts/controller/spare_tire_ai.cpp
@@ -142,11 +142,20 @@ void SpareTireAI::crashed(const AbstractKart *k)
     // Nothing happen when two spare tire karts crash each other
     if (dynamic_cast<const SpareTireAI*>(k->getController()) != NULL) return;
 
-    // Add a life
+    // Tell players that they can have at most 3 lives
     RaceGUIBase* r = World::getWorld()->getRaceGUI();
-    m_tsb_world->addKartLife(k->getWorldKartId());
-    if (r)
-        r->addMessage(_("+1 life."), k, 2.0f);
+    if (m_tsb_world->getKartLife(k->getWorldKartId()) == 3)
+    {
+        if (r)
+            r->addMessage(_("You can have at most 3 lives!"), k, 2.0f);
+    }
+    // Otherwise add one life for that kart 
+    else
+    {
+        m_tsb_world->addKartLife(k->getWorldKartId());
+        if (r)
+            r->addMessage(_("+1 life."), k, 2.0f);
+    }
     unspawn();
 
 }   // crashed
diff --git a/src/karts/kart_model.cpp b/src/karts/kart_model.cpp
index 933cd13a1c4..ccc4632ad1f 100644
--- a/src/karts/kart_model.cpp
+++ b/src/karts/kart_model.cpp
@@ -267,7 +267,8 @@ KartModel::~KartModel()
         if(m_is_master && m_wheel_model[i])
         {
             irr_driver->dropAllTextures(m_wheel_model[i]);
-            irr_driver->removeMeshFromCache(m_wheel_model[i]);
+            if (m_wheel_model[i]->getReferenceCount() == 1)
+                irr_driver->removeMeshFromCache(m_wheel_model[i]);
         }
     }
 
diff --git a/src/karts/kart_properties_manager.cpp b/src/karts/kart_properties_manager.cpp
index ef816b48bbd..833542f8e02 100644
--- a/src/karts/kart_properties_manager.cpp
+++ b/src/karts/kart_properties_manager.cpp
@@ -131,8 +131,8 @@ void KartPropertiesManager::removeKart(const std::string &ident)
         // Handle no custom group first
         if(it!=m_groups_2_indices_no_custom[groups[i]].end())
         {
-            m_groups_2_indices_no_custom.erase(groups[i]);
             m_groups_2_indices_no_custom[groups[i]].erase(it);
+
             if(m_groups_2_indices_no_custom[groups[i]].size()==0)
             {
                 m_groups_2_indices_no_custom.erase(groups[i]);
diff --git a/src/main.cpp b/src/main.cpp
index 9d143f78884..c52e014cfc7 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -514,12 +514,36 @@ void setupRaceStart()
     // a current player
     PlayerManager::get()->enforceCurrentPlayer();
 
-    InputDevice *device;
+    InputDevice *device = NULL;
 
-    // Use keyboard 0 by default in --no-start-screen
-    device = input_manager->getDeviceManager()->getKeyboard(0);
+    // Assign the player a device; check the command line params for preferences; by default use keyboard 0
 
-    // Create player and associate player with keyboard
+    if(UserConfigParams::m_default_keyboard > -1)
+    {
+        device = input_manager->getDeviceManager()->getKeyboard(UserConfigParams::m_default_keyboard);
+    }
+    else if(UserConfigParams::m_default_gamepad > -1)
+    {
+        // getGamePad(int) returns a GamePadDevice which is a subclass of InputDevice
+        // However, the compiler doesn't like it so it has to be manually casted in
+        device = (InputDevice *) input_manager->getDeviceManager()->getGamePad(UserConfigParams::m_default_gamepad);
+    }
+    // If no config requested or if the requested config doesn't exist
+    if (device == NULL)
+    {
+        if (UserConfigParams::m_default_keyboard > -1 ||
+            UserConfigParams::m_default_gamepad > -1)
+        {
+            Log::error("main", "Requested input device unavailable, fallback to the default keyboard");
+        }
+        device = input_manager->getDeviceManager()->getKeyboard(0);
+    }
+
+    // In case the requested config was disabled, enable it.
+    if (!device->getConfiguration()->isEnabled())
+        device->getConfiguration()->setEnabled(true);
+
+    // Create player and associate player with device
     StateManager::get()->createActivePlayer(
         PlayerManager::get()->getPlayer(0), device);
 
@@ -557,10 +581,14 @@ void cmdLineHelp()
                               "menu.\n"
     "  -R,  --race-now         Same as -N but also skip the ready-set-go phase"
                               " and the music.\n"
+    "       --use-keyboard=N   Used in conjunction with the -N or -R option, will assign the player to the specified"
+                              " keyboard. Is zero indexed.\n"
+    "       --use-gamepad=N    Used in conjunction with the -N or -R option, will assign the player to the specified"
+                              " gamepad. Is zero indexed.\n"
     "  -t,  --track=NAME       Start track NAME.\n"
     "       --gp=NAME          Start the specified Grand Prix.\n"
-    "       --add-gp-dir=DIR   Load Grand Prix files in DIR. Setting will be saved\n"
-                              "in config.xml under additional_gp_directory. Use\n"
+    "       --add-gp-dir=DIR   Load Grand Prix files in DIR. Setting will be saved"
+                              "in config.xml under additional_gp_directory. Use"
                               "--add-gp-dir=\"\" to unset.\n"
     "       --stk-config=FILE  use ./data/FILE instead of "
                               "./data/stk_config.xml\n"
@@ -1675,6 +1703,14 @@ int handleCmdLine(bool has_server_config, bool has_parent_process)
         UserConfigParams::m_race_now = true;
     }   // --race-now
 
+    if(CommandLine::has( "--use-keyboard",&n)) {
+        UserConfigParams::m_default_keyboard = n;
+    } //--use-keyboard
+
+    if(CommandLine::has( "--use-gamepad",&n)) {
+        UserConfigParams::m_default_gamepad = n;
+    } //--use-gamepad
+
     if(CommandLine::has("--laps", &s))
     {
         int laps = atoi(s.c_str());
diff --git a/src/modes/linear_world.cpp b/src/modes/linear_world.cpp
index 148a8f97932..ad770659630 100644
--- a/src/modes/linear_world.cpp
+++ b/src/modes/linear_world.cpp
@@ -443,6 +443,14 @@ void LinearWorld::newLap(unsigned int kart_index)
                 m_last_lap_sfx_playing = false;
             }
         }
+        // Switch on faster music if not already done so, if the
+        // first kart is doing its last lap.
+        if(!m_faster_music_active &&
+            useFastMusicNearEnd())
+        {
+            music_manager->switchToFastMusic();
+            m_faster_music_active=true;
+        }
     }
     else if (raceHasLaps() && kart_info.m_finished_laps > 0 &&
              kart_info.m_finished_laps+1 < lap_count && !isLiveJoinWorld() && m_race_gui)
@@ -955,17 +963,6 @@ void LinearWorld::updateRacePosition()
             assert(false);
         }
 #endif
-
-        // Switch on faster music if not already done so, if the
-        // first kart is doing its last lap.
-        if(!m_faster_music_active                                  &&
-            p == 1                                                 &&
-            kart_info.m_finished_laps == RaceManager::get()->getNumLaps() - 1 &&
-            useFastMusicNearEnd()                                       )
-        {
-            music_manager->switchToFastMusic();
-            m_faster_music_active=true;
-        }
     }   // for i<kart_amount
 
     // Define this to get a detailled analyses each time a race position
diff --git a/src/modes/overworld.cpp b/src/modes/overworld.cpp
index 1f060ecbf69..0fed626666e 100644
--- a/src/modes/overworld.cpp
+++ b/src/modes/overworld.cpp
@@ -38,6 +38,10 @@
 #include "tracks/track.hpp"
 #include "tracks/track_object_manager.hpp"
 
+#ifdef ANDROID
+#include <SDL_system.h>
+#endif
+
 //-----------------------------------------------------------------------------
 OverWorld::OverWorld() : World()
 {
@@ -242,6 +246,11 @@ void OverWorld::onFirePressed(Controller* who)
         {
             if (challenges[n].m_challenge_id == "tutorial")
             {
+#ifdef ANDROID
+                if (SDL_IsAndroidTV())
+                    return;
+#endif
+
                 scheduleTutorial();
                 return;
             }
diff --git a/src/modes/world.cpp b/src/modes/world.cpp
index d84f68796ba..82cdc3829ae 100644
--- a/src/modes/world.cpp
+++ b/src/modes/world.cpp
@@ -25,6 +25,7 @@
 #include "challenges/unlock_manager.hpp"
 #include "config/user_config.hpp"
 #include "graphics/camera/camera.hpp"
+#include "graphics/camera/camera_normal.hpp"
 #include "graphics/central_settings.hpp"
 #include "graphics/irr_driver.hpp"
 #include "graphics/material.hpp"
@@ -137,6 +138,7 @@ World::World() : WorldStatus()
     m_schedule_exit_race = false;
     m_schedule_tutorial  = false;
     m_is_network_world   = false;
+    m_snap_camera        = false;
 
     m_stop_music_when_dialog_open = true;
 
@@ -891,7 +893,11 @@ void World::resetAllKarts()
     {
         for(unsigned int i=0; i<Camera::getNumCameras(); i++)
         {
-            Camera::getCamera(i)->setInitialTransform();
+            Camera* cam = Camera::getCamera(i);
+            cam->setInitialTransform();
+            // Ensure that smoothed cameras start from a correct position
+            if (cam->isNormal())
+                dynamic_cast<CameraNormal*>(cam)->snapToPosition();
         }
     }
 }   // resetAllKarts
@@ -939,6 +945,7 @@ void World::moveKartTo(AbstractKart* kart, const btTransform &transform)
     Track::getCurrentTrack()->findGround(kart);
     Track::getCurrentTrack()->getCheckManager()->resetAfterKartMove(kart);
 
+    m_snap_camera = true;
 }   // moveKartTo
 
 // ----------------------------------------------------------------------------
@@ -1022,6 +1029,18 @@ void World::updateWorld(int ticks)
         m_schedule_unpause = false;
     }
 
+    if (m_snap_camera)
+    {
+        m_snap_camera = false;
+        for(unsigned int i=0; i<Camera::getNumCameras(); i++)
+        {
+            Camera* cam = Camera::getCamera(i);
+            // Ensure that smoothed cameras start from a correct position
+            if (cam->isNormal())
+                dynamic_cast<CameraNormal*>(cam)->snapToPosition();
+        }
+    }
+
     // Don't update world if a menu is shown or the race is over.
     // Exceptions : - Networking (local pause doesn't affect the server or other players)
     //              - Benchmarking (a pause would mess up measurements)
@@ -1256,14 +1275,13 @@ Highscores* World::getGPHighscores() const
 }
 
 // ----------------------------------------------------------------------------
-/** Called at the end of a race. Checks if the current times are worth a new
- *  score, if so it notifies the HighscoreManager so the new score is added
- *  and saved.
+/** Called at the end of a race.
+ * Submits the valid new times through the addHighscore functions, which then handles
+ * checking if the new times are worth of a highscore and saving them.
+ * The best highscore rank is transmitted to highlight the best new highscore in the GUI.
  */
 void World::updateHighscores(int* best_highscore_rank)
 {
-    *best_highscore_rank = -1;
-
     if(!m_use_highscores) return;
 
     // Add times to highscore list. First compute the order of karts,
@@ -1291,7 +1309,6 @@ void World::updateHighscores(int* best_highscore_rank)
         {
             // no kart claimed to be in this position, most likely means
             // the kart location data is wrong
-
 #ifdef DEBUG
             Log::error("[World]", "Incorrect kart positions:");
             for (unsigned int i=0; i<m_karts.size(); i++ )
@@ -1314,39 +1331,49 @@ void World::updateHighscores(int* best_highscore_rank)
         Kart *k = (Kart*)m_karts[index[pos]].get();
 
         Highscores* highscores = getHighscores();
-
-        int highscore_rank = 0;
+        float highscore_value = RaceManager::get()->isLapTrialMode() ? static_cast<float>(getFinishedLapsOfKart(index[pos]))
+                                                                     : k->getFinishTime();
         // The player is a local player, so there is a name:
-        if (RaceManager::get()->isLapTrialMode())
-        {
-            highscore_rank = highscores->addData(k->getIdent(),
-                                                 k->getController()->getName(),
-                                                 static_cast<float>(getFinishedLapsOfKart(index[pos])));
-        }
-        else
+        int highscore_rank = highscores->addData(k->getIdent(), k->getController()->getName(), highscore_value);
+
+        if (highscore_rank > 0 && (*best_highscore_rank == -1 ||
+                                    highscore_rank < *best_highscore_rank))
         {
-            highscore_rank = highscores->addData(k->getIdent(),
-                                                 k->getController()->getName(),
-                                                 k->getFinishTime()    );
+            *best_highscore_rank = highscore_rank;
         }
-        
+    } // next position
+
+    // Handle GP highscores
+    if (RaceManager::get()->getMajorMode() == RaceManager::MAJOR_MODE_GRAND_PRIX &&
+        RaceManager::get()->getNumOfTracks() == RaceManager::get()->getTrackNumber() + 1 &&
+        !RaceManager::get()->getGrandPrix().isRandomGP() &&
+        RaceManager::get()->getSkippedTracksInGP() == 0)
+    {
+        std::string gp_name = RaceManager::get()->getGrandPrix().getId();
 
-        if (highscore_rank > 0)
+        for (unsigned int kart_id = 0; kart_id < RaceManager::get()->getNumberOfKarts(); kart_id++)
         {
-            if (*best_highscore_rank == -1 ||
-                highscore_rank < *best_highscore_rank)
-            {
-                *best_highscore_rank = highscore_rank;
-            }
+            // Only record times for local player karts and only if
+            // they finished the race
+            if (!m_karts[kart_id]->getController()->isLocalPlayerController() ||
+                !m_karts[kart_id]->hasFinishedRace() ||
+                m_karts[kart_id]->isEliminated())
+                continue;
 
-            Highscores::setSortOrder(Highscores::SO_DEFAULT);
-            highscore_manager->sortHighscores(false);
+            // The original lap trial GP code was a mess. I'm not fixing it...
+            if (RaceManager::get()->isLapTrialMode())
+                continue;
 
-            highscore_manager->saveHighscores();
-        }
-    } // next position
-    delete []index;
+            Kart *k = (Kart*)m_karts[kart_id].get();
+            float full_time = RaceManager::get()->getOverallTime(kart_id);
+
+            Highscores* highscores = World::getWorld()->getGPHighscores();
+            // The player is a local player, so there is a name:
+            highscores->addGPData(k->getIdent(), k->getController()->getName(), gp_name, full_time);
+        } // for kart_id
+    } // Handle GP highscores
 
+    delete []index;
 }   // updateHighscores
 
 //-----------------------------------------------------------------------------
diff --git a/src/modes/world.hpp b/src/modes/world.hpp
index 4351810bd6e..d259e535096 100644
--- a/src/modes/world.hpp
+++ b/src/modes/world.hpp
@@ -174,6 +174,8 @@ class World : public WorldStatus
 
     Phase m_scheduled_pause_phase;
 
+    bool m_snap_camera;
+
     /** Set when the world needs to be deleted but you can't do it immediately
      * because you are e.g. within World::update()
      */
diff --git a/src/network/protocols/ranking.cpp b/src/network/protocols/ranking.cpp
new file mode 100644
index 00000000000..1662faa6bcb
--- /dev/null
+++ b/src/network/protocols/ranking.cpp
@@ -0,0 +1,488 @@
+//
+//  SuperTuxKart - a fun racing game with go-kart
+//  Copyright (C) 2024 SuperTuxKart-Team
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 3
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#include "network/protocols/ranking.hpp"
+#include "io/xml_node.hpp"
+#include "utils/log.hpp"
+#include "utils/time.hpp"
+#include <bitset>
+#include <cmath>
+#include <vector>
+
+namespace
+{
+    /* Ranking related variables */
+    // If updating the base points, update the base points distribution in DB
+    const double BASE_RANKING_POINTS    = 4000.0; // Given to a new player on 1st connection to a ranked server
+    const double BASE_RATING_DEVIATION  = 1000.0; // Given to a new player on 1st connection to a ranked server
+    const double MIN_RATING_DEVIATION   = 100.0; // A server cron job makes RD go up if a player is inactive
+    const double BASE_RD_PER_DISCONNECT = 15.0;
+    const double VAR_RD_PER_DISCONNECT  = 3.0;
+    const double MAX_SCALING_TIME       = 360.0;
+    const double BASE_POINTS_PER_SECOND = 0.25;
+    const double HANDICAP_OFFSET        = 2000.0;
+}
+
+
+//-----------------------------------------------------------------------------
+RankingEntry::RankingEntry(uint32_t online_id): online_id(online_id)
+{
+    raw_score = BASE_RANKING_POINTS;
+    score     = BASE_RANKING_POINTS - 3*BASE_RATING_DEVIATION + 3*MIN_RATING_DEVIATION;
+    max_score = BASE_RANKING_POINTS - 3*BASE_RATING_DEVIATION + 3*MIN_RATING_DEVIATION;
+    deviation = BASE_RATING_DEVIATION;
+    disconnects = 0;
+    races = 0;
+}
+
+//-----------------------------------------------------------------------------
+/** Compute the new player's rankings used in ranked servers
+ */
+void Ranking::computeNewRankings(std::vector<RaceResultData>& data, bool time_trial)
+{
+    // TODO : go over the variables and look
+    //        for things that can be simplified away.
+    //        e.g. can new/prev be simplified ?
+
+    std::vector<RankingEntry*> ranking_data;
+    for (const auto& result: data)
+    {
+        auto it = m_entries.find(result.online_id);
+        if (it == m_entries.end())
+        {
+            Log::fatal("Ranking", "Failed to obtain the saved ranking for online id %u", result.online_id);
+            return;
+        }
+        auto it2 = m_old_entries.find(result.online_id);
+        if (it2 == m_old_entries.end())
+            m_old_entries[result.online_id] = it->second.entry;
+        ranking_data.push_back(&(it->second.entry));
+    }
+
+    std::vector<double> raw_scores_change;
+    std::vector<double> new_raw_scores;
+    std::vector<double> prev_raw_scores;
+    std::vector<double> prev_scores;
+    std::vector<double> new_rating_deviations;
+    std::vector<double> prev_rating_deviations;
+    std::vector<uint64_t> prev_disconnects; //bitflag
+    std::vector<int>    disconnects;
+
+    unsigned player_count = data.size();
+
+    // Initialize data vectors
+    for (unsigned i = 0; i < player_count; i++)
+    {
+        double prev_raw_score = ranking_data[i]->raw_score;
+        new_raw_scores.push_back(prev_raw_score);
+        prev_raw_scores.push_back(prev_raw_score);
+
+        prev_scores.push_back(ranking_data[i]->score);
+
+        double prev_deviation = ranking_data[i]->deviation;
+        new_rating_deviations.push_back(prev_deviation);
+        prev_rating_deviations.push_back(prev_deviation);
+
+        prev_disconnects.push_back(ranking_data[i]->disconnects);
+    }
+ 
+    // Update some variables
+    for (unsigned i = 0; i < player_count; i++)
+    {
+        //First, update the number of ranked races
+        ranking_data[i]->races++;
+
+        // Update the number of disconnects
+        // We store the last 64 results as bit flags in a 64-bit int.
+        // This way, shifting flushes the oldest result.
+        ranking_data[i]->disconnects <<= 1;
+
+        if (data[i].is_eliminated)
+            ranking_data[i]->disconnects++;
+
+        // std::popcount is C++20 only
+        std::bitset<64> b(ranking_data[i]->disconnects);
+        disconnects.push_back(b.count());
+    }
+
+    // In this loop, considering the race as a set
+    // of head to head minimatches, we compute :
+    // I - Point changes for each ordered player pair.
+    //     In a (p1, p2) pair, only p1's rating is changed.
+    //     However, the loop will also go over (p2, p1).
+    //     Point changes can be assymetric.
+    // II - Rating deviation changes
+    for (unsigned i = 0; i < player_count; i++)
+    {
+        raw_scores_change.push_back(0.0);
+
+        double player1_raw_scores = new_raw_scores[i];
+        if (data[i].handicap)
+            player1_raw_scores -= HANDICAP_OFFSET;
+
+        // If the player has quitted before the race end,
+        // the time value will be incorrect, but it will not be used
+        double player1_time  = data[i].time;
+        double player1_rd = prev_rating_deviations[i];
+
+        // On a disconnect, increase RD once,
+        // no matter how many opponents
+        if (data[i].is_eliminated && disconnects[i] >= 3)
+            new_rating_deviations[i] =  prev_rating_deviations[i]
+                                      + BASE_RD_PER_DISCONNECT
+                                      + VAR_RD_PER_DISCONNECT * (disconnects[i] - 3);
+
+        // Loop over all opponents
+        for (unsigned j = 0; j < player_count; j++)
+        {
+            // Don't compare a player with himself
+            if (i == j)
+                continue;
+
+            // No change between two quitting players
+            if (data[i].is_eliminated && data[j].is_eliminated)
+                continue;
+
+            double diff, result, expected_result, ranking_importance, max_time;
+            diff = result = expected_result = ranking_importance = max_time = 0.0;
+
+            double player2_raw_scores = new_raw_scores[j];
+            if (data[j].handicap)
+                player2_raw_scores -= HANDICAP_OFFSET;
+
+            double player2_time = data[j].time;
+            double player2_rd = prev_rating_deviations[j];
+
+            // Each result can be viewed as new data helping to refine our previous
+            // estimates. But first, we need to assess how reliable this new data is
+            // compared to existing estimates.
+
+            bool handicap_used = (data[i].handicap || data[j].handicap);
+            double accuracy = computeDataAccuracy(player1_rd, player2_rd, player1_raw_scores, player2_raw_scores, player_count, handicap_used);
+
+            // Now that we've computed the reliability value,
+            // we can proceed with computing the points gained or lost
+
+            // Compute the result and race ranking importance
+
+            double mode_factor = getModeFactor(time_trial);
+
+            if (data[i].is_eliminated)
+            {
+                // Recurring disconnects are punished through
+                // increased RD and higher RD floor,
+                // not through higher raw score loss
+                result = 0.0;
+                player1_time = player2_time * 1.2; // for getTimeSpread
+            }
+            else if (data[j].is_eliminated)
+            {
+                result = 1.0;
+                player2_time = player1_time * 1.2;
+            }
+            else
+            {
+                result = computeH2HResult(player1_time, player2_time);
+            }
+
+            max_time = std::min(MAX_SCALING_TIME, std::max(player1_time, player2_time));
+
+            ranking_importance = accuracy * mode_factor * scalingValueForTime(max_time);
+
+            // Compute the expected result using an ELO-like function
+            diff = player2_raw_scores - player1_raw_scores;
+
+            expected_result = 1.0/ (1.0 + std::pow(10.0,
+                diff / (  BASE_RANKING_POINTS / 2.0
+                        * getModeSpread(time_trial)
+                        * getTimeSpread(std::min(player1_time, player2_time)))));
+
+            // Compute the ranking change
+            raw_scores_change[i] += ranking_importance * (result - expected_result);
+
+            // We now update the rating deviation. The change
+            // depends on the current RD, on the result's accuracy,
+            // on how expected the result was (upsets can increase RD)
+
+            // If there was a disconnect in this race, RD was handled once already
+            if (!data[i].is_eliminated) {
+                // First the RD reduction based on accuracy and current RD
+                double rd_change_factor = accuracy * 0.0016;
+                double rd_change = (-1) * prev_rating_deviations[i] * rd_change_factor;
+
+                // If the unexpected result happened, we add a RD increase
+                // TODO : more reliable would be accumulating an expected_result/result
+                // differential over time, weighted through relative RDs.
+                // If that differential goes high, then increase RD while decaying
+                // the differential. Some work needed to ensure sensible maths.
+                double upset = std::abs(result - expected_result);
+                if (upset > 0.5)
+                {
+                    // Renormalize so expected result 50% is 1.0 and expected result 100% is 0.0
+                    upset = 2.0 - 2 * upset;
+                    upset = std::max(0.02, upset);
+
+                    // If upsets happen at the rate predicted by expected score,
+                    // this won't prevent the rating deviation from going down.
+                    // However, if upsets are at least twice more frequent than expected, RD will go up.
+                    rd_change += MIN_RATING_DEVIATION * rd_change_factor / upset;
+                }
+
+                // Minimum RD will be handled after all iterative RD change have been done,
+                // so as to avoid the order in which player pairs are computed changing results.
+                new_rating_deviations[i] += rd_change;
+            }
+        }
+    }
+
+    // Don't merge it in the main loop as new_scores value are used there
+    for (unsigned i = 0; i < player_count; i++)
+    {
+        new_raw_scores[i] += raw_scores_change[i];
+        ranking_data[i]->raw_score = new_raw_scores[i];
+
+        // Ensure RD doesn't go below the RD floor.
+        // The minimum RD is increased in case of repeated disconnects
+        double disconnects_floor = 0;
+        if (disconnects[i] >= 3)
+        {
+            int n = disconnects[i] - 3;
+            disconnects_floor =   (disconnects[i] - 2) * BASE_RD_PER_DISCONNECT
+                                + VAR_RD_PER_DISCONNECT * (n * (n + 1)) / 2;
+        }
+        new_rating_deviations[i] = std::max(new_rating_deviations[i], MIN_RATING_DEVIATION + disconnects_floor);
+        ranking_data[i]->deviation = new_rating_deviations[i];
+
+        // Update the main public rating. At min RD, it is equal to the raw score.
+        ranking_data[i]->score = ranking_data[i]->raw_score - 3 * new_rating_deviations[i] + 3 * MIN_RATING_DEVIATION;
+        if (ranking_data[i]->score > ranking_data[i]->max_score)
+            ranking_data[i]->max_score = ranking_data[i]->score;
+    }
+}   // computeNewRankings
+
+
+//-----------------------------------------------------------------------------
+/** Returns the mode race importance factor,
+ *  used to make ranking move slower in more random modes.
+ */
+double Ranking::getModeFactor(bool time_trial)
+{
+    if (time_trial)
+        return 1.0;
+    return 0.75;
+}   // getModeFactor
+
+//-----------------------------------------------------------------------------
+/** Returns the mode spread factor, used so that a similar difference in
+ *  skill will result in a similar ranking difference in more random modes.
+ */
+double Ranking::getModeSpread(bool time_trial)
+{
+    if (time_trial)
+        return 1.0;
+
+    //TODO: For 2.0, it would be more sensible to simply use
+    // a different ranking for time-trial and normal races, as
+    // some players perform better in one mode than in the other,
+    // so an unified list is always going to be flawed. Trying to
+    // patch these flaws is never going to work well.
+    return 1.25;
+}   // getModeSpread
+
+//-----------------------------------------------------------------------------
+/** Returns the time spread factor.
+ *  Short races are more random, so the expected result changes depending
+ *  on race duration.
+ * TODO: collect real-world data on the relationship between race duration and
+ * the likelihood of winning of players, and fit the formula based on it.
+ */
+double Ranking::getTimeSpread(double time)
+{
+    return sqrt(120.0 / time);
+}   // getTimeSpread
+
+//-----------------------------------------------------------------------------
+/** Compute the scaling value of a given time
+ *  This is linear to race duration, getTimeSpread takes care
+ *  of expecting a more random result in shorter races.
+ */
+double Ranking::scalingValueForTime(double time)
+{
+    return time * BASE_POINTS_PER_SECOND;
+}   // scalingValueForTime
+
+//-----------------------------------------------------------------------------
+/** Computes the score of a head-to-head minimatch.
+ *  If time difference > 2,5% ; the result is 1 (complete win of player 1)
+ *  or 0 (complete loss of player 1)
+ *  Otherwise, it is averaged between 0 and 1.
+ */
+double Ranking::computeH2HResult(double player1_time, double player2_time)
+{
+    double max_time = std::max(player1_time, player2_time);
+    double min_time = std::min(player1_time, player2_time);
+
+    double result = (max_time - min_time) / (min_time / 20.0);
+    result = std::min(1.0, 0.5 + result);
+
+    if (player2_time <= player1_time)
+        result = 1.0 - result;
+
+    return result;
+}   // computeH2HResult
+
+//-----------------------------------------------------------------------------
+/** Computes a relative factor indicating how much informative value
+ *  the new race result gives us.
+ *
+ *  For a player with a high own rating deviation, the current rating is unreliable
+ *  so any new data holds more importance. This is crucial to allow reasonably
+ *  fast rating convergence of new players, provided they play accurately rated opponents.
+ *
+ *  When the opponent has a high rating deviation, the expected scores are likely off.
+ *  Therefore, the information from such a result is much less valuable.
+ *
+ *  We also reduce rating changes when the player ratings are very different, even
+ *  after considering the uncertainties from rating deviation.
+ *  This is multi-purpose :
+ *   - With a very high rating difference, random race events (very poor luck, disconnects)
+ *     are very likely to be the cause of any upset, so the rate of legitimate upsets is
+ *     unreliable. No rating method is safe.
+ *   - Attempting to "farm" much lower rated players against which a practical 100% winrate
+ *     may be reached (outside of random events) becomes very ineffective. Instead,
+ *     to gain rating points, the player has incentive to play well-rated opponents.
+ *   - The primary goal is to ensure that two players of equal rating would be about
+ *     evenly matched in head-to-head. If two strong players each beat a much weaker third
+ *     player, very little information is gained on how a direct head-to-head between the
+ *     strong players would go.
+ *  For the purposes of this rating computation, we assume that the informational value
+ *  of a race is roughly proportional to the likelihood of the weaker player winning.
+ * 
+ *  A downside of this method is that a legitimate loss to a much lower rated player won't
+ *  change the rating much, but these are rare enough that it's better to miss them than
+ *  to reward "farming" and to incorrectly reward wins due to external factors.
+ *
+ *  In a race with many players, a single event can have a significant impact on the
+ *  results of all the H2H. To avoid races with high players count having too strong
+ *  rating swings, we apply a modifier scaling down accuracy.
+ *
+ *  Finally, while handicap is allowed in ranked races and a rating offset is applied
+ *  to keep expected results realistic (without incentivizing playing handicap-only),
+ *  the results of such races are much less reliable.
+ */
+double Ranking::computeDataAccuracy(double player1_rd, double player2_rd, double player1_scores, double player2_scores, int player_count, bool handicap_used)
+{
+    double accuracy = player1_rd / (sqrt(player2_rd) * sqrt(MIN_RATING_DEVIATION));
+
+    double strong_lowerbound = (player1_scores > player2_scores) ? player1_scores - 350 - (player1_rd/2)
+                                                                 : player2_scores - 350 - (player2_rd/2);
+    double weak_upperbound   = (player1_scores > player2_scores) ? player2_scores + 350 + (player2_rd/2)
+                                                                 : player1_scores + 350 + (player1_rd/2);
+
+    if (weak_upperbound < strong_lowerbound)
+    {
+        double diff = strong_lowerbound - weak_upperbound;
+        diff = diff / (BASE_RANKING_POINTS / 2.0);
+
+        // The expected result is that of the weaker player and is between 0 and 0.5
+        double expected_result = 1.0/ (1.0 + std::pow(10.0, diff));
+        expected_result = std::max(0.05, 2*expected_result);
+
+        accuracy *= expected_result;
+    }
+
+    // Reduce the importance of single h2h in a race with many players.
+    // The overall impact of a race with more players is still always bigger.
+    double player_count_modifier = 2.0 / sqrt((double) player_count);
+    accuracy *= player_count_modifier;
+
+    // Races with handicap are unreliable for ranking
+    if (handicap_used)
+        accuracy *= 0.25;
+
+    return accuracy;
+}
+
+//-----------------------------------------------------------------------------
+void Ranking::cleanup()
+{
+    std::map<uint32_t, RankingEntryAndProfile> new_entries;
+    for (const auto& pair: m_entries)
+    {
+        auto profile = pair.second.profile;
+        if (!profile.expired())
+            new_entries.insert(pair);
+    }
+    std::swap(new_entries, m_entries);
+}
+
+//-----------------------------------------------------------------------------
+void Ranking::fill(uint32_t online_id, const XMLNode* result, std::shared_ptr<NetworkPlayerProfile> npp)
+{
+    RankingEntry entry(online_id);
+    result->get("scores", &entry.score);
+    result->get("max-scores", &entry.max_score);
+    result->get("num-races-done", &entry.races);
+    result->get("raw-scores", &entry.raw_score);
+    result->get("rating-deviation", &entry.deviation);
+    result->get("disconnects", &entry.disconnects);
+    m_entries[online_id] = {entry, npp};
+}
+
+//-----------------------------------------------------------------------------
+bool Ranking::has(uint32_t online_id)
+{
+    auto it = m_entries.find(online_id);
+    if (it == m_entries.end())
+        return false;
+    if (it->second.profile.expired())
+        return false;
+    return true;
+}
+
+//-----------------------------------------------------------------------------
+double Ranking::getDelta(uint32_t online_id)
+{
+    auto it = m_old_entries.find(online_id);
+    if (it == m_old_entries.end())
+        return 0.;
+    auto it2 = m_entries.find(online_id);
+    if (it2 == m_entries.end())
+        return 0.;
+    double result = it2->second.entry.score - it->second.score;
+    m_old_entries.erase(it);
+    return result;
+}
+
+//-----------------------------------------------------------------------------
+const RankingEntry Ranking::getScores(uint32_t online_id) const
+{
+    return m_entries.at(online_id).entry;
+}
+
+//-----------------------------------------------------------------------------
+const RankingEntry Ranking::getTemporaryPenalizedScores(uint32_t online_id) const
+{
+    RankingEntry entry = m_entries.at(online_id).entry;
+    entry.score -= 200.0;
+    entry.raw_score -= 200.0;
+    entry.races += 1;
+    entry.disconnects <<= 1;
+    entry.disconnects += 1;
+    return entry;
+}
\ No newline at end of file
diff --git a/src/network/protocols/ranking.hpp b/src/network/protocols/ranking.hpp
new file mode 100644
index 00000000000..0812045823e
--- /dev/null
+++ b/src/network/protocols/ranking.hpp
@@ -0,0 +1,82 @@
+//
+//  SuperTuxKart - a fun racing game with go-kart
+//  Copyright (C) 2024 SuperTuxKart-Team
+//
+//  This program is free software; you can redistribute it and/or
+//  modify it under the terms of the GNU General Public License
+//  as published by the Free Software Foundation; either version 3
+//  of the License, or (at your option) any later version.
+//
+//  This program is distributed in the hope that it will be useful,
+//  but WITHOUT ANY WARRANTY; without even the implied warranty of
+//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU General Public License for more details.
+//
+//  You should have received a copy of the GNU General Public License
+//  along with this program; if not, write to the Free Software
+//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+
+#ifndef RANKING_HPP
+#define RANKING_HPP
+
+#include <map>
+#include <memory>
+#include <vector>
+
+class XMLNode;
+class NetworkPlayerProfile;
+
+struct RankingEntry
+{
+    uint32_t online_id;
+    double raw_score;
+    double score;
+    double max_score;
+    double deviation;
+    uint64_t disconnects;
+    unsigned races;
+
+    RankingEntry(uint32_t online_id = -1);
+};
+
+struct RaceResultData {
+    uint32_t online_id;
+    bool is_eliminated;
+    double time;
+    bool handicap;
+};
+
+struct RankingEntryAndProfile
+{
+    RankingEntry entry;
+    std::weak_ptr<NetworkPlayerProfile> profile;
+};
+
+class Ranking
+{
+private:
+    // A map that stores the actual scores.
+    std::map<uint32_t, RankingEntryAndProfile> m_entries;
+
+    // A map that stores the score before the last series of computeNewRankings calls has started.
+    std::map<uint32_t, RankingEntry> m_old_entries;
+
+    static double getModeFactor(bool time_trial);
+    static double getModeSpread(bool time_trial);
+    static double getTimeSpread(double time);
+    static double scalingValueForTime(double time);
+    static double computeH2HResult(double player1_time, double player2_time);
+    static double computeDataAccuracy(double player1_rd, double player2_rd,
+                               double player1_scores, double player2_scores,
+                               int player_count, bool handicap_used);
+public:
+    void computeNewRankings(std::vector<RaceResultData>& data, bool time_trial);
+    void cleanup();
+    void fill(uint32_t online_id, const XMLNode* result, std::shared_ptr<NetworkPlayerProfile> npp);
+    bool has(uint32_t online_id);
+    double getDelta(uint32_t online_id);
+    const RankingEntry getScores(uint32_t online_id) const;
+    const RankingEntry getTemporaryPenalizedScores(uint32_t online_id) const;
+};
+
+#endif
\ No newline at end of file
diff --git a/src/network/protocols/server_lobby.cpp b/src/network/protocols/server_lobby.cpp
index 447eb4c9fd6..c305d708fb5 100644
--- a/src/network/protocols/server_lobby.cpp
+++ b/src/network/protocols/server_lobby.cpp
@@ -41,6 +41,7 @@
 #include "network/protocols/connect_to_peer.hpp"
 #include "network/protocols/game_protocol.hpp"
 #include "network/protocols/game_events_protocol.hpp"
+#include "network/protocols/ranking.hpp"
 #include "network/race_event_manager.hpp"
 #include "network/server_config.hpp"
 #include "network/socket_address.hpp"
@@ -70,20 +71,17 @@ int ServerLobby::m_fixed_laps = -1;
 class SubmitRankingRequest : public Online::XMLRequest
 {
 public:
-    SubmitRankingRequest(uint32_t online_id, double scores,
-                         double max_scores, unsigned num_races,
-                         double raw_scores, double rating_deviation,
-                         uint64_t disconnects,
+    SubmitRankingRequest(const RankingEntry& entry,
                          const std::string& country_code)
         : XMLRequest(Online::RequestManager::HTTP_MAX_PRIORITY)
     {
-        addParameter("id", online_id);
-        addParameter("scores", scores);
-        addParameter("max-scores", max_scores);
-        addParameter("num-races-done", num_races);
-        addParameter("raw-scores", raw_scores);
-        addParameter("rating-deviation", rating_deviation);
-        addParameter("disconnects", disconnects);
+        addParameter("id", entry.online_id);
+        addParameter("scores", entry.score);
+        addParameter("max-scores", entry.max_score);
+        addParameter("num-races-done", entry.races);
+        addParameter("raw-scores", entry.raw_score);
+        addParameter("rating-deviation", entry.deviation);
+        addParameter("disconnects", entry.disconnects);
         addParameter("country-code", country_code);
     }
     virtual void afterOperation()
@@ -178,6 +176,8 @@ ServerLobby::ServerLobby() : LobbyProtocol()
         Log::info("ServerLobby", "This server will submit ranking scores to "
             "the STK addons server. Don't bother hosting one without the "
             "corresponding permissions, as they would be rejected.");
+
+        m_ranking = std::make_shared<Ranking>();
     }
     m_result_ns = getNetworkString();
     m_result_ns->setSynchronous(true);
@@ -478,6 +478,23 @@ void ServerLobby::handleChat(Event* event)
     core::stringw message;
     event->data().decodeString16(&message, 360/*max_len*/);
 
+    // Check if the message starts with "(the name of main profile): " to prevent
+    // impersonation, see #5121.
+    std::string message_utf8 = StringUtils::wideToUtf8(message);
+    std::string prefix = StringUtils::wideToUtf8(
+        event->getPeer()->getPlayerProfiles()[0]->getName()) + ": ";
+    
+    if (!StringUtils::startsWith(message_utf8, prefix))
+    {
+        NetworkString* chat = getNetworkString();
+        chat->setSynchronous(true);
+        core::stringw warn = "Don't try to impersonate others!";
+        chat->addUInt8(LE_CHAT).encodeString16(warn);
+        event->getPeer()->sendPacket(chat, true/*reliable*/);
+        delete chat;
+        return;
+    }
+
     KartTeam target_team = KART_TEAM_NONE;
     if (event->data().size() > 0)
         target_team = (KartTeam)event->data().getUInt8();
@@ -782,7 +799,7 @@ void ServerLobby::asynchronousUpdate()
     updateServerOwner();
 
     if (ServerConfig::m_ranked && m_state.load() == WAITING_FOR_START_GAME)
-        clearDisconnectedRankedPlayer();
+        m_ranking->cleanup();
 
     if (allowJoinedPlayersWaiting() || (m_game_setup->isGrandPrix() &&
         m_state.load() == WAITING_FOR_START_GAME))
@@ -874,9 +891,14 @@ void ServerLobby::asynchronousUpdate()
     {
         if (ServerConfig::m_owner_less)
         {
+            // Ensure that a game can auto-start if the server meets the config's starting limit or if it's already full.
+            int starting_limit = std::min((int)ServerConfig::m_min_start_game_players, (int)ServerConfig::m_server_max_players);
+            if (ServerConfig::m_max_players_in_game > 0) // 0 here means it's not the limit
+                starting_limit = std::min(starting_limit, (int)ServerConfig::m_max_players_in_game);
+
             unsigned players = 0;
             STKHost::get()->updatePlayers(&players);
-            if (((int)players >= ServerConfig::m_min_start_game_players ||
+            if (((int)players >= starting_limit ||
                 m_game_setup->isGrandPrixStarted()) &&
                 m_timeout.load() == std::numeric_limits<int64_t>::max())
             {
@@ -884,7 +906,7 @@ void ServerLobby::asynchronousUpdate()
                     (int64_t)
                     (ServerConfig::m_start_game_counter * 1000.0f));
             }
-            else if ((int)players < ServerConfig::m_min_start_game_players &&
+            else if ((int)players < starting_limit &&
                 !m_game_setup->isGrandPrixStarted())
             {
                 resetPeersReady();
@@ -894,7 +916,7 @@ void ServerLobby::asynchronousUpdate()
             }
             if (m_timeout.load() < (int64_t)StkTime::getMonoTimeMs() ||
                 (checkPeersReady(true/*ignore_ai_peer*/) &&
-                (int)players >= ServerConfig::m_min_start_game_players))
+                (int)players >= starting_limit))
             {
                 resetPeersReady();
                 startSelection();
@@ -2341,28 +2363,14 @@ void ServerLobby::checkRaceFinished()
  */
 void ServerLobby::computeNewRankings()
 {
-    // TODO : go over the variables and look
-    //        for things that can be simplified away.
-    //        e.g. can new/prev be simplified ?
-
     // No ranking for battle mode
     if (!RaceManager::get()->modeHasLaps())
         return;
 
-    std::vector<double> raw_scores_change;
-    std::vector<double> new_raw_scores;
-    std::vector<double> prev_raw_scores;
-    std::vector<double> prev_scores;
-    std::vector<double> new_rating_deviations;
-    std::vector<double> prev_rating_deviations;
-    std::vector<uint64_t> prev_disconnects; //bitflag
-    std::vector<int>    disconnects;
-
     World* w = World::getWorld();
     assert(w);
 
     unsigned player_count = RaceManager::get()->getNumPlayers();
-    m_result_ns->addUInt8((uint8_t)player_count);
 
     // If all players quitted the race, we assume something went wrong
     // and skip entirely rating and statistics updates.
@@ -2373,347 +2381,32 @@ void ServerLobby::computeNewRankings()
         if ((i + 1) == player_count)
             return;
     }
-
-    // Initialize data vectors
+    
+    // Fill the results for the rankings to process
+    std::vector<RaceResultData> data;
     for (unsigned i = 0; i < player_count; i++)
     {
-        const uint32_t id = RaceManager::get()->getKartInfo(i).getOnlineId();
-        double prev_raw_score = m_raw_scores.at(id);
-        new_raw_scores.push_back(prev_raw_score);
-        prev_raw_scores.push_back(prev_raw_score);
-
-        prev_scores.push_back(m_scores.at(id));
-
-        double prev_deviation = m_rating_deviations.at(id);
-        new_rating_deviations.push_back(prev_deviation);
-        prev_rating_deviations.push_back(prev_deviation);
-
-        prev_disconnects.push_back(m_num_ranked_disconnects.at(id));
+        RaceResultData entry;
+        entry.online_id = RaceManager::get()->getKartInfo(i).getOnlineId();
+        entry.is_eliminated = w->getKart(i)->isEliminated();
+        entry.time = RaceManager::get()->getKartRaceTime(i);
+        entry.handicap = w->getKart(i)->getHandicap();
+        data.push_back(entry);
     }
- 
-    // Update some variables
-    for (unsigned i = 0; i < player_count; i++)
-    {
-        const uint32_t id = RaceManager::get()->getKartInfo(i).getOnlineId();
-
-        //First, update the number of ranked races
-        m_num_ranked_races.at(id)++;
-
-        // Update the number of disconnects
-        // We store the last 64 results as bit flags in a 64-bit int.
-        // This way, shifting flushes the oldest result.
-        m_num_ranked_disconnects.at(id) <<= 1;
-
-        if (w->getKart(i)->isEliminated())
-            m_num_ranked_disconnects.at(id)++;
-
-        // std::popcount is C++20 only
-        std::bitset<64> b(m_num_ranked_disconnects.at(id));
-        disconnects.push_back(b.count());
-    }
-
-    // In this loop, considering the race as a set
-    // of head to head minimatches, we compute :
-    // I - Point changes for each ordered player pair.
-    //     In a (p1, p2) pair, only p1's rating is changed.
-    //     However, the loop will also go over (p2, p1).
-    //     Point changes can be assymetric.
-    // II - Rating deviation changes
-    for (unsigned i = 0; i < player_count; i++)
-    {
-        raw_scores_change.push_back(0.0);
-
-        double player1_raw_scores = new_raw_scores[i];
-        if (w->getKart(i)->getHandicap())
-            player1_raw_scores -= HANDICAP_OFFSET;
-
-        // If the player has quitted before the race end,
-        // the time value will be incorrect, but it will not be used
-        double player1_time  = RaceManager::get()->getKartRaceTime(i);
-        double player1_rd = prev_rating_deviations[i];
-
-        // On a disconnect, increase RD once,
-        // no matter how many opponents
-        if (w->getKart(i)->isEliminated() && disconnects[i] >= 3)
-            new_rating_deviations[i] =  prev_rating_deviations[i]
-                                      + BASE_RD_PER_DISCONNECT
-                                      + VAR_RD_PER_DISCONNECT * (disconnects[i] - 3);
-
-        // Loop over all opponents
-        for (unsigned j = 0; j < player_count; j++)
-        {
-            // Don't compare a player with himself
-            if (i == j)
-                continue;
-
-            // No change between two quitting players
-            if (   w->getKart(i)->isEliminated()
-                && w->getKart(j)->isEliminated())
-                continue;
-
-            double diff, result, expected_result, ranking_importance, max_time;
-            diff = result = expected_result = ranking_importance = max_time = 0.0;
-
-            double player2_raw_scores = new_raw_scores[j];
-            if (w->getKart(j)->getHandicap())
-                player2_raw_scores -= HANDICAP_OFFSET;
-
-            double player2_time = RaceManager::get()->getKartRaceTime(j);
-            double player2_rd = prev_rating_deviations[j];
-
-            // Each result can be viewed as new data helping to refine our previous
-            // estimates. But first, we need to assess how reliable this new data is
-            // compared to existing estimates.
-
-            bool handicap_used = w->getKart(i)->getHandicap() || w->getKart(j)->getHandicap();
-            double accuracy = computeDataAccuracy(player1_rd, player2_rd, player1_raw_scores, player2_raw_scores, player_count, handicap_used);
-
-            // Now that we've computed the reliability value,
-            // we can proceed with computing the points gained or lost
-
-            // Compute the result and race ranking importance
-
-            double mode_factor = getModeFactor();
-
-            if (w->getKart(i)->isEliminated())
-            {
-                // Recurring disconnects are punished through
-                // increased RD and higher RD floor,
-                // not through higher raw score loss
-                result = 0.0;
-                player1_time = player2_time * 1.2; // for getTimeSpread
-            }
-            else if (w->getKart(j)->isEliminated())
-            {
-                result = 1.0;
-                player2_time = player1_time * 1.2;
-            }
-            else
-            {
-                result = computeH2HResult(player1_time, player2_time);
-            }
-
-            max_time = std::min(MAX_SCALING_TIME, std::max(player1_time, player2_time));
-
-            ranking_importance = accuracy * mode_factor * scalingValueForTime(max_time);
-
-            // Compute the expected result using an ELO-like function
-            diff = player2_raw_scores - player1_raw_scores;
-
-            expected_result = 1.0/ (1.0 + std::pow(10.0,
-                diff / (  BASE_RANKING_POINTS / 2.0
-                        * getModeSpread()
-                        * getTimeSpread(std::min(player1_time, player2_time)))));
-
-            // Compute the ranking change
-            raw_scores_change[i] += ranking_importance * (result - expected_result);
-
-            // We now update the rating deviation. The change
-            // depends on the current RD, on the result's accuracy,
-            // on how expected the result was (upsets can increase RD)
-
-            // If there was a disconnect in this race, RD was handled once already
-            if (!w->getKart(i)->isEliminated()) {
-                // First the RD reduction based on accuracy and current RD
-                double rd_change_factor = accuracy * 0.0016;
-                double rd_change = (-1) * prev_rating_deviations[i] * rd_change_factor;
-
-                // If the unexpected result happened, we add a RD increase
-                // TODO : more reliable would be accumulating an expected_result/result
-                // differential over time, weighted through relative RDs.
-                // If that differential goes high, then increase RD while decaying
-                // the differential. Some work needed to ensure sensible maths.
-                double upset = std::abs(result - expected_result);
-                if (upset > 0.5)
-                {
-                    // Renormalize so expected result 50% is 1.0 and expected result 100% is 0.0
-                    upset = 2.0 - 2 * upset;
-                    upset = std::max(0.02, upset);
-
-                    // If upsets happen at the rate predicted by expected score,
-                    // this won't prevent the rating deviation from going down.
-                    // However, if upsets are at least twice more frequent than expected, RD will go up.
-                    rd_change += MIN_RATING_DEVIATION * rd_change_factor / upset;
-                }
-
-                // Minimum RD will be handled after all iterative RD change have been done,
-                // so as to avoid the order in which player pairs are computed changing results.
-                new_rating_deviations[i] += rd_change;
-            }
-        }
-    }
-
-    // Don't merge it in the main loop as new_scores value are used there
-    for (unsigned i = 0; i < player_count; i++)
-    {
-        new_raw_scores[i] += raw_scores_change[i];
-        const uint32_t id = RaceManager::get()->getKartInfo(i).getOnlineId();
-        m_raw_scores.at(id) = new_raw_scores[i];
-
-        // Ensure RD doesn't go below the RD floor.
-        // The minimum RD is increased in case of repeated disconnects
-        double disconnects_floor = 0;
-        if (disconnects[i] >= 3)
-        {
-            int n = disconnects[i] - 3;
-            disconnects_floor =   (disconnects[i]-2) * BASE_RD_PER_DISCONNECT
-                                + VAR_RD_PER_DISCONNECT * (n * (n+1)) / 2;
-        }
-        new_rating_deviations[i] = std::max(new_rating_deviations[i], MIN_RATING_DEVIATION + disconnects_floor);
-        m_rating_deviations.at(id) = new_rating_deviations[i];
 
-        // Update the main public rating. At min RD, it is equal to the raw score.
-        m_scores.at(id) = m_raw_scores.at(id) - 3*new_rating_deviations[i] + 3*MIN_RATING_DEVIATION;
-        if (m_scores.at(id) > m_max_scores.at(id))
-            m_max_scores.at(id) = m_scores.at(id);
+    for (int i = 0; i < 64; ++i) {
+        m_ranking->computeNewRankings(data, RaceManager::get()->isTimeTrialMode());
     }
 
     // Used to display rating change at the end of a race
+    m_result_ns->addUInt8((uint8_t)player_count);
     for (unsigned i = 0; i < player_count; i++)
     {
         const uint32_t id = RaceManager::get()->getKartInfo(i).getOnlineId();
-        double change = m_scores.at(id) - prev_scores[i];
+        double change = m_ranking->getDelta(id);
         m_result_ns->addFloat((float)change);
     }
 }   // computeNewRankings
-
-
-//-----------------------------------------------------------------------------
-/** Returns the mode race importance factor,
- *  used to make ranking move slower in more random modes.
- */
-double ServerLobby::getModeFactor()
-{
-    if (RaceManager::get()->isTimeTrialMode())
-        return 1.0;
-    return 0.75;
-}   // getModeFactor
-
-//-----------------------------------------------------------------------------
-/** Returns the mode spread factor, used so that a similar difference in
- *  skill will result in a similar ranking difference in more random modes.
- */
-double ServerLobby::getModeSpread()
-{
-    if (RaceManager::get()->isTimeTrialMode())
-        return 1.0;
-
-    //TODO: the value used here for normal races is a wild guess.
-    // When hard data to the spread tendencies of time-trial
-    // and normal mode becomes available, update this to make
-    // the spreads more comparable
-    return 1.25;
-}   // getModeSpread
-
-//-----------------------------------------------------------------------------
-/** Returns the time spread factor.
- *  Short races are more random, so the expected result changes depending
- *  on race duration.
- */
-double ServerLobby::getTimeSpread(double time)
-{
-    return sqrt(120.0 / time);
-}   // getTimeSpread
-
-//-----------------------------------------------------------------------------
-/** Compute the scaling value of a given time
- *  This is linear to race duration, getTimeSpread takes care
- *  of expecting a more random result in shorter races.
- */
-double ServerLobby::scalingValueForTime(double time)
-{
-    return time * BASE_POINTS_PER_SECOND;
-}   // scalingValueForTime
-
-//-----------------------------------------------------------------------------
-/** Computes the score of a head-to-head minimatch.
- *  If time difference > 2,5% ; the result is 1 (complete win of player 1)
- *  or 0 (complete loss of player 1)
- *  Otherwise, it is averaged between 0 and 1.
- */
-double ServerLobby::computeH2HResult(double player1_time, double player2_time)
-{
-    double max_time = std::max(player1_time, player2_time);
-    double min_time = std::min(player1_time, player2_time);
-
-    double result = (max_time - min_time) / (min_time / 20.0);
-    result = std::min(1.0, 0.5 + result);
-
-    if (player2_time <= player1_time)
-        result = 1.0 - result;
-
-    return result;
-}   // computeH2HResult
-
-//-----------------------------------------------------------------------------
-/** Computes a relative factor indicating how much informative value
- *  the new race result gives us.
- *
- *  For a player with a high own rating deviation, the current rating is unreliable
- *  so any new data holds more importance. This is crucial to allow reasonably
- *  fast rating convergence of new players, provided they play accurately rated opponents.
- *
- *  When the opponent has a high rating deviation, the expected scores are likely off.
- *  Therefore, the information from such a result is much less valuable.
- *
- *  We also reduce rating changes when the player ratings are very different, even
- *  after considering the uncertainties from rating deviation.
- *  This is multi-purpose :
- *   - With a very high rating difference, random race events (very poor luck, disconnects)
- *     are very likely to be the cause of any upset, so the rate of legitimate upsets is
- *     unreliable. No rating method is safe.
- *   - Attempting to "farm" much lower rated players against which a practical 100% winrate
- *     may be reached (outside of random events) becomes very ineffective. Instead,
- *     to gain rating points, the player has incentive to play well-rated opponents.
- *   - The primary goal is to ensure that two players of equal rating would be about
- *     evenly matched in head-to-head. If two strong players each beat a much weaker third
- *     player, very little information is gained on how a direct head-to-head between the
- *     strong players would go.
- *  For the purposes of this rating computation, we assume that the informational value
- *  of a race is roughly proportional to the likelihood of the weaker player winning.
- *  We cap the effect so that losing to a much weaker player still costs rating points.
- *
- *  In a race with many players, a single event can have a significant impact on the
- *  results of all the H2H. To avoid races with high players count having too strong
- *  rating swings, we apply a modifier scaling down accuracy.
- *
- *  Finally, while handicap is allowed in ranked races and a rating offset is applied
- *  to keep expected results realistic (without incentivizing playing handicap-only),
- *  the results of such races are much less reliable.
- */
-double ServerLobby::computeDataAccuracy(double player1_rd, double player2_rd, double player1_scores, double player2_scores, int player_count, bool handicap_used)
-{
-    double accuracy = player1_rd / (sqrt(player2_rd) * sqrt(MIN_RATING_DEVIATION));
-
-    double strong_lowerbound = (player1_scores > player2_scores) ? player1_scores - 3 * player1_rd
-                                                                 : player2_scores - 3 * player2_rd;
-    double weak_upperbound   = (player1_scores > player2_scores) ? player2_scores + 3 * player2_rd
-                                                                 : player1_scores + 3 * player1_rd;
-
-    if (weak_upperbound < strong_lowerbound)
-    {
-        double diff = strong_lowerbound - weak_upperbound;
-        diff = diff / (BASE_RANKING_POINTS / 2.0);
-
-        // The expected result is that of the weaker player and is between 0 and 0.5
-        double expected_result = 1.0/ (1.0 + std::pow(10.0, diff));
-        expected_result = std::max(0.2, sqrt(2*expected_result));
-
-        accuracy *= expected_result;
-    }
-
-    // Reduce the importance of single h2h in a race with many players.
-    // The overall impact of a race with more players is still always bigger.
-    double player_count_modifier = 2.0 / sqrt((double) player_count);
-    accuracy *= player_count_modifier;
-
-    // Races with handicap are unreliable for ranking
-    if (handicap_used)
-        accuracy *= 0.25;
-
-    return accuracy;
-}
-
 //-----------------------------------------------------------------------------
 /** Called when a client disconnects.
  *  \param event The disconnect event.
@@ -2756,29 +2449,6 @@ void ServerLobby::clientDisconnected(Event* event)
 #endif
 }   // clientDisconnected
 
-//-----------------------------------------------------------------------------
-void ServerLobby::clearDisconnectedRankedPlayer()
-{
-    for (auto it = m_ranked_players.begin(); it != m_ranked_players.end();)
-    {
-        if (it->second.expired())
-        {
-            const uint32_t id = it->first;
-            m_scores.erase(id);
-            m_max_scores.erase(id);
-            m_num_ranked_races.erase(id);
-            m_raw_scores.erase(id);
-            m_rating_deviations.erase(id);
-            m_num_ranked_disconnects.erase(id);
-            it = m_ranked_players.erase(it);
-        }
-        else
-        {
-            it++;
-        }
-    }
-}   // clearDisconnectedRankedPlayer
-
 //-----------------------------------------------------------------------------
 void ServerLobby::kickPlayerWithReason(STKPeer* peer, const char* reason) const
 {
@@ -3904,42 +3574,17 @@ void ServerLobby::getRankingForPlayer(std::shared_ptr<NetworkPlayerProfile> p)
     const XMLNode* result = request->getXMLData();
     std::string rec_success;
 
-    // Default result
-    double raw_score = BASE_RANKING_POINTS;
-    double score     = BASE_RANKING_POINTS - 3*BASE_RATING_DEVIATION + 3*MIN_RATING_DEVIATION;
-    double max_score = BASE_RANKING_POINTS - 3*BASE_RATING_DEVIATION + 3*MIN_RATING_DEVIATION;
-    unsigned num_races = 0;
-    double rating_deviation = BASE_RATING_DEVIATION;
-    uint64_t disconnects = 0;
+    bool success = false;
     if (result->get("success", &rec_success))
-    {
         if (rec_success == "yes")
-        {
-            result->get("scores", &score);
-            result->get("max-scores", &max_score);
-            result->get("num-races-done", &num_races);
-            result->get("raw-scores", &raw_score);
-            result->get("rating-deviation", &rating_deviation);
-            result->get("disconnects", &disconnects);
-        }
-        else
-        {
-            Log::error("ServerLobby", "No ranking info found for player %s.",
-                StringUtils::wideToUtf8(p->getName()).c_str());
-            // Kick the player to avoid his score being reset in case
-            // connection to stk addons is broken
-            auto peer = p->getPeer();
-            if (peer)
-            {
-                peer->kick();
-                return;
-            }
-        }
-    }
-    else
+            success = true;
+
+    if (!success)
     {
         Log::error("ServerLobby", "No ranking info found for player %s.",
             StringUtils::wideToUtf8(p->getName()).c_str());
+        // Kick the player to avoid his score being reset in case
+        // connection to stk addons is broken
         auto peer = p->getPeer();
         if (peer)
         {
@@ -3947,13 +3592,7 @@ void ServerLobby::getRankingForPlayer(std::shared_ptr<NetworkPlayerProfile> p)
             return;
         }
     }
-    m_ranked_players[id] = p;
-    m_scores[id] = score;
-    m_max_scores[id] = max_score;
-    m_num_ranked_races[id] = num_races;
-    m_raw_scores[id] = raw_score;
-    m_rating_deviations[id] = rating_deviation;
-    m_num_ranked_disconnects[id] = disconnects;
+    m_ranking->fill(id, result, p);
 }   // getRankingForPlayer
 
 //-----------------------------------------------------------------------------
@@ -3966,16 +3605,14 @@ void ServerLobby::submitRankingsToAddons()
     for (unsigned i = 0; i < RaceManager::get()->getNumPlayers(); i++)
     {
         const uint32_t id = RaceManager::get()->getKartInfo(i).getOnlineId();
+        const RankingEntry& scores = m_ranking->getScores(id);
         auto request = std::make_shared<SubmitRankingRequest>
-            (id, m_scores.at(id), m_max_scores.at(id),
-            m_num_ranked_races.at(id), m_raw_scores.at(id),
-            m_rating_deviations.at(id), m_num_ranked_disconnects.at(id),
-            RaceManager::get()->getKartInfo(i).getCountryCode());
+            (scores, RaceManager::get()->getKartInfo(i).getCountryCode());
         NetworkConfig::get()->setUserDetails(request, "submit-ranking");
-        Log::info("ServerLobby", "Submiting ranking for %s (%d) : %lf, %lf %d",
+        Log::info("ServerLobby", "Submitting ranking for %s (%d) : %lf, %lf %d",
             StringUtils::wideToUtf8(
             RaceManager::get()->getKartInfo(i).getPlayerName()).c_str(), id,
-            m_scores.at(id), m_max_scores.at(id), m_num_ranked_races.at(id));
+            scores.score, scores.max_score, scores.races);
         request->queue();
     }
 }   // submitRankingsToAddons
@@ -4086,10 +3723,7 @@ void ServerLobby::addWaitingPlayersToGame()
             }
         }
         uint32_t online_id = profile->getOnlineId();
-        if (ServerConfig::m_ranked &&
-            (m_ranked_players.find(online_id) == m_ranked_players.end() ||
-            (m_ranked_players.find(online_id) != m_ranked_players.end() &&
-            m_ranked_players.at(online_id).expired())))
+        if (ServerConfig::m_ranked && !m_ranking->has(online_id))
         {
             getRankingForPlayer(peer->getPlayerProfiles()[0]);
         }
@@ -4441,12 +4075,9 @@ void ServerLobby::handlePlayerDisconnection() const
                 // Real score will be submitted later in computeNewRankings
                 const uint32_t id =
                     RaceManager::get()->getKartInfo(i).getOnlineId();
-                unsigned num_races = m_num_ranked_races.at(id);
-                uint64_t disconnects = m_num_ranked_disconnects.at(id) << 1;
+                RankingEntry penalized = m_ranking->getTemporaryPenalizedScores(id);
                 auto request = std::make_shared<SubmitRankingRequest>
-                    (id, m_scores.at(id) - 200.0, m_max_scores.at(id),
-                    ++num_races, m_raw_scores.at(id) - 200.0,
-                    m_rating_deviations.at(id), ++disconnects,
+                    (penalized,
                     RaceManager::get()->getKartInfo(i).getCountryCode());
                 NetworkConfig::get()->setUserDetails(request,
                     "submit-ranking");
@@ -4746,7 +4377,12 @@ std::set<std::shared_ptr<STKPeer>> ServerLobby::getSpectatorsByLimit()
     auto peers = STKHost::get()->getPeers();
     std::set<std::shared_ptr<STKPeer>> always_spectate_peers;
 
-    unsigned player_limit = ServerConfig::m_max_players_in_game;
+    unsigned player_limit = ServerConfig::m_server_max_players;
+    // If the server has an in-game player limit lower than the lobby limit, apply it,
+    // A value of 0 for this parameter means no limit.
+    if (ServerConfig::m_max_players_in_game > 0)
+        player_limit = std::min(player_limit, (unsigned)ServerConfig::m_max_players_in_game);
+
     // only 10 players allowed for battle or soccer
     if (RaceManager::get()->isBattleMode() || RaceManager::get()->isSoccerMode())
         player_limit = std::min(player_limit, 10u);
diff --git a/src/network/protocols/server_lobby.hpp b/src/network/protocols/server_lobby.hpp
index fc18cfeca43..0c5998eeb9b 100644
--- a/src/network/protocols/server_lobby.hpp
+++ b/src/network/protocols/server_lobby.hpp
@@ -41,6 +41,7 @@ class NetworkString;
 class NetworkPlayerProfile;
 class STKPeer;
 class SocketAddress;
+class Ranking;
 
 namespace Online
 {
@@ -154,39 +155,7 @@ class ServerLobby : public LobbyProtocol
 
     std::map<std::string, uint64_t> m_pending_peer_connection;
 
-    /* Ranking related variables */
-    // If updating the base points, update the base points distribution in DB
-    const double BASE_RANKING_POINTS    = 4000.0; // Given to a new player on 1st connection to a ranked server
-    const double BASE_RATING_DEVIATION  = 1000.0; // Given to a new player on 1st connection to a ranked server
-    const double MIN_RATING_DEVIATION   = 100.0; // A server cron job makes RD go up if a player is inactive
-    const double BASE_RD_PER_DISCONNECT = 15.0;
-    const double VAR_RD_PER_DISCONNECT  = 3.0;
-    const double MAX_SCALING_TIME       = 360.0;
-    const double BASE_POINTS_PER_SECOND = 0.18;
-    const double HANDICAP_OFFSET        = 2000.0;
-
-    /** Online id to profile map, handling disconnection in ranked server */
-    std::map<uint32_t, std::weak_ptr<NetworkPlayerProfile> > m_ranked_players;
-
-    /** Multi-session rating for each current player */
-    std::map<uint32_t, double> m_raw_scores;
-
-    /** The rating uncertainty for each current player */
-    std::map<uint32_t, double> m_rating_deviations;
-
-    /** A single number compounding "raw score" and RD,
-      * for rating display to players and rankings */
-    std::map<uint32_t, double> m_scores;
-
-    /** The maximum rating obtained for each current player.
-      * This is based on m_scores, not m_raw_scores */
-    std::map<uint32_t, double> m_max_scores;
-
-    /** Number of disconnects in the previous 64 ranked races for each current players */
-    std::map<uint32_t, uint64_t> m_num_ranked_disconnects;
-
-    /** Number of ranked races done for each current players */
-    std::map<uint32_t, unsigned> m_num_ranked_races;
+    std::shared_ptr<Ranking> m_ranking;
 
     /* Saved the last game result */
     NetworkString* m_result_ns;
@@ -306,16 +275,6 @@ class ServerLobby : public LobbyProtocol
     void getRankingForPlayer(std::shared_ptr<NetworkPlayerProfile> p);
     void submitRankingsToAddons();
     void computeNewRankings();
-    void clearDisconnectedRankedPlayer();
-    double getModeFactor();
-    double getModeSpread();
-    double getTimeSpread(double time);
-    double getUncertaintySpread(uint32_t online_id);
-    double scalingValueForTime(double time);
-    double computeH2HResult(double player1_time, double player2_time);
-    double computeDataAccuracy(double player1_rd, double player2_rd,
-                               double player1_scores, double player2_scores,
-                               int player_count, bool handicap_used);
     void checkRaceFinished();
     void getHitCaptureLimit();
     void configPeersStartTime();
diff --git a/src/network/server_config.cpp b/src/network/server_config.cpp
index 5d22927a1ff..c58bfe63905 100644
--- a/src/network/server_config.cpp
+++ b/src/network/server_config.cpp
@@ -341,8 +341,10 @@ void loadServerLobbyFromConfig()
         m_server_max_players > 10)
         m_server_max_players = 10;
 
-    m_max_players_in_game = (m_max_players_in_game <= 0) ? m_server_max_players :
-        std::min(m_max_players_in_game, m_server_max_players);
+    // Parameters should only be sanity checked, not modified for interpretation (see #5173).
+    // A parameter of 0 here means no limit is to be applied.
+    if (m_max_players_in_game < 0)
+        m_max_players_in_game = 0;
 
     if (m_ipv6_connection)
     {
@@ -360,8 +362,6 @@ void loadServerLobbyFromConfig()
     }
     if (m_owner_less)
     {
-        if (m_min_start_game_players > m_max_players_in_game)
-            m_min_start_game_players = 1;
         if (!m_live_players)
             m_team_choosing = false;
         m_server_configurable = false;
diff --git a/src/race/race_manager.cpp b/src/race/race_manager.cpp
index 3feb801962e..f58d51985c3 100644
--- a/src/race/race_manager.cpp
+++ b/src/race/race_manager.cpp
@@ -138,7 +138,6 @@ RaceManager::RaceManager()
     m_flag_deactivated_ticks = stk_config->time2Ticks(3.0f);
     m_skipped_tracks_in_gp = 0;
     m_gp_time_target = 0.0f;
-    m_gp_total_laps = 0;
     setMaxGoal(0);
     setTimeTarget(0.0f);
     setReverseTrack(false);
@@ -317,15 +316,6 @@ void RaceManager::setDifficulty(Difficulty diff)
     m_difficulty = diff;
 }   // setDifficulty
 
-//---------------------------------------------------------------------------------------------
-/** Sets the difficulty to use.
- *  \param diff The difficulty to use.
- */
-//void RaceManager::setTireCount(int tires)
-//{
-//    m_tire_count = tires;
-//}   // setDifficulty
-
 //---------------------------------------------------------------------------------------------
 /** Sets a single track to be used in the next race.
  *  \param track The identifier of the track to use.
@@ -441,10 +431,7 @@ void RaceManager::startNew(bool from_overworld)
                     m_skipped_tracks_in_gp = m_saved_gp->getSkippedTracks();
                     Log::info("RaceManager","%d",isLapTrialMode());
                     if (isLapTrialMode())
-                    {
                         m_gp_time_target = m_saved_gp->getTimeTarget();
-                        m_gp_total_laps = m_saved_gp->getPlayerTotalLaps();
-                    }
                 }   // if m_saved_gp==NULL
             }   // if m_continue_saved_gp
         }   // if !network_world
@@ -804,7 +791,7 @@ void RaceManager::saveGP()
             m_grand_prix.getReverseType(),
             m_skipped_tracks_in_gp,
             isLapTrialMode() ? m_gp_time_target : 0.0f,
-            isLapTrialMode() ? m_gp_total_laps : 0,
+            0,
             m_kart_status);
 
         // If a new GP is saved, delete any other saved data for this
@@ -1357,4 +1344,4 @@ void RaceManager::setBenchmarking(bool benchmark)
 void RaceManager::scheduleBenchmark()
 {
     m_scheduled_benchmark = true;
-}   // scheduleBenchmark
+}   // scheduleBenchmark
\ No newline at end of file
diff --git a/src/race/race_manager.hpp b/src/race/race_manager.hpp
index 19682171c1a..18870138048 100644
--- a/src/race/race_manager.hpp
+++ b/src/race/race_manager.hpp
@@ -300,9 +300,6 @@ class RaceManager
     /** The selected difficulty. */
     Difficulty                       m_difficulty;
 
-    /** The amount of starting tires. */
-    //int                              m_tire_count;
-
     /** The major mode (single race, GP). */
     MajorRaceModeType                m_major_mode;
 
@@ -603,9 +600,6 @@ class RaceManager
     /** Returns the difficulty. */
     Difficulty getDifficulty() const { return m_difficulty; }
     // ----------------------------------------------------------------------------------------
-    /** Returns the tire count for three strikes battle. */
-    //int getTireAmount() const { return m_tire_count; }
-    // ----------------------------------------------------------------------------------------
     /** Returns the specified difficulty as a string. */
     std::string getDifficultyAsString(Difficulty diff) const
     {
@@ -942,10 +936,6 @@ class RaceManager
     // ----------------------------------------------------------------------------------------
     void setGPTimeTarget(float time_target) { m_gp_time_target = time_target; }
     // ----------------------------------------------------------------------------------------
-    int getGPTotalLaps() const { return m_gp_total_laps; }
-    // ----------------------------------------------------------------------------------------
-    void addGPTotalLaps(int laps) { m_gp_total_laps += laps; }
-    // ----------------------------------------------------------------------------------------
     /** Whether the current game mode allow live joining even the current game
      *. started in network*/
     bool supportsLiveJoining() const
diff --git a/src/states_screens/dialogs/custom_video_settings.cpp b/src/states_screens/dialogs/custom_video_settings.cpp
index 9aad0d9ba92..738f9b0a79f 100644
--- a/src/states_screens/dialogs/custom_video_settings.cpp
+++ b/src/states_screens/dialogs/custom_video_settings.cpp
@@ -103,7 +103,9 @@ void CustomVideoSettingsDialog::beforeAddingWidgets()
     shadows->addLabel(_("Low"));        // 1
     shadows->addLabel(_("Medium"));     // 2
     shadows->addLabel(_("High"));       // 3
-    shadows->setValue(UserConfigParams::m_shadows_resolution == 2048 ? 3 :
+    shadows->addLabel(_("Very High"));  // 4
+    shadows->setValue(UserConfigParams::m_shadows_resolution == 4096 ? 4 :
+                      UserConfigParams::m_shadows_resolution == 2048 ? 3 :
                       UserConfigParams::m_shadows_resolution == 1024 ? 2 :
                       UserConfigParams::m_shadows_resolution ==  512 ? 1 : 0);
 
@@ -161,7 +163,8 @@ GUIEngine::EventPropagation CustomVideoSettingsDialog::processEvent(const std::s
                 UserConfigParams::m_shadows_resolution =
                     getWidget<SpinnerWidget>("shadows")->getValue() == 1 ?  512 :
                     getWidget<SpinnerWidget>("shadows")->getValue() == 2 ? 1024 :
-                    getWidget<SpinnerWidget>("shadows")->getValue() == 3 ? 2048 : 0;
+                    getWidget<SpinnerWidget>("shadows")->getValue() == 3 ? 2048 :
+                    getWidget<SpinnerWidget>("shadows")->getValue() == 4 ? 4096 : 0;
             }
             else
             {
diff --git a/src/states_screens/help/help_screen_1.cpp b/src/states_screens/help/help_screen_1.cpp
index bb6c6d5ba75..eda76f31db2 100644
--- a/src/states_screens/help/help_screen_1.cpp
+++ b/src/states_screens/help/help_screen_1.cpp
@@ -21,6 +21,10 @@
 #include "guiengine/widgets/button_widget.hpp"
 #include "modes/tutorial_utils.hpp"
 
+#ifdef ANDROID
+#include <SDL_system.h>
+#endif
+
 using namespace GUIEngine;
 
 // -----------------------------------------------------------------------------
@@ -37,6 +41,22 @@ void HelpScreen1::loadedFromFile()
 
 // -----------------------------------------------------------------------------
 
+void HelpScreen1::beforeAddingWidget()
+{
+#ifdef ANDROID
+    if (SDL_IsAndroidTV())
+    {
+        Widget* tutorial = getWidget("startTutorial");
+        if (tutorial)
+            tutorial->setVisible(false);
+
+        Widget* tutorial_icon = getWidget("tutorialIcon");
+        if (tutorial_icon)
+            tutorial_icon->setVisible(false);
+    }
+#endif
+}
+
 void HelpScreen1::eventCallback(Widget* widget, const std::string& name, const int playerID)
 {
     if (name == "startTutorial")
diff --git a/src/states_screens/help/help_screen_1.hpp b/src/states_screens/help/help_screen_1.hpp
index e517f721c73..2676718e49e 100644
--- a/src/states_screens/help/help_screen_1.hpp
+++ b/src/states_screens/help/help_screen_1.hpp
@@ -35,6 +35,9 @@ class HelpScreen1 : public GUIEngine::Screen, public GUIEngine::ScreenSingleton<
 
     /** \brief implement callback from parent class GUIEngine::Screen */
     virtual void loadedFromFile() OVERRIDE;
+    
+    /** \brief implement callback from parent class GUIEngine::Screen */
+    virtual void beforeAddingWidget() OVERRIDE;
 
     /** \brief implement callback from parent class GUIEngine::Screen */
     virtual void eventCallback(GUIEngine::Widget* widget, const std::string& name,
diff --git a/src/states_screens/kart_selection.cpp b/src/states_screens/kart_selection.cpp
index e9cc2715bf2..ac48e611fe5 100644
--- a/src/states_screens/kart_selection.cpp
+++ b/src/states_screens/kart_selection.cpp
@@ -279,12 +279,12 @@ void KartSelectionScreen::beforeAddingWidget()
     );
     if (useContinueButton())
     {
-        getWidget("kartlist")->m_properties[GUIEngine::PROP_WIDTH] = "85%";
+        getWidget("karts")->m_properties[GUIEngine::PROP_WIDTH] = "85%";
         getWidget("continue")->setVisible(true);
     }
     else
     {
-        getWidget("kartlist")->m_properties[GUIEngine::PROP_WIDTH] = "100%";
+        getWidget("karts")->m_properties[GUIEngine::PROP_WIDTH] = "100%";
         getWidget("continue")->setVisible(false);
     }
     // Remove dispatcher from m_widgets before calculateLayout otherwise a
@@ -354,7 +354,7 @@ void KartSelectionScreen::beforeAddingWidget()
     kart_class->m_properties[GUIEngine::PROP_MIN_VALUE] = "0";
     kart_class->m_properties[GUIEngine::PROP_MAX_VALUE] = StringUtils::toString(classes.size());
     
-    for (int i = 0; i < classes.size(); i++)
+    for (unsigned int i = 0; i < classes.size(); i++)
     {
         // Make the first letter upper-case
         std::string class_str = classes[i];
@@ -418,9 +418,6 @@ void KartSelectionScreen::init()
 
     DynamicRibbonWidget* w = getWidget<DynamicRibbonWidget>("karts");
     assert( w != NULL );
-    // Only allow keyboard and gamepad to choose kart without continue button in
-    // multitouch GUI, so mouse (touch) clicking can be used as previewing karts
-    w->setEventCallbackActive(Input::IT_MOUSEBUTTON, !useContinueButton());
 
     KartHoverListener* karthoverListener = new KartHoverListener(this);
     w->registerHoverListener(karthoverListener);
@@ -525,8 +522,10 @@ void KartSelectionScreen::tearDown()
     m_kart_widgets.clearAndDeleteAll();
 
     if (m_must_delete_on_back)
+    {
+        elementsWereDeleted();
         GUIEngine::removeScreen(this);
-
+    }
 }   // tearDown
 
 // ----------------------------------------------------------------------------
@@ -1215,9 +1214,9 @@ void KartSelectionScreen::eventCallback(Widget* widget,
         assert(w != NULL);
         const std::string selection = w->getSelectionIDString(player_id);
 
-        if (getWidget<CheckBoxWidget>("favorite")->getState()
-         && player_id == PLAYER_ID_GAME_MASTER
-         && selection != RANDOM_KART_ID)
+        if (getWidget<CheckBoxWidget>("favorite")->getState() &&
+            player_id == PLAYER_ID_GAME_MASTER &&
+            selection != RANDOM_KART_ID && !selection.empty())
         {
             const KartProperties *kp = kart_properties_manager->getKart(selection);
 
@@ -1231,7 +1230,7 @@ void KartSelectionScreen::eventCallback(Widget* widget,
             }
             setKartsFromCurrentGroup();
         }
-        else if (m_kart_widgets.size() > unsigned(player_id))
+        else if (m_kart_widgets.size() > unsigned(player_id) && !useContinueButton())
             playerConfirm(player_id);
     }
     else if (name == "kart_class")
@@ -1633,7 +1632,7 @@ PtrVector<const KartProperties, REF> KartSelectionScreen::getUsableKarts(
             prop->getName().make_lower().find(search_text.c_str()) == -1)
             continue;
         
-        if (kart_class->getValue() != classes.size() &&
+        if (kart_class->getValue() != (int)classes.size() &&
             classes[kart_class->getValue()] != prop->getKartType())
             continue;
 
diff --git a/src/states_screens/main_menu_screen.cpp b/src/states_screens/main_menu_screen.cpp
index bb35a2d8d4d..ccd4a461383 100644
--- a/src/states_screens/main_menu_screen.cpp
+++ b/src/states_screens/main_menu_screen.cpp
@@ -72,6 +72,10 @@
 
 #include <IrrlichtDevice.h>
 
+#ifdef ANDROID
+#include <SDL_system.h>
+#endif
+
 using namespace GUIEngine;
 using namespace Online;
 
@@ -119,6 +123,15 @@ void MainMenuScreen::beforeAddingWidget()
     if (w)
         w->setVisible(false);
 #endif
+
+#ifdef ANDROID
+    if (SDL_IsAndroidTV())
+    {
+        Widget* tutorial = getWidget("startTutorial");
+        if (tutorial)
+            tutorial->setVisible(false);
+    }
+#endif
 }
 
 // ----------------------------------------------------------------------------
@@ -327,6 +340,12 @@ void MainMenuScreen::onUpdate(float delta)
     if (player->getUseFrequency() != 0)
         return;
 
+#ifdef ANDROID
+    // Don't show tutorial dialog on Android TV
+    if (SDL_IsAndroidTV())
+        return;
+#endif
+
     player->incrementUseFrequency();
     class PlayTutorial :
           public MessageDialog::IConfirmDialogListener
diff --git a/src/states_screens/online/networking_lobby.cpp b/src/states_screens/online/networking_lobby.cpp
index 217653c33fa..94caa412429 100644
--- a/src/states_screens/online/networking_lobby.cpp
+++ b/src/states_screens/online/networking_lobby.cpp
@@ -841,6 +841,7 @@ void NetworkingLobby::eventCallback(Widget* widget, const std::string& name,
     {
         onEnterPressed(m_chat_box->getText());
         m_chat_box->setText("");
+        m_chat_box->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
     }   // send chat message
     else if (name == m_emoji_button->m_properties[PROP_ID] &&
         !ScreenKeyboard::isActive())
diff --git a/src/states_screens/online/tracks_screen.cpp b/src/states_screens/online/tracks_screen.cpp
index b6d2ec407d2..f0d9c5e33fe 100644
--- a/src/states_screens/online/tracks_screen.cpp
+++ b/src/states_screens/online/tracks_screen.cpp
@@ -343,7 +343,7 @@ void TracksScreen::beforeAddingWidget()
 
     RibbonWidget* tabs = getWidget<RibbonWidget>("trackgroups");
     tabs->clearAllChildren();
-    
+
     RaceManager::MinorRaceModeType minor_mode = RaceManager::get()->getMinorMode();
     bool is_soccer = minor_mode == RaceManager::MINOR_MODE_SOCCER;
     bool is_arena = is_soccer || RaceManager::get()->isBattleMode();
diff --git a/src/states_screens/options/options_common.cpp b/src/states_screens/options/options_common.cpp
index d134301ba26..104fedc09ed 100644
--- a/src/states_screens/options/options_common.cpp
+++ b/src/states_screens/options/options_common.cpp
@@ -43,4 +43,19 @@ namespace OptionsCommon
     	if(screen)
         	StateManager::get()->replaceTopMostScreen(screen);
 	}
+
+	// In the in-game pause options, disable the players and language tabs
+	void setTabStatus()
+	{
+		if (StateManager::get()->getGameState() == GUIEngine::INGAME_MENU)
+		{
+	    	GUIEngine::getWidget("tab_players")->setActive(false);
+	    	GUIEngine::getWidget("tab_language")->setActive(false);			
+		}
+		else
+		{
+			GUIEngine::getWidget("tab_players")->setActive(true);
+	    	GUIEngine::getWidget("tab_language")->setActive(true);
+	    }
+	} // setTabStatus
 }
\ No newline at end of file
diff --git a/src/states_screens/options/options_common.hpp b/src/states_screens/options/options_common.hpp
index 9bafe3e26c3..9a618f06070 100644
--- a/src/states_screens/options/options_common.hpp
+++ b/src/states_screens/options/options_common.hpp
@@ -52,6 +52,7 @@
 namespace OptionsCommon
 {
 	void switchTab(std::string selected_tab);
+	void setTabStatus();
 }
 
 #endif
\ No newline at end of file
diff --git a/src/states_screens/options/options_screen_audio.cpp b/src/states_screens/options/options_screen_audio.cpp
index 0bcad71bfc4..97174de5d00 100644
--- a/src/states_screens/options/options_screen_audio.cpp
+++ b/src/states_screens/options/options_screen_audio.cpp
@@ -41,6 +41,8 @@ void OptionsScreenAudio::loadedFromFile()
 void OptionsScreenAudio::init()
 {
     Screen::init();
+    OptionsCommon::setTabStatus();
+
     RibbonWidget* ribbon = this->getWidget<RibbonWidget>("options_choice");
     assert(ribbon != NULL);
     ribbon->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
@@ -70,7 +72,6 @@ void OptionsScreenAudio::init()
         getWidget<SpinnerWidget>("sfx_volume")->setActive(false);
     if(!UserConfigParams::m_music)
         getWidget<SpinnerWidget>("music_volume")->setActive(false);
-
 }   // init
 
 // -----------------------------------------------------------------------------
diff --git a/src/states_screens/options/options_screen_device.cpp b/src/states_screens/options/options_screen_device.cpp
index 209f21113be..7f0fbd32cab 100644
--- a/src/states_screens/options/options_screen_device.cpp
+++ b/src/states_screens/options/options_screen_device.cpp
@@ -63,6 +63,8 @@ void OptionsScreenDevice::beforeAddingWidget()
 void OptionsScreenDevice::init()
 {
     Screen::init();
+    OptionsCommon::setTabStatus();
+
     RibbonWidget* tabBar = getWidget<RibbonWidget>("options_choice");
     assert(tabBar != NULL);
     // Focus is set to the actions list later in the init
@@ -182,9 +184,7 @@ void OptionsScreenDevice::init()
     actions->setSelectionID(0);
 
     // Disable deleting or disabling configuration mid-race
-    bool in_game = StateManager::get()->getGameState() == GUIEngine::INGAME_MENU;
-    
-    if (in_game)
+    if (StateManager::get()->getGameState() == GUIEngine::INGAME_MENU)
     {
         delete_button->setActive(false);
         disable_toggle->setActive(false);
diff --git a/src/states_screens/options/options_screen_display.cpp b/src/states_screens/options/options_screen_display.cpp
index 68f1bc81434..09148348eda 100644
--- a/src/states_screens/options/options_screen_display.cpp
+++ b/src/states_screens/options/options_screen_display.cpp
@@ -66,6 +66,8 @@ void OptionsScreenDisplay::loadedFromFile()
 void OptionsScreenDisplay::init()
 {
     Screen::init();
+    OptionsCommon::setTabStatus();
+
     RibbonWidget* ribbon = getWidget<RibbonWidget>("options_choice");
     assert(ribbon != NULL);
     ribbon->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
diff --git a/src/states_screens/options/options_screen_general.cpp b/src/states_screens/options/options_screen_general.cpp
index 1dca1dc2cb5..b83e7c4b1cf 100644
--- a/src/states_screens/options/options_screen_general.cpp
+++ b/src/states_screens/options/options_screen_general.cpp
@@ -72,6 +72,8 @@ void OptionsScreenGeneral::init()
     assert( show_login!= NULL );
     show_login->setState( UserConfigParams::m_always_show_login_screen);
 
+    OptionsCommon::setTabStatus();
+
 #ifdef MOBILE_STK
     if (ExtractMobileAssets::hasFullAssets())
     {
diff --git a/src/states_screens/options/options_screen_input.cpp b/src/states_screens/options/options_screen_input.cpp
index 15289a5ea67..b58a50744ff 100644
--- a/src/states_screens/options/options_screen_input.cpp
+++ b/src/states_screens/options/options_screen_input.cpp
@@ -154,6 +154,8 @@ void OptionsScreenInput::buildDeviceList()
 void OptionsScreenInput::init()
 {
     Screen::init();
+    OptionsCommon::setTabStatus();
+
     RibbonWidget* tabBar = this->getWidget<RibbonWidget>("options_choice");
     assert(tabBar != NULL);
     tabBar->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
diff --git a/src/states_screens/options/options_screen_ui.cpp b/src/states_screens/options/options_screen_ui.cpp
index de9ee66b39e..6caa85f3df8 100644
--- a/src/states_screens/options/options_screen_ui.cpp
+++ b/src/states_screens/options/options_screen_ui.cpp
@@ -148,6 +148,7 @@ void OptionsScreenUI::loadedFromFile()
 void OptionsScreenUI::init()
 {
     Screen::init();
+    OptionsCommon::setTabStatus();
 
     bool in_game = StateManager::get()->getGameState() == GUIEngine::INGAME_MENU;
 
diff --git a/src/states_screens/options/options_screen_video.cpp b/src/states_screens/options/options_screen_video.cpp
index 98807468938..8bed1953014 100644
--- a/src/states_screens/options/options_screen_video.cpp
+++ b/src/states_screens/options/options_screen_video.cpp
@@ -64,7 +64,7 @@ void OptionsScreenVideo::initPresets()
 
     m_presets.push_back // Level 4
     ({
-        true /* light */, 0 /* shadow */, false /* bloom */, true /* lightshaft */,
+        true /* light */, 0 /* shadow */, false /* bloom */, false /* lightshaft */,
         true /* glow */, true /* mlaa */, false /* ssao */, true /* light scatter */,
         true /* animatedCharacters */, 2 /* particles */, 2 /* image_quality */,
         false /* degraded IBL */, 3 /* Geometry Detail */
@@ -81,7 +81,7 @@ void OptionsScreenVideo::initPresets()
     m_presets.push_back // Level 6
     ({
         true /* light */, 1024 /* shadow */, true /* bloom */, true /* lightshaft */,
-        true /* glow */, true /* mlaa */, true /* ssao */, true /* light scatter */,
+        true /* glow */, true /* mlaa */, false /* ssao */, true /* light scatter */,
         true /* animatedCharacters */, 2 /* particles */, 3 /* image_quality */,
         false /* degraded IBL */, 4 /* Geometry Detail */
     });
@@ -94,17 +94,25 @@ void OptionsScreenVideo::initPresets()
         false /* degraded IBL */, 5 /* Geometry Detail */
     });
 
-    m_blur_presets.push_back
+    m_presets.push_back // Level 8
+    ({
+        true /* light */, 4096 /* shadow */, true /* bloom */, true /* lightshaft */,
+        true /* glow */, true /* mlaa */, true /* ssao */, true /* light scatter */,
+        true /* animatedCharacters */, 2 /* particles */, 3 /* image_quality */,
+        false /* degraded IBL */, 5 /* Geometry Detail */
+    });
+
+    m_blur_presets.push_back // Level 0
     ({
         false /* motionblur */, false /* depth of field */
     });
 
-    m_blur_presets.push_back
+    m_blur_presets.push_back // Level 1
     ({
         true  /* motionblur */, false /* depth of field */
     });
 
-    m_blur_presets.push_back
+    m_blur_presets.push_back // Level 2
     ({
         true  /* motionblur */, true  /* depth of field */
     });
@@ -124,6 +132,9 @@ void OptionsScreenVideo::initPresets()
     m_scale_rtts_custom_presets.push_back({ 0.9f });
     m_scale_rtts_custom_presets.push_back({ 0.95f });
     m_scale_rtts_custom_presets.push_back({ 1.0f });
+    m_scale_rtts_custom_presets.push_back({ 1.25f });
+    m_scale_rtts_custom_presets.push_back({ 1.5f });
+    m_scale_rtts_custom_presets.push_back({ 2.0f });
 
 }   // initPresets
 
@@ -209,7 +220,7 @@ OptionsScreenVideo::OptionsScreenVideo() : Screen("options/options_video.stkgui"
 void OptionsScreenVideo::loadedFromFile()
 {
     m_inited = false;
-    assert(m_presets.size() == 7);
+    assert(m_presets.size() == 8);
     assert(m_blur_presets.size() == 3);
 
     GUIEngine::SpinnerWidget* gfx =
@@ -230,6 +241,8 @@ void OptionsScreenVideo::loadedFromFile()
 void OptionsScreenVideo::init()
 {
     Screen::init();
+    OptionsCommon::setTabStatus();
+
     m_prev_adv_pipline = UserConfigParams::m_dynamic_lights;
     m_prev_img_quality = getImageQuality();
     RibbonWidget* ribbon = getWidget<RibbonWidget>("options_choice");
@@ -290,6 +303,9 @@ void OptionsScreenVideo::init()
     scale_rtts->addLabel("90%");
     scale_rtts->addLabel("95%");
     scale_rtts->addLabel("100%");
+    scale_rtts->addLabel("125%");
+    scale_rtts->addLabel("150%");
+    scale_rtts->addLabel("200%");
 
     // --- set gfx settings values
     updateGfxSlider();
diff --git a/src/states_screens/race_gui.cpp b/src/states_screens/race_gui.cpp
index cf6940d0b31..0f692d78283 100644
--- a/src/states_screens/race_gui.cpp
+++ b/src/states_screens/race_gui.cpp
@@ -519,14 +519,22 @@ void RaceGUI::drawLiveDifference()
     video::SColor time_color;
 
     // Change color depending on value
-    if (live_difference > 1.0f)
+    if (live_difference > 2.5f)
         time_color = video::SColor(255, 255, 0, 0);
+    else if (live_difference > 1.0f)
+        time_color = video::SColor(255, 255, 60, 0);
+    else if (live_difference > 0.3f)
+        time_color = video::SColor(255, 255, 120, 0);
     else if (live_difference > 0.0f)
-        time_color = video::SColor(255, 255, 160, 0);
+        time_color = video::SColor(255, 255, 180, 0);
+    else if (live_difference > -0.3f)
+        time_color = video::SColor(255, 210, 230, 0);
     else if (live_difference > -1.0f)
-        time_color = video::SColor(255, 160, 255, 0);
+        time_color = video::SColor(255, 105, 255, 0);
+    else if (live_difference > -2.5f)
+        time_color = video::SColor(255, 0, 210, 30);
     else
-        time_color = video::SColor(255, 0, 255, 0);
+        time_color = video::SColor(255, 0, 160, 60);
 
     int dist_from_right = 10 + timer_width;
 
diff --git a/src/states_screens/race_gui_overworld.cpp b/src/states_screens/race_gui_overworld.cpp
index a82c5dd95fa..f72d6a39635 100644
--- a/src/states_screens/race_gui_overworld.cpp
+++ b/src/states_screens/race_gui_overworld.cpp
@@ -58,6 +58,11 @@
 #include <IrrlichtDevice.h>
 #include <ISceneCollisionManager.h>
 #include <ISceneManager.h>
+
+#ifdef ANDROID
+#include <SDL_system.h>
+#endif
+
 using namespace irr;
 
 #include <algorithm>
@@ -526,6 +531,11 @@ void RaceGUIOverworld::drawGlobalMiniMap()
 
             if (challenges[n].m_challenge_id == "tutorial")
             {
+#ifdef ANDROID
+                if (SDL_IsAndroidTV())
+                    continue;
+#endif
+
                 gui::ScalableFont* font = GUIEngine::getTitleFont();
                 font->draw(_("Tutorial"), pos, video::SColor(255,255,255,255),
                            false, true /* vcenter */, NULL);
diff --git a/src/states_screens/race_result_gui.cpp b/src/states_screens/race_result_gui.cpp
index 49a317c611d..a487a73dc47 100644
--- a/src/states_screens/race_result_gui.cpp
+++ b/src/states_screens/race_result_gui.cpp
@@ -207,27 +207,6 @@ void RaceResultGUI::init()
         MessageQueue::add(MessageQueue::MT_GENERIC, tips_string);
     }
 #endif
-    
-    if (RaceManager::get()->getMajorMode() == RaceManager::MAJOR_MODE_GRAND_PRIX &&
-        !NetworkConfig::get()->isNetworking() &&
-        (RaceManager::get()->getMinorMode() == RaceManager::MINOR_MODE_NORMAL_RACE || RaceManager::get()->getMinorMode() == RaceManager::MINOR_MODE_TIME_TRIAL ||
-        RaceManager::get()->isLapTrialMode()))
-    {
-        const AbstractKart* k = RaceManager::get()->getKartWithGPRank(RaceManager::get()->getLocalPlayerGPRank(PLAYER_ID_GAME_MASTER));
-        RaceManager::get()->addGPTotalLaps(World::getWorld()->getFinishedLapsOfKart(k->getWorldKartId()));
-        if (RaceManager::get()->getNumOfTracks() == RaceManager::get()->getTrackNumber() + 1
-           && !RaceManager::get()->getGrandPrix().isRandomGP() && RaceManager::get()->getSkippedTracksInGP() == 0)
-        {
-            Highscores* highscores = World::getWorld()->getGPHighscores();
-            float full_time;
-            if (RaceManager::get()->isLapTrialMode())
-                full_time = static_cast<float>(RaceManager::get()->getGPTotalLaps());
-            else
-                full_time = RaceManager::get()->getOverallTime(RaceManager::get()->getLocalPlayerGPRank(PLAYER_ID_GAME_MASTER));
-            std::string gp_name = RaceManager::get()->getGrandPrix().getId();
-            highscores->addGPData(k->getIdent(), k->getController()->getName(), gp_name, full_time);
-        }
-    }
 }   // init
 
 //-----------------------------------------------------------------------------
@@ -256,6 +235,15 @@ void RaceResultGUI::enableAllButtons()
     operations->setActive(true);
     operations->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
 
+    auto makeContinueButton
+    {
+        [](GUIEngine::IconButtonWidget *button)
+        {
+            button->setLabel(_("Continue"));
+            button->setImage("gui/icons/green_check.png");
+        }
+    };
+
     if (RaceManager::get()->getMajorMode() == RaceManager::MAJOR_MODE_GRAND_PRIX)
     {
         enableGPProgress();
@@ -281,8 +269,7 @@ void RaceResultGUI::enableAllButtons()
     // If we're in a network world, change the buttons text
     if (World::getWorld()->isNetworkWorld())
     {
-        right->setLabel(_("Continue"));
-        right->setImage("gui/icons/green_check.png");
+        makeContinueButton(right);
         right->setVisible(true);
         operations->select("right", PLAYER_ID_GAME_MASTER);
         middle->setVisible(false);
@@ -304,8 +291,7 @@ void RaceResultGUI::enableAllButtons()
          (RaceManager::get()->getMajorMode() != RaceManager::MAJOR_MODE_GRAND_PRIX ||
           RaceManager::get()->getTrackNumber() + 1 == RaceManager::get()->getNumOfTracks() ) )
     {
-        middle->setLabel(_("Continue"));
-        middle->setImage("gui/icons/green_check.png");
+        makeContinueButton(middle);
         middle->setVisible(true);
         operations->select("middle", PLAYER_ID_GAME_MASTER);
     }
@@ -313,16 +299,14 @@ void RaceResultGUI::enableAllButtons()
     {
         // In case of a GP:
         // ----------------
-        middle->setLabel(_("Continue"));
-        middle->setImage("gui/icons/green_check.png");
+        makeContinueButton(middle);
         middle->setVisible(false);
         middle->setFocusable(false);
         left->setVisible(false);
         left->setFocusable(false);
 
         // Two continue buttons to make sure the buttons in the bar is balanced
-        right->setLabel(_("Continue"));
-        right->setImage("gui/icons/green_check.png");
+        makeContinueButton(right);
         right->setVisible(true);
 
         if (RaceManager::get()->getTrackNumber() + 1 < RaceManager::get()->getNumOfTracks())
@@ -673,7 +657,6 @@ void RaceResultGUI::displayCTFResults()
     //Draw win text
     core::stringw result_text;
     video::SColor color = video::SColor(255, 255, 255, 255);
-    video::SColor red_color = video::SColor(255, 255, 0, 0);
     gui::IGUIFont* font = GUIEngine::getTitleFont();
     int team_icon_height = font->getDimension(L"A").Height;
     int current_x = UserConfigParams::m_width / 2;
@@ -739,18 +722,44 @@ void RaceResultGUI::displayCTFResults()
 
     // The red team player scores:
     current_y += rect.Height / 2 + rect.Height / 4;
-    font = GUIEngine::getSmallFont();
+    drawCTFScorers(KART_TEAM_RED, current_x, current_y, height);
+    current_x += UserConfigParams::m_width / 2;
+    drawCTFScorers(KART_TEAM_BLUE, current_x, current_y, height);
+#endif
+} // displayCTFResults
+
+//-----------------------------------------------------------------------------
+/** Displays the CTF scorers for a team
+ *  \param team The team for which to draw the scorers
+ *  \param x Left limit of the scorers lists (both blue and red)
+ *  \param y Top limit of the scorers lists
+ *  \param height Maximum y of the table area (??) */
+void RaceResultGUI::drawCTFScorers(KartTeam team, int x, int y, int height)
+{
+#ifndef SERVER_ONLY
+    CaptureTheFlag* ctf = dynamic_cast<CaptureTheFlag*>(World::getWorld());
+    gui::IGUIFont* font = GUIEngine::getSmallFont();
     irr::video::ITexture* kart_icon;
 
-    int prev_y = current_y;
+    core::stringw result_text;
+    video::SColor color = video::SColor(255, 255, 255, 255);
+    video::SColor red_color = video::SColor(255, 255, 0, 0);
+
+    int current_x = x;
+    int current_y = y;
+    core::dimension2du rect;
+    core::rect<s32> pos(current_x, current_y, current_x, current_y);
+
     const unsigned num_karts = ctf->getNumKarts();
     for (unsigned int i = 0; i < num_karts; i++)
     {
         AbstractKart* kart = ctf->getKartAtPosition(i + 1);
         unsigned kart_id = kart->getWorldKartId();
-        if (ctf->getKartTeam(kart_id) != KART_TEAM_RED)
+        if (ctf->getKartTeam(kart_id) != team)
             continue;
         result_text = kart->getController()->getName();
+
+        // add the country flag if available
         if (RaceManager::get()->getKartGlobalPlayerId(kart_id) > -1)
         {
             const core::stringw& flag = StringUtils::getCountryFlag(
@@ -768,9 +777,9 @@ void RaceResultGUI::displayCTFResults()
         }
         else
         {
-            result_text.append(
-                StringUtils::toWString(ctf->getKartScore(kart_id)));
+            result_text.append(StringUtils::toWString(ctf->getKartScore(kart_id)));
         }
+
         rect = font->getDimension(result_text.c_str());
         current_y += rect.Height;
 
@@ -781,63 +790,15 @@ void RaceResultGUI::displayCTFResults()
             kart->getController()->isLocalPlayerController() ?
             red_color : color, true, false);
         kart_icon = kart->getKartProperties()->getIconMaterial()->getTexture();
-        source_rect = core::recti(core::vector2di(0, 0), kart_icon->getSize());
+        core::recti source_rect = core::recti(core::vector2di(0, 0), kart_icon->getSize());
         irr::u32 offset_x =
             (irr::u32)(font->getDimension(result_text.c_str()).Width / 1.5f);
-        dest_rect = core::recti(current_x - offset_x - m_width_icon, current_y,
-            current_x - offset_x, current_y + m_width_icon);
-        draw2DImage(kart_icon, dest_rect, source_rect, NULL, NULL, true);
-    }
-
-    // The blue team player scores:
-    current_y = prev_y;
-    current_x += UserConfigParams::m_width / 2;
-    for (unsigned int i = 0; i < num_karts; i++)
-    {
-        AbstractKart* kart = ctf->getKartAtPosition(i + 1);
-        unsigned kart_id = kart->getWorldKartId();
-        if (ctf->getKartTeam(kart_id) != KART_TEAM_BLUE)
-            continue;
-        result_text = kart->getController()->getName();
-        if (RaceManager::get()->getKartGlobalPlayerId(kart_id) > -1)
-        {
-            const core::stringw& flag = StringUtils::getCountryFlag(
-                RaceManager::get()->getKartInfo(kart_id).getCountryCode());
-            if (!flag.empty())
-            {
-                result_text += L" ";
-                result_text += flag;
-            }
-        }
-        result_text.append("  ");
-        if (kart->isEliminated())
-        {
-            continue;
-        }
-        else
-        {
-            result_text.append(
-                StringUtils::toWString(ctf->getKartScore(kart_id)));
-        }
-        rect = font->getDimension(result_text.c_str());
-        current_y += rect.Height;
-
-        if (current_y > height) break;
-
-        pos = core::rect<s32>(current_x, current_y, current_x, current_y);
-        font->draw(result_text, pos,
-            kart->getController()->isLocalPlayerController() ?
-            red_color : color, true, false);
-        kart_icon = kart->getKartProperties()->getIconMaterial()->getTexture();
-        source_rect = core::recti(core::vector2di(0, 0), kart_icon->getSize());
-        irr::u32 offset_x = (irr::u32)
-            (font->getDimension(result_text.c_str()).Width / 1.5f);
-        dest_rect = core::recti(current_x - offset_x - m_width_icon, current_y,
+        core::recti dest_rect = core::recti(current_x - offset_x - m_width_icon, current_y,
             current_x - offset_x, current_y + m_width_icon);
         draw2DImage(kart_icon, dest_rect, source_rect, NULL, NULL, true);
     }
 #endif
-} // displayCTFResults
+} // drawCTFScorers
 
 //-----------------------------------------------------------------------------
 void RaceResultGUI::unload()
@@ -1003,11 +964,12 @@ void RaceResultGUI::determineTableLayout()
     // The time the first phase is being displayed: add the start time
     // of the last kart to the duration of the scroll plus some time
     // of rest before the next phase starts
+    m_extra_scroll_time = 1.0f;
     m_time_overall_scroll = (num_karts - 1)*m_time_between_rows
-        + m_time_single_scroll + 2.0f;
+        + m_time_single_scroll + m_extra_scroll_time;
 
     // The time to increase the number of points.
-    m_time_for_points = 1.0f;
+    m_time_for_points = 2.0f;
 
     // Determine text height
     r = m_font->getDimension(L"Y");
@@ -1142,6 +1104,9 @@ void RaceResultGUI::renderGlobal(float dt)
     assert(World::getWorld()->getPhase() == WorldStatus::RESULT_DISPLAY_PHASE);
     unsigned int num_karts = (unsigned int)m_all_row_infos.size();
     float time_overall_scroll = m_time_overall_scroll;
+    // TODO after 1.5: Avoid the point increase being too slow for low point amounts
+    // float time_for_points = std::min(0.3f + 0.2f*m_most_points, m_time_for_points);
+    float time_for_points = m_time_for_points;
 
     // First: Update the finite state machine
     // ======================================
@@ -1161,7 +1126,7 @@ void RaceResultGUI::renderGlobal(float dt)
         // GP mode has a continue button so no extra time is needed
         if (RaceManager::get()->getMajorMode() ==
             RaceManager::MAJOR_MODE_GRAND_PRIX)
-            time_overall_scroll -= 2.0f;
+            time_overall_scroll -= m_extra_scroll_time;
         if (m_timer > time_overall_scroll)
         {
             // Make sure that all lines are aligned to the left
@@ -1210,7 +1175,7 @@ void RaceResultGUI::renderGlobal(float dt)
         break;
     case RR_INCREASE_POINTS:
         // Have one second delay before the resorting starts.
-        if (m_timer > 1 + m_time_for_points)
+        if (m_timer > 1 + time_for_points)
         {
             m_animation_state = RR_RESORT_TABLE;
             if (m_gp_position_was_changed)
@@ -1307,20 +1272,13 @@ void RaceResultGUI::renderGlobal(float dt)
             {
                 WorldWithRank *wwr = dynamic_cast<WorldWithRank*>(World::getWorld());
                 assert(wwr);
-                int most_points;
-                if (RaceManager::get()->isFollowMode())
-                    most_points = wwr->getScoreForPosition(2);
-                else
-                    most_points = wwr->getScoreForPosition(1);
-                ri->m_current_displayed_points +=
-                    dt*most_points / m_time_for_points;
+                ri->m_current_displayed_points += dt * m_most_points / time_for_points;
                 if (ri->m_current_displayed_points > ri->m_new_overall_points)
                 {
                     ri->m_current_displayed_points =
                         (float)ri->m_new_overall_points;
                 }
-                ri->m_new_points -=
-                    dt*most_points / m_time_for_points;
+                ri->m_new_points -= dt * m_most_points / time_for_points;
                 if (ri->m_new_points < 0)
                     ri->m_new_points = 0;
                 break;
@@ -1366,6 +1324,7 @@ void RaceResultGUI::determineGPLayout()
         max_time = std::max(RaceManager::get()->getOverallTime(kart_id), max_time);
     }
 
+    m_most_points = 0.;
     for (unsigned int kart_id = 0; kart_id < num_karts; kart_id++)
     {
         int rank = RaceManager::get()->getKartGPRank(kart_id);
@@ -1406,17 +1365,6 @@ void RaceResultGUI::determineGPLayout()
         ri->m_y_pos = (float)(m_top + rank*m_distance_between_rows);
         int p = RaceManager::get()->getKartPrevScore(kart_id);
         ri->m_current_displayed_points = (float)p;
-        if (kart->isEliminated() && !(RaceManager::get()->isFollowMode()))
-        {
-            ri->m_new_points = 0;
-        }
-        else
-        {
-            WorldWithRank *wwr = dynamic_cast<WorldWithRank*>(World::getWorld());
-            assert(wwr);
-            ri->m_new_points =
-                (float)wwr->getScoreForPosition(kart->getPosition());
-        }
     }
 
     // Now update the GP ranks, and determine the new position
@@ -1433,6 +1381,8 @@ void RaceResultGUI::determineGPLayout()
         ri->m_centre_point = m_top + (gp_position + j)*m_distance_between_rows*0.5f;
         int p = RaceManager::get()->getKartScore(i);
         ri->m_new_overall_points = p;
+        ri->m_new_points = ri->m_new_overall_points - ri->m_current_displayed_points;
+        m_most_points = std::max(m_most_points, ri->m_new_points);
         ri->m_new_gp_rank = gp_position;
         ri->m_laps = World::getWorld()->getFinishedLapsOfKart(i);
     }   // i < num_karts
diff --git a/src/states_screens/race_result_gui.hpp b/src/states_screens/race_result_gui.hpp
index 5aba04c346d..e6b3b2831df 100644
--- a/src/states_screens/race_result_gui.hpp
+++ b/src/states_screens/race_result_gui.hpp
@@ -134,6 +134,9 @@ class RaceResultGUI : public RaceGUIBase,
         This includes a small waiting time at the end. */
     float                      m_time_overall_scroll;
 
+    /** The small waiting time for the above. */
+    float                      m_extra_scroll_time;
+
     /** Distance between each row of the race results */
     unsigned int               m_distance_between_rows;
 
@@ -186,6 +189,9 @@ class RaceResultGUI : public RaceGUIBase,
     /** For highscores */
     int m_highscore_rank;
 
+    /** Maximum number of points earned by a player in this game (used in animation). */
+    float m_most_points;
+
     unsigned int m_width_all_points;
 
     int m_max_tracks;
@@ -210,6 +216,7 @@ class RaceResultGUI : public RaceGUIBase,
     int  displayLapDifficulty(int x, int y, bool increase_density);
     int  displayChallengeInfo(int x, int y, bool increase_density);
     void displayCTFResults();
+    void drawCTFScorers(KartTeam team, int x, int y, int height);
     void displaySoccerResults();
     void drawTeamScorers(KartTeam team, int x, int y, int height);
     void displayBenchmarkSummary();
diff --git a/src/tracks/track.cpp b/src/tracks/track.cpp
index 738037c2124..66a595c0c30 100644
--- a/src/tracks/track.cpp
+++ b/src/tracks/track.cpp
@@ -541,8 +541,8 @@ void Track::loadTrackInfo()
     m_sun_specular_color    = video::SColor(255, 255, 255, 255);
     m_sun_diffuse_color     = video::SColor(255, 255, 255, 255);
     m_sun_position          = core::vector3df(0, 10, 10);
-    irr_driver->setSSAORadius(1.);
-    irr_driver->setSSAOK(1.5);
+    irr_driver->setSSAORadius(0.5);
+    irr_driver->setSSAOK(3.);
     irr_driver->setSSAOSigma(1.);
     XMLNode *root           = file_manager->createXMLTree(m_filename);
 
diff --git a/src/utils/crash_reporting.cpp b/src/utils/crash_reporting.cpp
index cd1d4ebf5d6..3e34c9bced5 100644
--- a/src/utils/crash_reporting.cpp
+++ b/src/utils/crash_reporting.cpp
@@ -101,9 +101,9 @@
                 getCallStack(callstack);
 
             std::string msg =   "SuperTuxKart crashed!\n"
-                                "If you continue to encounter this issue, please hit Ctrl+C to copy this error\n"
-                                "to the clipboard and report the problem to the developers on our forum:\n"
-                                "http://forum.freegamedev.net/viewforum.php?f=17\n"
+                                "If you continue to encounter this issue, please hit Ctrl+C to copy this error "
+                                "to the clipboard and report the problem to the developers on our bug tracker:\n"
+                                "https://github.com/supertuxkart/stk-code/issues\n"
                                 "\n"
                                 "Call stack:\n";
             msg += callstack;

From 8f889d41882a0e460dae30eab83a0e173a45a66d Mon Sep 17 00:00:00 2001
From: bart <bart@bbun>
Date: Wed, 12 Feb 2025 17:41:57 +0100
Subject: [PATCH 3/9] changes to three strike battle

---
 src/karts/controller/spare_tire_ai.cpp | 17 ++++-------------
 1 file changed, 4 insertions(+), 13 deletions(-)

diff --git a/src/karts/controller/spare_tire_ai.cpp b/src/karts/controller/spare_tire_ai.cpp
index 09210fabc24..4d51d89ec03 100644
--- a/src/karts/controller/spare_tire_ai.cpp
+++ b/src/karts/controller/spare_tire_ai.cpp
@@ -142,20 +142,11 @@ void SpareTireAI::crashed(const AbstractKart *k)
     // Nothing happen when two spare tire karts crash each other
     if (dynamic_cast<const SpareTireAI*>(k->getController()) != NULL) return;
 
-    // Tell players that they can have at most 3 lives
+    // Add a life
     RaceGUIBase* r = World::getWorld()->getRaceGUI();
-    if (m_tsb_world->getKartLife(k->getWorldKartId()) == 3)
-    {
-        if (r)
-            r->addMessage(_("You can have at most 3 lives!"), k, 2.0f);
-    }
-    // Otherwise add one life for that kart 
-    else
-    {
-        m_tsb_world->addKartLife(k->getWorldKartId());
-        if (r)
-            r->addMessage(_("+1 life."), k, 2.0f);
-    }
+    m_tsb_world->addKartLife(k->getWorldKartId());
+    if (r)
+        r->addMessage(_("+1 life."), k, 2.0f);
     unspawn();
 
 }   // crashed

From 1fbd35546dedb8efebd16ad8f8fa390681a64d6b Mon Sep 17 00:00:00 2001
From: bart <bart@bbun>
Date: Wed, 12 Feb 2025 18:50:30 +0100
Subject: [PATCH 4/9] return accidentaly removed changes

---
 src/config/user_config.hpp               | 26 ++++++++++++++++--------
 src/modes/three_strikes_battle.cpp       | 11 +++++-----
 src/states_screens/track_info_screen.cpp |  2 +-
 3 files changed, 24 insertions(+), 15 deletions(-)

diff --git a/src/config/user_config.hpp b/src/config/user_config.hpp
index b08990f36b3..f2c0f874354 100644
--- a/src/config/user_config.hpp
+++ b/src/config/user_config.hpp
@@ -837,6 +837,10 @@ namespace UserConfigParams
 
     PARAM_PREFIX bool m_race_now          PARAM_DEFAULT( false );
 
+    PARAM_PREFIX int m_default_keyboard   PARAM_DEFAULT( -1 );
+
+    PARAM_PREFIX int m_default_gamepad    PARAM_DEFAULT( -1 );
+
     PARAM_PREFIX bool m_enforce_current_player PARAM_DEFAULT( false );
 
     PARAM_PREFIX bool m_enable_sound PARAM_DEFAULT( true );
@@ -1036,12 +1040,12 @@ namespace UserConfigParams
                         "Camera settings for player.") );
 
     PARAM_PREFIX FloatUserConfigParam         m_camera_distance
-            PARAM_DEFAULT(  FloatUserConfigParam(1.0, "distance",
+            PARAM_DEFAULT(  FloatUserConfigParam(2.8, "distance",
             &m_camera_normal,
             "Distance between kart and camera"));
 
     PARAM_PREFIX FloatUserConfigParam         m_camera_forward_up_angle
-            PARAM_DEFAULT(  FloatUserConfigParam(0, "forward-up-angle",
+            PARAM_DEFAULT(  FloatUserConfigParam(25, "forward-up-angle",
             &m_camera_normal,
             "Angle between camera and plane of kart (pitch) when the camera is pointing forward"));
 
@@ -1061,7 +1065,7 @@ namespace UserConfigParams
             "Angle between camera and plane of kart (pitch) when the camera is pointing backwards. This is usually larger than the forward-up-angle, since the kart itself otherwise obstricts too much of the view"));
 
     PARAM_PREFIX IntUserConfigParam         m_camera_fov
-            PARAM_DEFAULT(  IntUserConfigParam(80, "fov",
+            PARAM_DEFAULT(  IntUserConfigParam(85, "fov",
             &m_camera_normal,
             "Focal distance (single player)"));
 
@@ -1075,18 +1079,22 @@ namespace UserConfigParams
                             "The current used camera. 0=Custom; 1=Standard; 2=Drone chase") );
 
     // ---- Standard camera settings
+    PARAM_PREFIX BoolUserConfigParam       m_camera_updated_one_five
+            PARAM_DEFAULT(  BoolUserConfigParam(false, "camera-updated-one-five",
+                            "Used to update the standard camera values for users upgrading to 1.5") );
+
     PARAM_PREFIX GroupUserConfigParam        m_standard_camera_settings
             PARAM_DEFAULT( GroupUserConfigParam(
                         "standard-camera-settings",
                         "Standard camera settings for player.") );
 
     PARAM_PREFIX FloatUserConfigParam         m_standard_camera_distance
-            PARAM_DEFAULT(  FloatUserConfigParam(1.0, "distance",
+            PARAM_DEFAULT(  FloatUserConfigParam(2.8, "distance",
             &m_standard_camera_settings,
             "Distance between kart and camera"));
 
     PARAM_PREFIX FloatUserConfigParam         m_standard_camera_forward_up_angle
-            PARAM_DEFAULT(  FloatUserConfigParam(0, "forward-up-angle",
+            PARAM_DEFAULT(  FloatUserConfigParam(25, "forward-up-angle",
             &m_standard_camera_settings,
             "Angle between camera and plane of kart (pitch) when the camera is pointing forward"));
 
@@ -1106,7 +1114,7 @@ namespace UserConfigParams
             "Angle between camera and plane of kart (pitch) when the camera is pointing backwards. This is usually larger than the forward-up-angle, since the kart itself otherwise obstricts too much of the view"));
 
     PARAM_PREFIX IntUserConfigParam         m_standard_camera_fov
-            PARAM_DEFAULT(  IntUserConfigParam(80, "fov",
+            PARAM_DEFAULT(  IntUserConfigParam(85, "fov",
             &m_standard_camera_settings,
             "Focal distance (single player)"));
 
@@ -1163,12 +1171,12 @@ namespace UserConfigParams
                         "Saved custom camera settings for player.") );
 
     PARAM_PREFIX FloatUserConfigParam         m_saved_camera_distance
-            PARAM_DEFAULT(  FloatUserConfigParam(1.0, "distance",
+            PARAM_DEFAULT(  FloatUserConfigParam(2.8, "distance",
             &m_saved_camera_settings,
             "Distance between kart and camera"));
 
     PARAM_PREFIX FloatUserConfigParam         m_saved_camera_forward_up_angle
-            PARAM_DEFAULT(  FloatUserConfigParam(0, "forward-up-angle",
+            PARAM_DEFAULT(  FloatUserConfigParam(25, "forward-up-angle",
             &m_saved_camera_settings,
             "Angle between camera and plane of kart (pitch) when the camera is pointing forward"));
 
@@ -1188,7 +1196,7 @@ namespace UserConfigParams
             "Angle between camera and plane of kart (pitch) when the camera is pointing backwards. This is usually larger than the forward-up-angle, since the kart itself otherwise obstricts too much of the view"));
 
     PARAM_PREFIX IntUserConfigParam         m_saved_camera_fov
-            PARAM_DEFAULT(  IntUserConfigParam(80, "fov",
+            PARAM_DEFAULT(  IntUserConfigParam(85, "fov",
             &m_saved_camera_settings,
             "Focal distance (single player)"));
 
diff --git a/src/modes/three_strikes_battle.cpp b/src/modes/three_strikes_battle.cpp
index 521406c2bfe..09f65a6b288 100644
--- a/src/modes/three_strikes_battle.cpp
+++ b/src/modes/three_strikes_battle.cpp
@@ -46,8 +46,6 @@
 #include <string>
 #include <IMeshSceneNode.h>
 
-#include <iostream>
-
 //-----------------------------------------------------------------------------
 /** Constructor. Sets up the clock mode etc.
  */
@@ -120,8 +118,7 @@ void ThreeStrikesBattle::reset(bool restart)
         }
         else
         {
-            //m_kart_info[n].m_lives = RaceManager::get()->getTireAmount();
-            //m_kart_info[n].m_lives = 1;   
+            // Gets starting amount of lives straight from the config (please tell me if this is the best method)
             m_kart_info[n].m_lives = UserConfigParams::m_ffa_time_limit;         
         }
 
@@ -237,6 +234,7 @@ bool ThreeStrikesBattle::kartHit(int kart_id, int hitter)
     if (!UserConfigParams::m_arena_ai_stats)
     {
         m_kart_info[kart_id].m_lives--;
+        // Don't return the tire if 1. the checkbox says so or if 2. the kart hit itself or 3. if there is no hitter. That causes a crash otherwise.
         if (hitter != -1 && hitter != kart_id && UserConfigParams::m_tire_steal)
             m_kart_info[hitter].m_lives++;
     }  
@@ -528,7 +526,8 @@ void ThreeStrikesBattle::getKartsDisplayInfo(
     {
         RaceGUIBase::KartIconDisplayInfo& rank_info = (*info)[i];
 
-        // reset color
+        // Samples colours from a gradient at a regular interval. The colours get funky if it goes out of bound, i dont know why.        
+        
         rank_info.lap = -1;
         
         if (m_kart_info[i].m_lives == 0)
@@ -554,6 +553,8 @@ void ThreeStrikesBattle::getKartsDisplayInfo(
 std::pair<int, video::SColor> ThreeStrikesBattle::getSpeedometerDigit(
                                                 const AbstractKart *kart) const
 {
+    // Samples colours from a gradient at a regular interval. The colours get funky if it goes out of bound, i dont know why.
+        
     video::SColor color = video::SColor(255, 255, 255, 255);
     int id = kart->getWorldKartId();
     if (m_kart_info[id].m_lives == 0)
diff --git a/src/states_screens/track_info_screen.cpp b/src/states_screens/track_info_screen.cpp
index dcff8606eb3..949850fafee 100644
--- a/src/states_screens/track_info_screen.cpp
+++ b/src/states_screens/track_info_screen.cpp
@@ -297,7 +297,7 @@ void TrackInfoScreen::init()
         m_target_value_label->setText(_("Maximum time (min.)"), false);
         m_target_value_spinner->setValue(UserConfigParams::m_lap_trial_time_limit);
     }
-    // Reverse track or tire stealing and random item in arena
+    // Reverse track and random item in arena
     // -------------
     const bool reverse_available =     m_track->reverseAvailable()
                                    && !(RaceManager::get()->isEggHuntMode());

From d97cc0d02b5302b6affc332d4a838c9e5ec1af78 Mon Sep 17 00:00:00 2001
From: bart <bart@bbun>
Date: Thu, 13 Feb 2025 18:25:34 +0100
Subject: [PATCH 5/9] change according to review

---
 src/modes/three_strikes_battle.cpp       | 35 +++++++++++++++++++-----
 src/modes/three_strikes_battle.hpp       |  9 ------
 src/states_screens/track_info_screen.cpp | 12 ++++----
 3 files changed, 34 insertions(+), 22 deletions(-)

diff --git a/src/modes/three_strikes_battle.cpp b/src/modes/three_strikes_battle.cpp
index 09f65a6b288..4556f47d8cf 100644
--- a/src/modes/three_strikes_battle.cpp
+++ b/src/modes/three_strikes_battle.cpp
@@ -56,7 +56,7 @@ ThreeStrikesBattle::ThreeStrikesBattle() : WorldWithRank()
     m_insert_tire = 0;
 
     m_tire = irr_driver->getMesh(file_manager->getAsset(FileManager::MODEL,
-                                 "tire.spm") );
+                                "tire.spm") );
     irr_driver->grabAllTextures(m_tire);
 
     m_total_rescue = 0;
@@ -67,6 +67,27 @@ ThreeStrikesBattle::ThreeStrikesBattle() : WorldWithRank()
 
 }   // ThreeStrikesBattle
 
+namespace
+{
+    const int redGradient[12] = {30, 64, 255, 255, 255, 128, 0, 0, 0, 0, 0, 0};
+    // ------------------------------------------------------------------------
+    const int greenGradient[12] = {0, 0, 0, 128, 255, 255, 255, 128, 255, 128, 0, 0};
+    // ------------------------------------------------------------------------
+    const int blueGradient[12] = {0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 192, 64};
+    // ------------------------------------------------------------------------
+    /* Must be two lower than the actual length, the first and last items in the 
+     array are just buffers to prevent floating-point disasters */
+    const int gradientLength = 10;
+
+    video::SColor calculateColor(int lerp_index, float lerp_time)
+    {
+        int redVal = lerp(redGradient[lerp_index + 1], redGradient[lerp_index + 2], lerp_time);
+        int greenVal = lerp(greenGradient[lerp_index + 1], greenGradient[lerp_index + 2], lerp_time);
+        int blueVal = lerp(blueGradient[lerp_index + 1], blueGradient[lerp_index + 2], lerp_time);
+        return video::SColor(255, redVal, greenVal, blueVal);
+    }
+}
+
 //-----------------------------------------------------------------------------
 /** Initialises the three strikes battle. It sets up the data structure
  *  to keep track of points etc. for each kart.
@@ -102,9 +123,9 @@ void ThreeStrikesBattle::reset(bool restart)
     WorldWithRank::reset(restart);
     
     float next_spawn_time =
-        RaceManager::get()->getDifficulty() == RaceManager::DIFFICULTY_BEST ? 40.0f :
-        RaceManager::get()->getDifficulty() == RaceManager::DIFFICULTY_HARD ? 30.0f :
-        RaceManager::get()->getDifficulty() == RaceManager::DIFFICULTY_MEDIUM ?
+    RaceManager::get()->getDifficulty() == RaceManager::DIFFICULTY_BEST ? 40.0f :
+    RaceManager::get()->getDifficulty() == RaceManager::DIFFICULTY_HARD ? 30.0f :
+    RaceManager::get()->getDifficulty() == RaceManager::DIFFICULTY_MEDIUM ?
         25.0f : 20.0f;
     m_next_sta_spawn_ticks = stk_config->time2Ticks(next_spawn_time);
 
@@ -540,8 +561,8 @@ void ThreeStrikesBattle::getKartsDisplayInfo(
             lerp_time = float(m_kart_info[i].m_lives-1)/float(UserConfigParams::m_ffa_time_limit);
             int lerp_lower = floor(lerp_time*gradientLength);
     
-            rank_info.m_color = video::SColor(255, lerp(redGradient[lerp_lower+1],redGradient[lerp_lower+2],lerp_time*gradientLength-lerp_lower), lerp(greenGradient[lerp_lower+1],greenGradient[lerp_lower+2],lerp_time*gradientLength-lerp_lower), lerp(blueGradient[lerp_lower+1],blueGradient[lerp_lower+2],lerp_time*gradientLength-lerp_lower));
-    }
+            rank_info.m_color = calculateColor(lerp_lower, lerp_time * gradientLength - lerp_lower);
+        }
         std::ostringstream oss;
         oss << m_kart_info[i].m_lives;
 
@@ -567,7 +588,7 @@ std::pair<int, video::SColor> ThreeStrikesBattle::getSpeedometerDigit(
         lerp_time = float(m_kart_info[id].m_lives-1)/float(UserConfigParams::m_ffa_time_limit);
         int lerp_lower = floor(lerp_time*gradientLength);
     
-        color = video::SColor(255, lerp(redGradient[lerp_lower+1],redGradient[lerp_lower+2],lerp_time*gradientLength-lerp_lower), lerp(greenGradient[lerp_lower+1],greenGradient[lerp_lower+2],lerp_time*gradientLength-lerp_lower), lerp(blueGradient[lerp_lower+1],blueGradient[lerp_lower+2],lerp_time*gradientLength-lerp_lower));
+        color = color = calculateColor(lerp_lower, lerp_time * gradientLength - lerp_lower);
     }
     return std::make_pair(m_kart_info[id].m_lives, color);
 }   // getSpeedometerDigit
diff --git a/src/modes/three_strikes_battle.hpp b/src/modes/three_strikes_battle.hpp
index 5eddbb502e3..3a3dc7d0b0c 100644
--- a/src/modes/three_strikes_battle.hpp
+++ b/src/modes/three_strikes_battle.hpp
@@ -151,15 +151,6 @@ class ThreeStrikesBattle : public WorldWithRank
     // ------------------------------------------------------------------------
     void spawnSpareTireKarts();
     // ------------------------------------------------------------------------
-    const int redGradient[12] = {30, 64, 255, 255, 255, 128, 0, 0, 0, 0, 0, 0};
-    // ------------------------------------------------------------------------
-    const int greenGradient[12] = {0, 0, 0, 128, 255, 255, 255, 128, 255, 128, 0, 0};
-    // ------------------------------------------------------------------------
-    const int blueGradient[12] = {0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 192, 64};
-    // ------------------------------------------------------------------------
-    /* Must be two lower than the actual length, the first and last items in the 
-     array are just buffers to prevent floating-point disasters */
-    const int gradientLength = 10;
 
 };   // ThreeStrikesBattles
 
diff --git a/src/states_screens/track_info_screen.cpp b/src/states_screens/track_info_screen.cpp
index 949850fafee..fb3b12b779b 100644
--- a/src/states_screens/track_info_screen.cpp
+++ b/src/states_screens/track_info_screen.cpp
@@ -253,19 +253,19 @@ void TrackInfoScreen::init()
         m_target_type_label->setText(_("Game mode"), false);
         m_target_type_spinner->clearLabels();
         m_target_type_spinner->addLabel(_("3 Strikes Battle"));
-                
+        
         m_target_type_spinner->addLabel(_("Free-For-All"));
         m_target_type_spinner->setValue(UserConfigParams::m_use_ffa_mode ? 1 : 0);
         m_target_value_spinner->setValue(UserConfigParams::m_ffa_time_limit);
         if (UserConfigParams::m_use_ffa_mode)
             m_target_value_label->setText(_("Maximum time (min.)"), false);
             
-		else
-		    m_target_value_label->setText(_("Starting tires"), false);
+        else
+            m_target_value_label->setText(_("Starting tires"), false);
         
         m_tire_stealing->setVisible(!UserConfigParams::m_use_ffa_mode);
         getWidget<LabelWidget>("tire-stealing-text")->setVisible(!UserConfigParams::m_use_ffa_mode);
-		getWidget<LabelWidget>("tire-stealing-text")->setText(_("Steal tires"), false);
+        getWidget<LabelWidget>("tire-stealing-text")->setText(_("Steal tires"), false);
         m_tire_stealing->setState(UserConfigParams::m_tire_steal);
 
         m_target_value_label->setVisible(true);
@@ -681,8 +681,8 @@ void TrackInfoScreen::eventCallback(Widget* widget, const std::string& name,
 
             if (enable_ffa)
                 m_target_value_label->setText(_("Maximum time (min.)"), false);
-		    else
-		        m_target_value_label->setText(_("Starting tires"), false);
+            else
+                m_target_value_label->setText(_("Starting tires"), false);
         }
     }
     else if (name == "target-value-spinner")

From 05eed49ebe8143697280f3c623ac754390c506d5 Mon Sep 17 00:00:00 2001
From: bart <bart@bbun>
Date: Fri, 14 Feb 2025 10:24:04 +0100
Subject: [PATCH 6/9] bugfixes and lighter gradient

---
 src/karts/controller/spare_tire_ai.cpp | 16 +++++++++++---
 src/modes/three_strikes_battle.cpp     | 30 ++++++++++++++------------
 2 files changed, 29 insertions(+), 17 deletions(-)

diff --git a/src/karts/controller/spare_tire_ai.cpp b/src/karts/controller/spare_tire_ai.cpp
index 4d51d89ec03..d488a98410d 100644
--- a/src/karts/controller/spare_tire_ai.cpp
+++ b/src/karts/controller/spare_tire_ai.cpp
@@ -18,6 +18,7 @@
 
 #include "karts/controller/spare_tire_ai.hpp"
 
+#include "config/user_config.hpp"
 #include "karts/abstract_kart.hpp"
 #include "karts/kart_gfx.hpp"
 #include "karts/max_speed.hpp"
@@ -144,9 +145,18 @@ void SpareTireAI::crashed(const AbstractKart *k)
 
     // Add a life
     RaceGUIBase* r = World::getWorld()->getRaceGUI();
-    m_tsb_world->addKartLife(k->getWorldKartId());
-    if (r)
-        r->addMessage(_("+1 life."), k, 2.0f);
+    if (m_tsb_world->getKartLife(k->getWorldKartId()) == UserConfigParams::m_ffa_time_limit && !UserConfigParams::m_tire_steal)
+    {
+        if (r)
+            r->addMessage(_("You can't go over the starting amount!"), k, 2.0f);
+    }
+    // Otherwise add one life for that kart 
+    else
+    {
+        m_tsb_world->addKartLife(k->getWorldKartId());
+        if (r)
+            r->addMessage(_("+1 life."), k, 2.0f);
+    }
     unspawn();
 
 }   // crashed
diff --git a/src/modes/three_strikes_battle.cpp b/src/modes/three_strikes_battle.cpp
index 4556f47d8cf..9dff6412997 100644
--- a/src/modes/three_strikes_battle.cpp
+++ b/src/modes/three_strikes_battle.cpp
@@ -69,21 +69,22 @@ ThreeStrikesBattle::ThreeStrikesBattle() : WorldWithRank()
 
 namespace
 {
-    const int redGradient[12] = {30, 64, 255, 255, 255, 128, 0, 0, 0, 0, 0, 0};
+    const int redGradient[12] =   {200,   255,   255,   255,   128,   0,     0,     0,     0,     0,    192,   200};
     // ------------------------------------------------------------------------
-    const int greenGradient[12] = {0, 0, 0, 128, 255, 255, 255, 128, 255, 128, 0, 0};
+    const int greenGradient[12] = {0,     100,   200,   255,   255,   255,   128,   255,   128,   0,    0,     0};
     // ------------------------------------------------------------------------
-    const int blueGradient[12] = {0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 192, 64};
+    const int blueGradient[12] =  {0,     0,     0,     0,     0,     0,     0,     255,   255,   192,  192,   0};
     // ------------------------------------------------------------------------
-    /* Must be two lower than the actual length, the first and last items in the 
-     array are just buffers to prevent floating-point disasters */
-    const int gradientLength = 10;
+    /* Must be 3 lower than the length of the array so it doesn't 
+    and so that it connects once you get more lives than the starting amount.
+    The first and last items in the array must be the same.*/
+    const int gradientLength = 9;
 
     video::SColor calculateColor(int lerp_index, float lerp_time)
     {
-        int redVal = lerp(redGradient[lerp_index + 1], redGradient[lerp_index + 2], lerp_time);
-        int greenVal = lerp(greenGradient[lerp_index + 1], greenGradient[lerp_index + 2], lerp_time);
-        int blueVal = lerp(blueGradient[lerp_index + 1], blueGradient[lerp_index + 2], lerp_time);
+        int redVal = lerp(redGradient[lerp_index], redGradient[lerp_index + 1], lerp_time);
+        int greenVal = lerp(greenGradient[lerp_index], greenGradient[lerp_index + 1], lerp_time);
+        int blueVal = lerp(blueGradient[lerp_index], blueGradient[lerp_index + 1], lerp_time);
         return video::SColor(255, redVal, greenVal, blueVal);
     }
 }
@@ -154,11 +155,11 @@ void ThreeStrikesBattle::reset(bool restart)
 
             if (core::stringc(curr->getName()) == "tire1")
             {
-                curr->setVisible(true);
+                curr->setVisible(UserConfigParams::m_ffa_time_limit >= 3);
             }
             else if (core::stringc(curr->getName()) == "tire2")
             {
-                curr->setVisible(true);
+                curr->setVisible(UserConfigParams::m_ffa_time_limit >= 2);
             }
         }
 
@@ -257,7 +258,8 @@ bool ThreeStrikesBattle::kartHit(int kart_id, int hitter)
         m_kart_info[kart_id].m_lives--;
         // Don't return the tire if 1. the checkbox says so or if 2. the kart hit itself or 3. if there is no hitter. That causes a crash otherwise.
         if (hitter != -1 && hitter != kart_id && UserConfigParams::m_tire_steal)
-            m_kart_info[hitter].m_lives++;
+            addKartLife(hitter);
+
     }  
     else
     {
@@ -561,7 +563,7 @@ void ThreeStrikesBattle::getKartsDisplayInfo(
             lerp_time = float(m_kart_info[i].m_lives-1)/float(UserConfigParams::m_ffa_time_limit);
             int lerp_lower = floor(lerp_time*gradientLength);
     
-            rank_info.m_color = calculateColor(lerp_lower, lerp_time * gradientLength - lerp_lower);
+            rank_info.m_color = calculateColor(lerp_lower % (gradientLength + 2), lerp_time * gradientLength - lerp_lower);
         }
         std::ostringstream oss;
         oss << m_kart_info[i].m_lives;
@@ -588,7 +590,7 @@ std::pair<int, video::SColor> ThreeStrikesBattle::getSpeedometerDigit(
         lerp_time = float(m_kart_info[id].m_lives-1)/float(UserConfigParams::m_ffa_time_limit);
         int lerp_lower = floor(lerp_time*gradientLength);
     
-        color = color = calculateColor(lerp_lower, lerp_time * gradientLength - lerp_lower);
+        color = color = calculateColor(lerp_lower % (gradientLength + 2), lerp_time * gradientLength - lerp_lower);
     }
     return std::make_pair(m_kart_info[id].m_lives, color);
 }   // getSpeedometerDigit

From ff55392dbeddbe3e07b6700cfcd7f1433b9f64a8 Mon Sep 17 00:00:00 2001
From: bart <bart@bbun>
Date: Sat, 15 Feb 2025 12:43:50 +0100
Subject: [PATCH 7/9] better gradient function and hopefully final changes

---
 src/karts/controller/spare_tire_ai.cpp |  2 +-
 src/modes/three_strikes_battle.cpp     | 47 ++++++++++++--------------
 2 files changed, 23 insertions(+), 26 deletions(-)

diff --git a/src/karts/controller/spare_tire_ai.cpp b/src/karts/controller/spare_tire_ai.cpp
index d488a98410d..21c0381525e 100644
--- a/src/karts/controller/spare_tire_ai.cpp
+++ b/src/karts/controller/spare_tire_ai.cpp
@@ -148,7 +148,7 @@ void SpareTireAI::crashed(const AbstractKart *k)
     if (m_tsb_world->getKartLife(k->getWorldKartId()) == UserConfigParams::m_ffa_time_limit && !UserConfigParams::m_tire_steal)
     {
         if (r)
-            r->addMessage(_("You can't go over the starting amount!"), k, 2.0f);
+            r->addMessage(_("You can have at most %d lives!"), k, 2.0f);
     }
     // Otherwise add one life for that kart 
     else
diff --git a/src/modes/three_strikes_battle.cpp b/src/modes/three_strikes_battle.cpp
index 9dff6412997..622927a0be1 100644
--- a/src/modes/three_strikes_battle.cpp
+++ b/src/modes/three_strikes_battle.cpp
@@ -69,26 +69,31 @@ ThreeStrikesBattle::ThreeStrikesBattle() : WorldWithRank()
 
 namespace
 {
-    const int redGradient[12] =   {200,   255,   255,   255,   128,   0,     0,     0,     0,     0,    192,   200};
+    const int gradientLength = 9;
+    
+    const int redGradient[gradientLength + 3] =   {200,   255,   255,   255,   128,   0,     0,     0,     0,     0,    192,   200};
     // ------------------------------------------------------------------------
-    const int greenGradient[12] = {0,     100,   200,   255,   255,   255,   128,   255,   128,   0,    0,     0};
+    const int greenGradient[gradientLength + 3] = {0,     100,   200,   255,   255,   255,   128,   255,   128,   0,    0,     0};
     // ------------------------------------------------------------------------
-    const int blueGradient[12] =  {0,     0,     0,     0,     0,     0,     0,     255,   255,   192,  192,   0};
+    const int blueGradient[gradientLength + 3] =  {0,     0,     0,     0,     0,     0,     0,     255,   255,   192,  192,   0};
     // ------------------------------------------------------------------------
-    /* Must be 3 lower than the length of the array so it doesn't 
-    and so that it connects once you get more lives than the starting amount.
-    The first and last items in the array must be the same.*/
-    const int gradientLength = 9;
 
-    video::SColor calculateColor(int lerp_index, float lerp_time)
+    video::SColor calculateColor(int current_lives, int starting_lives)
     {
-        int redVal = lerp(redGradient[lerp_index], redGradient[lerp_index + 1], lerp_time);
-        int greenVal = lerp(greenGradient[lerp_index], greenGradient[lerp_index + 1], lerp_time);
-        int blueVal = lerp(blueGradient[lerp_index], blueGradient[lerp_index + 1], lerp_time);
-        return video::SColor(255, redVal, greenVal, blueVal);
+        float lerp_time;
+        lerp_time = float(current_lives - 1)/float(starting_lives);
+        int lerp_index = floor(lerp_time*gradientLength);
+        lerp_index = lerp_index % (gradientLength + 2);
+        lerp_time = lerp_time * gradientLength - lerp_index;
+
+        auto channelBrightness = [lerp_time, lerp_index](const int* gradient)
+        {
+            return lerp(gradient[lerp_index], gradient[lerp_index + 1], lerp_time);
+        };
+
+        return video::SColor(255, channelBrightness(redGradient), channelBrightness(greenGradient), channelBrightness(blueGradient));
     }
 }
-
 //-----------------------------------------------------------------------------
 /** Initialises the three strikes battle. It sets up the data structure
  *  to keep track of points etc. for each kart.
@@ -558,12 +563,8 @@ void ThreeStrikesBattle::getKartsDisplayInfo(
             rank_info.m_color = video::SColor(128,128,128,0);
         }
         else
-        {
-            float lerp_time;
-            lerp_time = float(m_kart_info[i].m_lives-1)/float(UserConfigParams::m_ffa_time_limit);
-            int lerp_lower = floor(lerp_time*gradientLength);
-    
-            rank_info.m_color = calculateColor(lerp_lower % (gradientLength + 2), lerp_time * gradientLength - lerp_lower);
+        {    
+            rank_info.m_color = calculateColor(m_kart_info[i].m_lives, UserConfigParams::m_ffa_time_limit);
         }
         std::ostringstream oss;
         oss << m_kart_info[i].m_lives;
@@ -585,12 +586,8 @@ std::pair<int, video::SColor> ThreeStrikesBattle::getSpeedometerDigit(
         color = video::SColor(128,128,128,0);
     }
     else
-    {
-        float lerp_time;
-        lerp_time = float(m_kart_info[id].m_lives-1)/float(UserConfigParams::m_ffa_time_limit);
-        int lerp_lower = floor(lerp_time*gradientLength);
-    
-        color = color = calculateColor(lerp_lower % (gradientLength + 2), lerp_time * gradientLength - lerp_lower);
+    { 
+        color = calculateColor(m_kart_info[id].m_lives, UserConfigParams::m_ffa_time_limit);
     }
     return std::make_pair(m_kart_info[id].m_lives, color);
 }   // getSpeedometerDigit

From 198b5951a0072cc5a5b9518d9d0a7b015f36fa2e Mon Sep 17 00:00:00 2001
From: bart <bart@bbun>
Date: Sat, 15 Feb 2025 13:11:31 +0100
Subject: [PATCH 8/9] gradient bugfix

---
 src/modes/three_strikes_battle.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/modes/three_strikes_battle.cpp b/src/modes/three_strikes_battle.cpp
index 622927a0be1..ac9aea61e7c 100644
--- a/src/modes/three_strikes_battle.cpp
+++ b/src/modes/three_strikes_battle.cpp
@@ -83,8 +83,8 @@ namespace
         float lerp_time;
         lerp_time = float(current_lives - 1)/float(starting_lives);
         int lerp_index = floor(lerp_time*gradientLength);
-        lerp_index = lerp_index % (gradientLength + 2);
         lerp_time = lerp_time * gradientLength - lerp_index;
+        lerp_index = lerp_index % (gradientLength + 2);
 
         auto channelBrightness = [lerp_time, lerp_index](const int* gradient)
         {

From 55a3481c59e19068337839f1476b0660344e16de Mon Sep 17 00:00:00 2001
From: bart <bart@bbun>
Date: Sat, 15 Feb 2025 15:55:37 +0100
Subject: [PATCH 9/9] 0 life color fix

---
 src/modes/three_strikes_battle.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/modes/three_strikes_battle.cpp b/src/modes/three_strikes_battle.cpp
index ac9aea61e7c..86412044d7f 100644
--- a/src/modes/three_strikes_battle.cpp
+++ b/src/modes/three_strikes_battle.cpp
@@ -560,7 +560,7 @@ void ThreeStrikesBattle::getKartsDisplayInfo(
         
         if (m_kart_info[i].m_lives == 0)
         {
-            rank_info.m_color = video::SColor(128,128,128,0);
+            rank_info.m_color = video::SColor(255,128,128,128);
         }
         else
         {    
@@ -583,7 +583,7 @@ std::pair<int, video::SColor> ThreeStrikesBattle::getSpeedometerDigit(
     int id = kart->getWorldKartId();
     if (m_kart_info[id].m_lives == 0)
     {
-        color = video::SColor(128,128,128,0);
+        color = video::SColor(255,128,128,128);
     }
     else
     {