1) The challenge menu now displays the description when hovering over name,

if the name is clicked, a race for this challenge is started (e.g. a
   unfinished track in the 'all track' challenge, or the race/GP that
   needs to be raced with the right number of opponents, difficulty etc).
2) The all_track challenge now has a list of all tracks (instead of simply
   couting).
3) Fixed typo: the short description of the collect coin challenge had
   'race track' specified in the short description.


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

src/challenges/all_tracks.cpp

@@ -20,9 +20,20 @@
 #include <algorithm>
 #include "challenges/all_tracks.hpp"
 #include "world.hpp"
+#include "track_manager.hpp"
+
+char *ALLTRACKS[] = {"beach",         "bsodcastle", " islandtrack", "lighthouse",
+                     "littlevolcano", "olivermath",  "race",        "sandtrack",
+                     "startrack",     "subseatrack", "tuxtrack",    "volcano",
+                     ""};
 
 AllTracks::AllTracks() : Challenge("alltracks", "All Tracks")
 {
+    for(int i=0;; i++)
+    {
+        if(ALLTRACKS[i][0]==0) break;
+        m_all_tracks.push_back(ALLTRACKS[i]);
+    }
     setChallengeDescription("Finish one race\nin each track");
     setFeatureDescription("New track: SnowTuxPeak\nnow available");
     setFeature("snowtuxpeak");
@@ -32,6 +43,15 @@ AllTracks::AllTracks() : Challenge("alltracks", "All Tracks")
 void AllTracks::loadState(const lisp::Lisp* config)
 {
     config->getVector("solved-tracks", m_raced_tracks);
+    // Remove the finished tracks from the list of all tracks, so that
+    // startRace picks a track that wasn't used before.
+    for(std::vector<std::string>::iterator i=m_raced_tracks.begin();
+        i!=m_raced_tracks.end(); i++)
+    {
+        std::vector<std::string>::iterator p=std::find(m_all_tracks.begin(),
+                                                       m_all_tracks.end(),*i);
+        m_all_tracks.erase(p);
+    }
 }   // loadState
 
 //-----------------------------------------------------------------------------
@@ -40,6 +60,19 @@ void AllTracks::saveState(lisp::Writer* writer)
     writer->write("solved-tracks\t", m_raced_tracks);
 }   // saveState
 
+//-----------------------------------------------------------------------------
+void AllTracks::setRace() const
+{
+    assert(m_all_tracks.size()>0);
+    race_manager->setRaceMode(RaceManager::RM_QUICK_RACE);
+    race_manager->setTrack(m_all_tracks[0]);
+    race_manager->setDifficulty(RaceManager::RD_EASY);
+    race_manager->setNumLaps(1);
+    race_manager->setNumKarts(4);
+    race_manager->setNumPlayers(1);
+
+}   // setRace
+
 //-----------------------------------------------------------------------------
 bool AllTracks::raceFinished()
 {
@@ -49,9 +82,15 @@ bool AllTracks::raceFinished()
         ==m_raced_tracks.end())
     {
         m_raced_tracks.push_back(track_name);
+        std::vector<std::string>::iterator p=std::find(m_all_tracks.begin(),
+                                                       m_all_tracks.end(), 
+                                                       track_name);
+        // In case that a track was raced (for the first time) that's not
+        // in the list of tracks to race ...
+        if(p!=m_all_tracks.end()) m_all_tracks.erase(p);
     }
 
     // Check if all tracks are finished. If so, unlock feature
-    return (m_raced_tracks.size()==13);
+    return (m_all_tracks.size()==0);
 }   // raceFinished
 //-----------------------------------------------------------------------------

src/challenges/all_tracks.hpp

@@ -29,12 +29,13 @@ class AllTracks : public Challenge
 {
 private:
     std::vector<std::string> m_raced_tracks;
+    std::vector<std::string> m_all_tracks;
 public:
                  AllTracks();
     virtual void loadState(const lisp::Lisp* config);
     virtual void saveState(lisp::Writer* writer);
     virtual bool raceFinished();
-
+    virtual void setRace() const;
 };   // AllTracks
 
 #endif

src/challenges/challenge.hpp

@@ -75,5 +75,6 @@ public:
     // the feature remains locked.
     virtual bool raceFinished()                      {return false;}   // end of a race
     virtual bool grandPrixFinished()                 {return false;}   // end of a GP
+    virtual void setRace() const = 0;                                  // set race to use
 };
 #endif

src/challenges/energy_math_class.cpp

@@ -19,15 +19,26 @@
 
 #include <algorithm>
 #include "challenges/energy_math_class.hpp"
+#include "race_manager.hpp"
 #include "world.hpp"
 
-EnergyMathClass::EnergyMathClass() : Challenge("energymathclass", "Collect Coins in Race track")
+EnergyMathClass::EnergyMathClass() : Challenge("energymathclass", "Collect Coins in Math Class")
 {
     setChallengeDescription("Collect at least 6 coins\non three laps of\nOliver's Math Class\nin under 1 minute.");
     setFeatureDescription("New game mode\n'Grand Prix'\nnow available");
     setFeature("grandprix");
 }   // EnergyMathClass
 
