only one saved GP per GP-ident

Conflicts:
	src/graphics/glwrap.cpp

src/config/saved_grand_prix.cpp

@@ -143,15 +143,13 @@ void SavedGrandPrix::setKarts(const std::vector<RaceManager::KartStatus> &kart_l
 //------------------------------------------------------------------------------
 void SavedGrandPrix::loadKarts(std::vector<RaceManager::KartStatus> & kart_list)
 {
-    //Fix aikarts
     int aikarts = 0;
     for(unsigned int i = 0; i < m_karts.size(); i++)
     {
         const KartProperties *kp = kart_properties_manager->getKart(m_karts[i].m_ident);
 
-        if(m_karts[i].m_local_player_id == -1)
+        if(m_karts[i].m_local_player_id == -1) // AI kart
         {
-            //AI kart found
             if(kp) kart_list[aikarts].m_ident = m_karts[i].m_ident;
             kart_list[aikarts].m_score        = m_karts[i].m_score;
             kart_list[aikarts].m_overall_time = m_karts[i].m_overall_time;

src/config/saved_grand_prix.hpp

@@ -135,25 +135,19 @@ public:
 
     // ------------------------------------------------------------------------
     /** Finds the right SavedGrandPrix given the specified data, or
-     *  NULL if no matching GP was found.
+     *  NULL if no matching GP was found. */
-     */
     static SavedGrandPrix* getSavedGP(unsigned int player,
                                       const std::string &gpid,
-                                int difficulty, int total_karts,
+                                      const unsigned int number_of_players)
-                                int player_karts)
     {
         for (unsigned int n=0; n<UserConfigParams::m_saved_grand_prix_list.size(); n++)
         {
             SavedGrandPrix* gp = &UserConfigParams::m_saved_grand_prix_list[n];
-
+            if (gp->getGPID()        == gpid   &&
-            if ((gp->getGPID()       == gpid) &&
+                gp->getPlayerID()    == player &&
-                (gp->getPlayerID()    ==  player) &&
+                gp->getPlayerKarts() == (int)number_of_players)
-                (gp->getDifficulty()  == difficulty) &&
-                (gp->getTotalKarts()  == total_karts) &&
-                (gp->getPlayerKarts() == player_karts)){
                 return gp;
-            }   // if
+        }
-        }   // for n
         return NULL;
     }   // getSavedGP
     // ------------------------------------------------------------------------

src/race/race_manager.cpp

@@ -279,6 +279,7 @@ void RaceManager::computeRandomKartList()
 void RaceManager::startNew(bool from_overworld)
 {
     m_started_from_overworld = from_overworld;
+    m_saved_gp = NULL; // There will be checks for this being NULL done later
 
     if (m_major_mode==MAJOR_MODE_GRAND_PRIX)
     {
@@ -286,8 +287,30 @@ void RaceManager::startNew(bool from_overworld)
         m_tracks        = m_grand_prix.getTrackNames();
         m_num_laps      = m_grand_prix.getLaps();
         m_reverse_track = m_grand_prix.getReverse();
+
+        // Saved GP only in offline mode
+        if (m_continue_saved_gp && !NetworkWorld::getInstance<NetworkWorld>()->isRunning())
+        {
+            // We look if Player 1 has a saved version of this GP.
+            m_saved_gp = SavedGrandPrix::getSavedGP(
+                                         StateManager::get()
+                                         ->getActivePlayerProfile(0)
+                                         ->getUniqueID(),
+                                         m_grand_prix.getId(),
+                                         m_player_karts.size());
+
+            if (m_saved_gp == NULL)
+            {
+                Log::error("Race Manager", "Can not continue Grand Prix '%s'"
+                                           "because it could not exist",
+                                           m_grand_prix.getId().c_str());
+                m_continue_saved_gp = false; // simple and working
+            } else {
+                setNumKarts(m_saved_gp->getTotalKarts());
+                setupPlayerKartInfo();
+            }
+        }
     }
-    //assert(m_player_karts.size() > 0);
 
     // command line parameters: negative numbers=all karts
     if(m_num_karts < 0 ) m_num_karts = stk_config->m_max_karts;
@@ -308,7 +331,7 @@ void RaceManager::startNew(bool from_overworld)
         race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER
         ? -1
         : 0;
-    const unsigned int ai_kart_count = (unsigned int) m_ai_kart_list.size();
+    const unsigned int ai_kart_count = m_ai_kart_list.size();
     for(unsigned int i = 0; i < ai_kart_count; i++)
     {
         m_kart_status.push_back(KartStatus(m_ai_kart_list[i], i, -1, -1,
@@ -323,7 +346,7 @@ void RaceManager::startNew(bool from_overworld)
 
     // Then the players, which start behind the AI karts
     // -------------------------------------------------
-    for(unsigned int i=0; i<(unsigned int)m_player_karts.size(); i++)
+    for(unsigned int i = 0; i < m_player_karts.size(); i++)
     {
         KartType kt= m_player_karts[i].isNetworkPlayer() ? KT_NETWORK_PLAYER : KT_PLAYER;
         m_kart_status.push_back(KartStatus(m_player_karts[i].getKartName(), i,
@@ -339,35 +362,20 @@ void RaceManager::startNew(bool from_overworld)
         init_gp_rank ++;
     }
 
-    m_track_number = 0;
+    if (MAJOR_MODE_GRAND_PRIX)
-    if(m_major_mode==MAJOR_MODE_GRAND_PRIX &&
-        !NetworkWorld::getInstance<NetworkWorld>()->isRunning()) // offline mode only
-    {
-        //We look if Player 1 has a saved version of this GP.
-        // =================================================
-        SavedGrandPrix* gp = SavedGrandPrix::getSavedGP( StateManager::get()
-                                                         ->getActivePlayerProfile(0)
-                                                         ->getUniqueID(),
-                                                         m_grand_prix.getId(),
-                                                         m_difficulty,
-                                                         m_num_karts,
-                                                         (int)m_player_karts.size());
-
-        // Start the race with the appropriate track
-        // =========================================
-        if(gp != NULL)
     {
         if (m_continue_saved_gp)
         {
-                m_track_number = gp->getNextTrack();
+            m_track_number  = m_saved_gp->getNextTrack();
-                gp->loadKarts(m_kart_status);
+            m_saved_gp->loadKarts(m_kart_status);
         }
         else
         {
-                gp->remove();
+            m_track_number = 0;
-            }
+            m_saved_gp->remove();
         }
     }
+
     startNextRace();
 }   // startNew
 
@@ -494,24 +502,15 @@ void RaceManager::next()
         if(m_major_mode==MAJOR_MODE_GRAND_PRIX && !NetworkWorld::getInstance()->isRunning())
         {
             // Saving GP state
-            //We look if Player 1 has already saved this GP.
+            // If Player 1 has already saved a GP, we adapt it
-            SavedGrandPrix* gp =
+            if(m_saved_gp != NULL)
-                SavedGrandPrix::getSavedGP(StateManager::get()
-                                           ->getActivePlayerProfile(0)
-                                           ->getUniqueID(),
-                                           m_grand_prix.getId(),
-                                           m_difficulty,
-                                           m_num_karts,
-                                           (int)m_player_karts.size());
-            if(gp != NULL)
             {
-                //if so addept it
+                m_saved_gp->setKarts(m_kart_status);
-                gp->setKarts(m_kart_status);
+                m_saved_gp->setNextTrack(m_track_number);
-                gp->setNextTrack(m_track_number);
             }
             else
             {
-                //create a new entry
+                // Otherwise we create a new entry
                 UserConfigParams::m_saved_grand_prix_list.push_back(
                     new SavedGrandPrix(
                         StateManager::get()->getActivePlayerProfile(0)
@@ -630,16 +629,8 @@ void RaceManager::exitRace(bool delete_world)
         PlayerManager::getCurrentPlayer()->grandPrixFinished();
         if(m_major_mode==MAJOR_MODE_GRAND_PRIX&& !NetworkWorld::getInstance()->isRunning())
         {
-            //Delete saved GP
+            if(m_saved_gp != NULL)
-            SavedGrandPrix* gp =
+                m_saved_gp->remove();
-                SavedGrandPrix::getSavedGP(StateManager::get()
-                                           ->getActivePlayerProfile(0)
-                                           ->getUniqueID(),
-                                           m_grand_prix.getId(),
-                                           m_difficulty,
-                                           m_num_karts,
-                                           (int)m_player_karts.size());
-            if(gp != NULL) gp->remove();
         }
         StateManager::get()->resetAndGoToScreen( MainMenuScreen::getInstance() );
 
@@ -717,6 +708,7 @@ void RaceManager::exitRace(bool delete_world)
 
     if (delete_world) World::deleteWorld();
 
+    m_saved_gp = NULL;
     m_track_number = 0;
 }   // exitRace
 
@@ -766,7 +758,6 @@ void RaceManager::startGP(const GrandPrixData &gp, bool from_overworld,
 {
     StateManager::get()->enterGameState();
     setGrandPrix(gp);
-    setCoinTarget( 0 ); // Might still be set from a previous challenge
     race_manager->setupPlayerKartInfo();
     m_continue_saved_gp = continue_saved_gp;
 

src/race/race_manager.hpp

@@ -36,6 +36,7 @@
 #include "utils/vec3.hpp"
 
 class AbstractKart;
+class SavedGrandPrix;
 class Track;
 
 static const std::string IDENT_STD      ("STANDARD"        );
@@ -326,6 +327,7 @@ private:
     std::vector<std::string>         m_ai_kart_list;
     int                              m_track_number;
     GrandPrixData                    m_grand_prix;
+    SavedGrandPrix*                  m_saved_gp;
     int                              m_num_karts;
     unsigned int                     m_num_finished_karts;
     unsigned int                     m_num_finished_players;
@@ -410,11 +412,13 @@ public:
       */
     void setDifficulty(Difficulty diff);
 
+    // ------------------------------------------------------------------------
+    void setCoinTarget(int num)   { m_coin_target = num;        }
     // ------------------------------------------------------------------------
     void setGrandPrix(const GrandPrixData &gp)
     {
         m_grand_prix = gp;
-        m_coin_target = 0;
+        setCoinTarget(0);
     }
     // ------------------------------------------------------------------------
     void setAIKartOverride(const std::string& kart)
@@ -453,8 +457,6 @@ public:
         m_ai_superpower = SUPERPOWER_NONE;
     }
     // ------------------------------------------------------------------------
-    void setCoinTarget(int num)   { m_coin_target = num;        }
-    // ------------------------------------------------------------------------
     void setTimeTarget(float num) { m_has_time_target = true;
                                     m_time_target = num;        }
     /** \} */

src/states_screens/dialogs/gp_info_dialog.cpp

@@ -203,8 +203,6 @@ void GPInfoDialog::addButtons()
                                                ->getActivePlayerProfile(0)
                                                ->getUniqueID(),
                                                m_gp.getId(),
-                                               race_manager->getDifficulty(),
-                                               race_manager->getNumberOfKarts(),
                                                race_manager->getNumLocalPlayers());
 
     okBtn->m_properties[PROP_ID] = "start";

src/states_screens/gp_info_screen.cpp

@@ -130,8 +130,6 @@ void GPInfoScreen::beforeAddingWidget()
         SavedGrandPrix* saved_gp = SavedGrandPrix::getSavedGP(
             StateManager::get()->getActivePlayerProfile(0)->getUniqueID(),
             m_gp.getId(),
-            race_manager->getDifficulty(),
-            race_manager->getNumberOfKarts(),
             race_manager->getNumLocalPlayers());
 
         RibbonWidget* ribbonButtons = getWidget<RibbonWidget>("buttons");