Fixed crash at the end of a GP if there is a challenge associated to it. Also, it is now detected properly when you unlock a feature by winnign a GP (however the chest scene doesn't yet apepar)

git-svn-id: svn+ssh://svn.code.sf.net/p/supertuxkart/code/main/trunk@4954 178a84e3-b1eb-0310-8ba1-8eac791a3b58

src/challenges/challenge_data.cpp

@@ -323,10 +323,13 @@ bool ChallengeData::grandPrixFinished()
         race_manager->getNumPlayers() > 1) return false;
 
     // check if the player came first.
-    Kart* kart = World::getWorld()->getPlayerKart(0);
+    //assert(World::getWorld() != NULL);
-    const int rank = race_manager->getKartFinalGPRank(kart->getWorldKartId());
+    // Kart* kart = World::getWorld()->getPlayerKart(0);
+    //const int rank = race_manager->getKartGPRank(kart->getWorldKartId());
+    const int rank = race_manager->getLocalPlayerGPRank(0);
+    
     //printf("getting rank for %s : %i \n", kart->getName().c_str(), rank );
-    if( rank != 0 ) return false;
+    if (rank != 0) return false;
 
     return true;
 }   // grandPrixFinished

src/challenges/unlock_manager.cpp

@@ -340,8 +340,9 @@ void UnlockManager::grandPrixFinished()
     for(AllChallengesType::iterator i =m_all_challenges.begin(); 
                                     i!=m_all_challenges.end();  i++)
     {
-        if(i->second->isActive() &&i->second->grandPrixFinished())
+        if(i->second->isActive() && i->second->grandPrixFinished())
         {
+            std::cout << "===== A FEATURE WAS UNLOCKED BECAUSE YOU WON THE GP!! ==\n";
             unlockFeature(i->second);
         }
     }

src/ide/Xcode/STK_XCode.xcodeproj/project.pbxproj

@@ -2617,7 +2617,9 @@
 				GCC_PREFIX_HEADER = "";
 				GCC_VERSION = 4.0;
 				GCC_WARN_ABOUT_MISSING_NEWLINE = YES;
+				GCC_WARN_MISSING_PARENTHESES = YES;
 				GCC_WARN_NON_VIRTUAL_DESTRUCTOR = YES;
+				GCC_WARN_SHADOW = NO;
 				GCC_WARN_UNUSED_FUNCTION = NO;
 				GCC_WARN_UNUSED_PARAMETER = NO;
 				HEADER_SEARCH_PATHS = "$(inherited)";
@@ -2654,7 +2656,9 @@
 				GCC_PREFIX_HEADER = "";
 				GCC_VERSION = 4.0;
 				GCC_WARN_ABOUT_MISSING_NEWLINE = YES;
+				GCC_WARN_MISSING_PARENTHESES = YES;
 				GCC_WARN_NON_VIRTUAL_DESTRUCTOR = YES;
+				GCC_WARN_SHADOW = NO;
 				GCC_WARN_UNUSED_FUNCTION = NO;
 				GCC_WARN_UNUSED_PARAMETER = NO;
 				HEADER_SEARCH_PATHS = "$(inherited)";

src/race/race_manager.cpp

@@ -90,13 +90,28 @@ void RaceManager::setPlayerKart(unsigned int player_id, const RemoteKartInfo& ki
  */
 void RaceManager::setLocalKartInfo(unsigned int player_id, const std::string& kart)
 {
-    assert(0<=player_id && player_id <m_local_kart_info.size());
+    assert(0<=player_id && player_id <m_local_player_karts.size());
 
-    m_local_kart_info[player_id] = RemoteKartInfo(player_id, kart,
+    m_local_player_karts[player_id] = RemoteKartInfo(player_id, kart,
                                                   StateManager::get()->getActivePlayerProfile(player_id)->getName(),
                                                   network_manager->getMyHostId());
 }   // setLocalKartInfo
 
+//-----------------------------------------------------------------------------
+
+int RaceManager::getLocalPlayerGPRank(const int playerID) const
+{
+    const int amount = m_kart_status.size();
+    for (int n=0; n<amount; n++)
+    {
+        if (m_kart_status[n].m_local_player_id == playerID)
+        {
+            return m_kart_status[n].m_gp_rank;
+        }
+    }
+    return -1;
+}
+
 //-----------------------------------------------------------------------------
 /** Sets the number of local players playing on this computer (including
  *  split screen).
@@ -104,7 +119,7 @@ void RaceManager::setLocalKartInfo(unsigned int player_id, const std::string& ka
  */
 void RaceManager::setNumLocalPlayers(unsigned int n)
 {
-    m_local_kart_info.resize(n);
+    m_local_player_karts.resize(n);
 }   // setNumLocalPlayers
 
 //-----------------------------------------------------------------------------
@@ -294,6 +309,77 @@ void RaceManager::next()
     }
 }   // next
 