+//-----------------------------------------------------------------------------
+void EnergyMathClass::setRace() const {
+    race_manager->setRaceMode(RaceManager::RM_QUICK_RACE);
+    race_manager->setTrack("olivermath");
+    race_manager->setDifficulty(RaceManager::RD_EASY);
+    race_manager->setNumLaps(3);
+    race_manager->setNumKarts(1);
+    race_manager->setNumPlayers(1);
+}   // setRace
+\
 //-----------------------------------------------------------------------------
 bool EnergyMathClass::raceFinished()
 {

src/challenges/energy_math_class.hpp

@@ -30,6 +30,7 @@ class EnergyMathClass : public Challenge
 public:
                  EnergyMathClass();
     virtual bool raceFinished();
+    virtual void setRace() const;
 };   // EnergyMathClass
 
 #endif

src/challenges/race_track_time.cpp

@@ -20,6 +20,7 @@
 #include <algorithm>
 #include "challenges/race_track_time.hpp"
 #include "world.hpp"
+#include "race_manager.hpp"
 
 RaceTrackTime::RaceTrackTime() : Challenge("racetracktime", "Finish Race track in 1:15")
 {
@@ -28,6 +29,16 @@ RaceTrackTime::RaceTrackTime() : Challenge("racetracktime", "Finish Race track i
     setFeature("followleader");
 }   // RaceTrackTime
 
+//-----------------------------------------------------------------------------
+void RaceTrackTime::setRace() const {
+    race_manager->setRaceMode(RaceManager::RM_QUICK_RACE);
+    race_manager->setTrack("race");
+    race_manager->setDifficulty(RaceManager::RD_EASY);
+    race_manager->setNumLaps(3);
+    race_manager->setNumKarts(1);
+    race_manager->setNumPlayers(1);
+}   // setRace
+
 //-----------------------------------------------------------------------------
 bool RaceTrackTime::raceFinished()
 {

src/challenges/race_track_time.hpp

@@ -30,6 +30,7 @@ class RaceTrackTime : public Challenge
 public:
                  RaceTrackTime();
     virtual bool raceFinished();
+    virtual void setRace() const;
 };   // RaceTrackTime
 
 #endif

src/challenges/win_gotm_cup.cpp

@@ -21,6 +21,7 @@
 #include "challenges/win_gotm_cup.hpp"
 #include "world.hpp"
 #include "race_manager.hpp"
+#include "cup_data.hpp"
 
 WinGOTMCup::WinGOTMCup() : Challenge("wingotmcup", "Win GOTM Cup")
 {
@@ -31,6 +32,16 @@ WinGOTMCup::WinGOTMCup() : Challenge("wingotmcup", "Win GOTM Cup")
     setFeature("jungle");
 }   // WinGOTMCup
 
+//-----------------------------------------------------------------------------
+void WinGOTMCup::setRace() const {
+    race_manager->setRaceMode(RaceManager::RM_GRAND_PRIX);
+    CupData cup("gotm.cup");
+    race_manager->setGrandPrix(cup);
+    race_manager->setDifficulty(RaceManager::RD_HARD);
+    race_manager->setNumKarts(4);
+    race_manager->setNumPlayers(1);
+}   // setRace
+
 //-----------------------------------------------------------------------------
 bool WinGOTMCup::grandPrixFinished()
 {

src/challenges/win_gotm_cup.hpp

@@ -30,6 +30,7 @@ class WinGOTMCup: public Challenge
 public:
                  WinGOTMCup();
     virtual bool grandPrixFinished();
+    virtual void setRace() const;
 };   // WinGOTMCup
 
 #endif

src/gui/challenges_menu.cpp

@@ -69,6 +69,7 @@ ChallengesMenu::ChallengesMenu()
 
     widget_manager->layout(WGT_AREA_ALL);
 }   // ChallengesMenu
+
 //-----------------------------------------------------------------------------
 ChallengesMenu::~ChallengesMenu()
 {
@@ -76,7 +77,18 @@ ChallengesMenu::~ChallengesMenu()
 }   // ~ChallengesMenu
 
 //-----------------------------------------------------------------------------
+void ChallengesMenu::update(float dt)
+{
+    const int challenge= widget_manager->getSelectedWgt() - WTOK_CHALLENGES;
+    if(challenge>=0 && challenge<(int)m_all_challenges.size())
+    {
+        widget_manager->setWgtText(WTOK_DESCRIPTION,
+                                   m_all_challenges[challenge]->getChallengeDescription());
+    }
+    BaseGUI::update(dt);
+}   // update
 
+//-----------------------------------------------------------------------------
 void ChallengesMenu::select()
 {
     if(widget_manager->getSelectedWgt()==WTOK_BACK)
@@ -87,7 +99,7 @@ void ChallengesMenu::select()
     int n=widget_manager->getSelectedWgt()-WTOK_CHALLENGES;
     if(n>=0 && n<(int)m_all_challenges.size())
     {
-        widget_manager->setWgtText(WTOK_DESCRIPTION,
-                                   m_all_challenges[n]->getChallengeDescription());
+        m_all_challenges[n]->setRace();
+        race_manager->startNew();
     }
 }   // select

src/gui/challenges_menu.hpp

@@ -32,7 +32,9 @@ private:
 public:
          ChallengesMenu();
         ~ChallengesMenu();
-    void select       ();
+    void select        ();
+    void update        (float dt);
+
 };  // ChallengesMenu
 
 #endif