Allow a challenge to specify which AI kart to use, and use it for the final race against Nolok challenge

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

data/challenges/fortmagma.challenge

@@ -5,15 +5,15 @@
     <requirements trophies="23"/>
     
     <hard>
-        <karts number="2"/>
+        <karts number="2" aiIdent="nolok"/>
         <requirements position="1"/>
     </hard>
     <medium>
-        <karts number="2"/>
+        <karts number="2" aiIdent="nolok"/>
         <requirements position="1"/>
     </medium>
     <easy>
-        <karts number="2"/>
+        <karts number="2" aiIdent="nolok"/>
         <requirements position="1"/>
     </easy>
     

src/challenges/challenge_data.cpp

@@ -154,6 +154,10 @@ ChallengeData::ChallengeData(const std::string& filename)
         if (!karts_node->get("number", &num_karts)) error("karts");
         m_num_karts[d] = num_karts;
         
+        std::string ai_kart_ident;
+        if (karts_node->get("aiIdent", &ai_kart_ident))
+            m_ai_kart_ident[d] = ai_kart_ident;
+        
         const XMLNode* requirements_node = difficulties[d]->getNode("requirements");
         if (requirements_node == NULL) error("<requirements .../>");
 
@@ -363,6 +367,11 @@ void ChallengeData::setRace(RaceManager::Difficulty d) const
         race_manager->setNumKarts(m_num_karts[d]);
         race_manager->setNumLocalPlayers(1);
     }
+    
+    if (m_ai_kart_ident[d] != "")
+    {
+        race_manager->setAIKartOverride(m_ai_kart_ident[d]);
+    }
 }   // setRace
 
 // ----------------------------------------------------------------------------

src/challenges/challenge_data.hpp

@@ -58,6 +58,7 @@ private:
     int                            m_num_laps;
     int                            m_position[RaceManager::DIFFICULTY_COUNT];
     int                            m_num_karts[RaceManager::DIFFICULTY_COUNT];
+    std::string                    m_ai_kart_ident[RaceManager::DIFFICULTY_COUNT];
     float                          m_time[RaceManager::DIFFICULTY_COUNT];
     int                            m_energy[RaceManager::DIFFICULTY_COUNT];
     std::string                    m_gp_id;
@@ -136,6 +137,8 @@ public:
     float getTime    (RaceManager::Difficulty difficulty) const { return m_time[difficulty];       }
     int   getEnergy  (RaceManager::Difficulty difficulty) const { return m_energy[difficulty];     }
     
+    std::string getAIKartIdent(RaceManager::Difficulty difficulty) const { return m_ai_kart_ident[difficulty]; }
+    
 };   // Ch
 
 #endif   // HEADER_CHALLENGE_DATA_HPP

src/race/race_manager.cpp

@@ -243,6 +243,14 @@ void RaceManager::computeRandomKartList()
         kart_properties_manager->getRandomKartList(n, m_player_karts, 
                                                    &m_ai_kart_list   );
 
+    if (m_ai_kart_override != "")
+    {
+        for (int n = 0; n < m_ai_kart_list.size(); n++)
+        {
+            m_ai_kart_list[n] = m_ai_kart_override;
+        }
+    }
+
 }   // computeRandomKartList
 
 //-----------------------------------------------------------------------------

src/race/race_manager.hpp

@@ -265,6 +265,9 @@ private:
     /** The list of default AI karts to use. This is from the command line. */
     std::vector<std::string>         m_default_ai_list;
 
+    /** If set, specifies which kart to use for AI(s) */
+    std::string                      m_ai_kart_override;
+
     /** The list of AI karts to use. This is stored here so that the
      *  same list of AIs is used for all tracks of a GP. */
     std::vector<std::string>         m_ai_kart_list;
@@ -312,6 +315,8 @@ public:
       */
     void         setNumLocalPlayers(unsigned int n);
     
+    void         setAIKartOverride(const std::string& kart) { m_ai_kart_override = kart; }
+    
     /** In case of non GP mode set the track to use.
      *  \param track Pointer to the track to use.
      */
@@ -334,7 +339,7 @@ public:
                                                 { m_major_mode = mode;              }
     void         setMinorMode(MinorRaceModeType mode)
                                                 { m_minor_mode = mode;              }
-    void         setNumKarts(int num)           { m_num_karts = num;                }
+    void         setNumKarts(int num)           { m_num_karts = num; m_ai_kart_override = ""; }
     void         setCoinTarget(int num)         { m_coin_target = num;              }
     
     /** \} */