+//-----------------------------------------------------------------------------
+/**
+  * Sets/updates the m_gp_rank status of each KartStatus object
+  */
+void RaceManager::computeGPRanks()
+{
+    // calculate the rank of each kart
+    const unsigned int NUM_KARTS = getNumberOfKarts();
+    
+    int *scores   = new int[NUM_KARTS];
+    int *position = new int[NUM_KARTS];
+    double *race_time = new double[NUM_KARTS];
+    // Ignore the first kart if it's a follow-the-leader race.
+    int start=(race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER) ? 1 : 0;
+    for (unsigned int kart_id = start; kart_id < NUM_KARTS; ++kart_id)
+    {
+        position[kart_id]  = kart_id;
+        scores[kart_id]    = race_manager->getKartScore(kart_id);
+        race_time[kart_id] = race_manager->getOverallTime(kart_id);
+    }
+    
+    if (race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER)
+    {
+        // fill values for leader
+        position[0]  = -1;
+        scores[0]    = -1;
+        race_time[0] = -1; 
+        m_kart_status[0].m_gp_rank = -1;
+    }
+    
+    //Bubblesort
+    bool sorted;
+    do
+    {
+        sorted = true;
+        for( unsigned int i = start; i < NUM_KARTS - 1; ++i )
+        {
+            if( scores[i] < scores[i+1] || (scores[i] == scores[i+1] 
+                                            && race_time[i] > race_time[i+1]))
+            {
+                int tmp_score[2];
+                double tmp_time;
+                
+                tmp_score[0] = position[i];
+                tmp_score[1] = scores[i];
+                tmp_time = race_time[i];
+                
+                position[i] = position[i+1];
+                scores[i] = scores[i+1];
+                race_time[i] = race_time[i+1];
+                
+                position[i+1] = tmp_score[0];
+                scores[i+1] = tmp_score[1];
+                race_time[i+1] = tmp_time;
+                
+                sorted = false;
+            }
+        }
+    } while(!sorted);
+    
+    for (unsigned int i=start; i < NUM_KARTS; ++i)
+    {
+        //printf("setting kart %s to rank %i\n", race_manager->getKartName(position[i]).c_str(), i-start);
+        m_kart_status[position[i]].m_gp_rank = i - start;
+    }
+    // printf("kart %s has rank %i\n", 0, m_kart_status[0].m_gp_rank);
+    delete []scores;
+    delete []position;
+    delete []race_time;    
+}
+
 //-----------------------------------------------------------------------------
 /** In GP displays the GP result screen, and then deletes the world.
  */
@@ -303,70 +389,7 @@ void RaceManager::exitRace()
     // were finished, and not when a race is aborted.
     if (m_major_mode==MAJOR_MODE_GRAND_PRIX && m_track_number==(int)m_tracks.size()) 
     {
-        // calculate the rank of each kart
+        computeGPRanks();        
-        const unsigned int NUM_KARTS = getNumberOfKarts();
-        
-        int *scores   = new int[NUM_KARTS];
-        int *position = new int[NUM_KARTS];
-        double *race_time = new double[NUM_KARTS];
-        // Ignore the first kart if it's a follow-the-leader race.
-        int start=(race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER) ? 1 : 0;
-        for (unsigned int kart_id = start; kart_id < NUM_KARTS; ++kart_id)
-        {
-            position[kart_id]  = kart_id;
-            scores[kart_id]    = race_manager->getKartScore(kart_id);
-            race_time[kart_id] = race_manager->getOverallTime(kart_id);
-        }
-        
-        if (race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER)
-        {
-            // fill values for leader
-            position[0]  = -1;
-            scores[0]    = -1;
-            race_time[0] = -1; 
-            m_kart_status[0].m_gp_final_rank = -1;
-        }
-        
-        //Bubblesort
-        bool sorted;
-        do
-        {
-            sorted = true;
-            for( unsigned int i = start; i < NUM_KARTS - 1; ++i )
-            {
-                if( scores[i] < scores[i+1] || (scores[i] == scores[i+1] 
-                                                && race_time[i] > race_time[i+1]))
-                {
-                    int tmp_score[2];
-                    double tmp_time;
-                    
-                    tmp_score[0] = position[i];
-                    tmp_score[1] = scores[i];
-                    tmp_time = race_time[i];
-                    
-                    position[i] = position[i+1];
-                    scores[i] = scores[i+1];
-                    race_time[i] = race_time[i+1];
-                    
-                    position[i+1] = tmp_score[0];
-                    scores[i+1] = tmp_score[1];
-                    race_time[i+1] = tmp_time;
-                    
-                    sorted = false;
-                }
-            }
-        } while(!sorted);
-        
-        for (unsigned int i=start; i < NUM_KARTS; ++i)
-        {
-            //printf("setting kart %s to rank %i\n", race_manager->getKartName(position[i]).c_str(), i-start);
-            m_kart_status[position[i]].m_gp_final_rank = i - start;
-        }
-       // printf("kart %s has rank %i\n", 0, m_kart_status[0].m_gp_final_rank);
-        delete []scores;
-        delete []position;
-        delete []race_time;
-        
         unlock_manager->grandPrixFinished();
         
         StateManager::get()->resetAndGoToScreen( MainMenuScreen::getInstance() );
@@ -375,8 +398,8 @@ void RaceManager::exitRace()
         std::string winners[3];
         for (unsigned int i=0; i < m_kart_status.size(); ++i)
         {
-            std::cout << m_kart_status[i].m_ident << " has GP final rank " << m_kart_status[i].m_gp_final_rank << std::endl;
+            std::cout << m_kart_status[i].m_ident << " has GP final rank " << m_kart_status[i].m_gp_rank << std::endl;
-            const int rank = m_kart_status[i].m_gp_final_rank;
+            const int rank = m_kart_status[i].m_gp_rank;
             if (rank >= 0 && rank < 3)
             {
                 winners[rank] = m_kart_status[i].m_ident;

src/race/race_manager.hpp

@@ -170,7 +170,7 @@ private:
         KartType    m_kart_type;        // Kart type: AI, player, network player etc.
         int         m_local_player_id;  // player controling the kart, for AI: -1
         int         m_global_player_id; // global ID of player
-        int         m_gp_final_rank;    // In GPs, at the end, will hold the overall rank of this kart.
+        int         m_gp_rank;    // In GPs, at the end, will hold the overall rank of this kart.
         
         KartStatus(const std::string& ident, const int& prev_finish_pos, 
                    int local_player_id, int global_player_id, KartType kt) :
@@ -189,7 +189,7 @@ private:
     MinorRaceModeType                m_minor_mode;
     /** Stores remote kart information about all player karts. */
     std::vector<RemoteKartInfo>      m_player_karts;
-    std::vector<RemoteKartInfo>      m_local_kart_info;
+    std::vector<RemoteKartInfo>      m_local_player_karts;
     std::vector<std::string>         m_tracks;
     std::vector<int>                 m_host_ids;
     std::vector<int>                 m_num_laps;
@@ -216,9 +216,9 @@ public:
     void         reset();
     void         setLocalKartInfo(unsigned int player_id, const std::string& kart);
     const RemoteKartInfo& 
-                 getLocalKartInfo(unsigned int n) const {return m_local_kart_info[n];}
+                 getLocalKartInfo(unsigned int n) const {return m_local_player_karts[n];}
     void         setNumLocalPlayers(unsigned int n);
-    unsigned int getNumLocalPlayers() const  {return m_local_kart_info.size(); };
+    unsigned int getNumLocalPlayers() const  {return m_local_player_karts.size(); };
     /** Returns the selected number of karts (selected=number of players and 
      *  AI karts. */
     unsigned int getNumberOfKarts()   const  {return m_num_karts; }
@@ -232,9 +232,9 @@ public:
     void         setNumLaps(int num)            { m_num_laps.clear();
                                                   m_num_laps.push_back(num);        }
     void         setMajorMode(MajorRaceModeType mode)
-                                                { m_major_mode = mode;        }
+                                                { m_major_mode = mode;              }
     void         setMinorMode(MinorRaceModeType mode)
-                                                { m_minor_mode = mode;       }
+                                                { m_minor_mode = mode;              }
     void         setNumKarts(int num)           { m_num_karts = num;                }
     void         setCoinTarget(int num)         { m_coin_target = num;              }
     MajorRaceModeType
@@ -250,8 +250,12 @@ public:
     unsigned int getFinishedPlayers()     const { return m_num_finished_players;    }
     const std::string& getItemStyle()     const { return m_grand_prix.getItemStyle(); }
     
-    int          getKartFinalGPRank(const int kart_id)
+    void         computeGPRanks();
-                                          const { return m_kart_status[kart_id].m_gp_final_rank; }
+    int          getKartGPRank(const int kart_id)
+                                          const { return m_kart_status[kart_id].m_gp_rank; }
+    
+    /** \return the GP rank of a local player, or -1 if the given player ID doesn't exist */
+    int          getLocalPlayerGPRank(const int playerID) const;
     
     const std::string&  
                  getKartIdent(int kart)   const { return m_kart_status[kart].m_ident;}