ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

split major and minor modes, started some more encapsulationa round that

Browse Source 
git-svn-id: svn+ssh://svn.code.sf.net/p/supertuxkart/code/trunk/supertuxkart@2292 178a84e3-b1eb-0310-8ba1-8eac791a3b58
This commit is contained in:
auria 2008-09-22 00:55:27 +00:00
parent cc61f53ff8
commit 0ece64bc05
23 changed files with 192 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
src/challenges/challenge_data.cpp
View File

@ -35,8 +35,8 @@
ChallengeData::ChallengeData(const std::string& filename)
{
m_filename = filename;
m_major = RaceManager::RM_SINGLE;
m_minor = RaceManager::RM_SINGLE;
m_major = RaceManager::MAJOR_MODE_SINGLE;
m_minor = RaceManager::MINOR_MODE_QUICK_RACE;
m_difficulty = RaceManager::RD_EASY;
m_num_laps = -1;
m_num_karts = -1;
@ -64,19 +64,19 @@ ChallengeData::ChallengeData(const std::string& filename)
lisp->get("major", mode);
if(mode=="grandprix")
m_major = RaceManager::RM_GRAND_PRIX;
m_major = RaceManager::MAJOR_MODE_GRAND_PRIX;
else if(mode=="single")
m_major = RaceManager::RM_SINGLE;
m_major = RaceManager::MAJOR_MODE_SINGLE;
else
error("major");
lisp->get ("minor", mode);
lisp->get("minor", mode);
if(mode=="timetrial")
m_minor = RaceManager::RM_TIME_TRIAL;
m_minor = RaceManager::MINOR_MODE_TIME_TRIAL;
else if(mode=="quickrace")
m_minor = RaceManager::RM_QUICK_RACE;
m_minor = RaceManager::MINOR_MODE_QUICK_RACE;
else if(mode=="followtheleader")
m_minor = RaceManager::RM_FOLLOW_LEADER;
m_minor = RaceManager::MINOR_MODE_FOLLOW_LEADER;
else
error("minor");
std::string s;
@ -89,8 +89,9 @@ ChallengeData::ChallengeData(const std::string& filename)
if(!lisp->get("karts", m_num_karts) ) error("karts");
// Position is optional except in GP and FTL
if(!lisp->get("position", m_position) &&
(m_minor==RaceManager::RM_FOLLOW_LEADER ||
m_major==RaceManager::RM_GRAND_PRIX))
//RaceManager::getWorld()->areKartsOrdered() ) // FIXME - order and optional are not the same thing
(m_minor==RaceManager::MINOR_MODE_FOLLOW_LEADER ||
m_major==RaceManager::MAJOR_MODE_GRAND_PRIX))
error("position");
lisp->get("difficulty", s);
if(s=="easy")
@ -106,11 +107,11 @@ ChallengeData::ChallengeData(const std::string& filename)
lisp->get("position", m_position ); // must be set
if(m_time<0 && m_position<0) error("position/time");
lisp->get("energy", m_energy ); // This is optional
if(m_major==RaceManager::RM_SINGLE)
if(m_major==RaceManager::MAJOR_MODE_SINGLE)
{
if(!lisp->get("track", m_track_name )) error("track");
if(!lisp->get("laps", m_num_laps ) &&
m_minor!=RaceManager::RM_FOLLOW_LEADER)
m_minor!=RaceManager::MINOR_MODE_FOLLOW_LEADER)
error("laps");
}
else // GP
@ -187,7 +188,7 @@ void ChallengeData::getUnlocks(const lisp::Lisp *lisp, const char* type,
void ChallengeData::setRace() const
{
race_manager->setMajorMode(m_major);
if(m_major==RaceManager::RM_SINGLE)
if(m_major==RaceManager::MAJOR_MODE_SINGLE)
{
race_manager->setMinorMode(m_minor);
race_manager->setTrack(m_track_name);
@ -212,7 +213,7 @@ void ChallengeData::setRace() const
bool ChallengeData::raceFinished()
{
// GP's use the grandPrixFinished() function, so they can't be fulfilled here.
if(m_major==RaceManager::RM_GRAND_PRIX) return false;
if(m_major==RaceManager::MAJOR_MODE_GRAND_PRIX) return false;
// Single races
// ------------
@ -226,7 +227,7 @@ bool ChallengeData::raceFinished()
// Follow the leader
// -----------------
if(m_minor==RaceManager::RM_FOLLOW_LEADER)
if(m_minor==RaceManager::MINOR_MODE_FOLLOW_LEADER)
{
// All possible conditions were already checked, so: must have been successful
return true;
@ -240,7 +241,7 @@ bool ChallengeData::raceFinished()
// ----------------------------------------------------------------------------
bool ChallengeData::grandPrixFinished()
{
if (race_manager->getMajorMode() != RaceManager::RM_GRAND_PRIX ||
if (race_manager->getMajorMode() != RaceManager::MAJOR_MODE_GRAND_PRIX ||
race_manager->getMinorMode() != m_minor ||
race_manager->getGrandPrix()->getId() != m_gp_id ||
race_manager->getDifficulty()!= m_difficulty ||

24
src/challenges/challenge_data.hpp
View File

@ -30,20 +30,20 @@
class ChallengeData : public Challenge
{
private:
RaceManager::RaceModeType m_major;
RaceManager::RaceModeType m_minor;
RaceManager::Difficulty m_difficulty;
int m_num_laps;
int m_position;
int m_num_karts;
float m_time;
std::string m_gp_id;
std::string m_track_name;
int m_energy;
std::vector<std::string> m_depends_on;
RaceManager::MajorRaceModeType m_major;
RaceManager::MinorRaceModeType m_minor;
RaceManager::Difficulty m_difficulty;
int m_num_laps;
int m_position;
int m_num_karts;
float m_time;
std::string m_gp_id;
std::string m_track_name;
int m_energy;
std::vector<std::string> m_depends_on;
std::vector<UnlockableFeature> m_unlock;
std::string m_filename;
std::string m_filename;
void getUnlocks(const lisp::Lisp *lisp, const char* type, REWARD_TYPE reward);
void error(const char *id);

13
src/collectable.cpp
View File

@ -54,16 +54,9 @@ Collectable::~Collectable()
//-----------------------------------------------------------------------------
void Collectable::reset()
{
if(race_manager->getMinorMode()==RaceManager::RM_TIME_TRIAL)
{
m_type = COLLECT_ZIPPER;
m_number = race_manager->getNumLaps();
}
else
{
m_type = COLLECT_NOTHING;
m_number = 0;
}
int type;
RaceManager::getWorld()->getDefaultCollectibles( type, m_number );
m_type = (CollectableType)type;
} // reset
//-----------------------------------------------------------------------------

2
src/gui/char_sel.cpp
View File

@ -442,7 +442,7 @@ void CharSel::nextMenu()
// on handling client selections). Waiting for all client infos
// happens in the start_race_feedback menu (which then triggers
// sending the race info).
if (race_manager->getMajorMode() == RaceManager::RM_GRAND_PRIX)
if (race_manager->getMajorMode() == RaceManager::MAJOR_MODE_GRAND_PRIX)
menu_manager->pushMenu(MENUID_GRANDPRIXSELECT);
else
menu_manager->pushMenu(MENUID_TRACKSEL);

24
src/gui/game_mode.cpp
View File

@ -150,28 +150,28 @@ void GameMode::select()
switch (mode)
{
case WTOK_QUICK_RACE_SINGLE:
race_manager->setMajorMode(RaceManager::RM_SINGLE);
race_manager->setMinorMode(RaceManager::RM_QUICK_RACE);
race_manager->setMajorMode(RaceManager::MAJOR_MODE_SINGLE);
race_manager->setMinorMode(RaceManager::MINOR_MODE_QUICK_RACE);
break;
case WTOK_TIMETRIAL_SINGLE:
race_manager->setMajorMode(RaceManager::RM_SINGLE);
race_manager->setMinorMode(RaceManager::RM_TIME_TRIAL);
race_manager->setMajorMode(RaceManager::MAJOR_MODE_SINGLE);
race_manager->setMinorMode(RaceManager::MINOR_MODE_TIME_TRIAL);
break;
case WTOK_FOLLOW_LEADER_SINGLE:
race_manager->setMajorMode(RaceManager::RM_SINGLE);
race_manager->setMinorMode(RaceManager::RM_FOLLOW_LEADER);
race_manager->setMajorMode(RaceManager::MAJOR_MODE_SINGLE);
race_manager->setMinorMode(RaceManager::MINOR_MODE_FOLLOW_LEADER);
break;
case WTOK_QUICK_RACE_GP:
race_manager->setMajorMode(RaceManager::RM_GRAND_PRIX);
race_manager->setMinorMode(RaceManager::RM_QUICK_RACE);
race_manager->setMajorMode(RaceManager::MAJOR_MODE_GRAND_PRIX);
race_manager->setMinorMode(RaceManager::MINOR_MODE_QUICK_RACE);
break;
case WTOK_TIMETRIAL_GP:
race_manager->setMajorMode(RaceManager::RM_GRAND_PRIX);
race_manager->setMinorMode(RaceManager::RM_TIME_TRIAL);
race_manager->setMajorMode(RaceManager::MAJOR_MODE_GRAND_PRIX);
race_manager->setMinorMode(RaceManager::MINOR_MODE_TIME_TRIAL);
break;
case WTOK_FOLLOW_LEADER_GP:
race_manager->setMajorMode(RaceManager::RM_GRAND_PRIX);
race_manager->setMinorMode(RaceManager::RM_FOLLOW_LEADER);
race_manager->setMajorMode(RaceManager::MAJOR_MODE_GRAND_PRIX);
race_manager->setMinorMode(RaceManager::MINOR_MODE_FOLLOW_LEADER);
break;
case WTOK_HELP:
menu_manager->pushMenu(MENUID_HELP3);

4
src/gui/grand_prix_ending.cpp
View File

@ -67,7 +67,7 @@ GrandPrixEnd::GrandPrixEnd()
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::RM_FOLLOW_LEADER) ? 1 : 0;
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;
@ -120,7 +120,7 @@ GrandPrixEnd::GrandPrixEnd()
for(unsigned int i=start; i < NUM_KARTS; ++i)
{
char sTime[20];sTime[0]=0;
if(race_manager->getMinorMode()!=RaceManager::RM_FOLLOW_LEADER)
if(race_manager->getMinorMode()!=RaceManager::MINOR_MODE_FOLLOW_LEADER)
TimeToString(race_time[i], sTime);
sprintf((char*)(m_score + MAX_STR_LEN * i), "%d. %s %d %s",
i + 1-start, race_manager->getKartName(position[i]).c_str(), scores[i], sTime );

6
src/gui/race_gui.cpp
View File

@ -399,7 +399,7 @@ void RaceGUI::drawPlayerIcons ()
font_race->PrintShadow(str, 30, ICON_PLAYER_WIDHT+x, y+5,
COLORS);
}
if(race_manager->getMinorMode()==RaceManager::RM_FOLLOW_LEADER && i==0)
if(race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER && i==0)
{
GLfloat const RED[] = { 1.0f, 0, 0, 1.0f};
font_race->PrintShadow(_("Leader"), 30, ICON_PLAYER_WIDHT+x, y+5,
@ -1041,12 +1041,12 @@ void RaceGUI::drawStatusText(const float dt)
} // for pla
drawTimer ();
if(RaceManager::getWorld()->getTime()<TIME_MUSIC_DESCRIPTION
&& race_manager->getMinorMode() != RaceManager::RM_FOLLOW_LEADER)
&& race_manager->getMinorMode() != RaceManager::MINOR_MODE_FOLLOW_LEADER)
{
drawMusicDescription();
}
else if (RaceManager::getWorld()->getTime()>stk_config->m_leader_intervals[0]-TIME_MUSIC_DESCRIPTION
&& race_manager->getMinorMode()== RaceManager::RM_FOLLOW_LEADER)
&& race_manager->getMinorMode()== RaceManager::MINOR_MODE_FOLLOW_LEADER)
drawMusicDescription();
drawMap ();

4
src/gui/race_gui.hpp
View File

@ -60,7 +60,7 @@ class RaceGUI: public BaseGUI
if( time < 0.0f ) m_end_time = -1.0f;
else
{
m_end_time = race_manager->getMinorMode()==RaceManager::RM_FOLLOW_LEADER ?
m_end_time = race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER ?
world->getTime()-time : world->getTime()+time;
}
m_red=red; m_blue=blue; m_green=green;
@ -68,7 +68,7 @@ class RaceGUI: public BaseGUI
// in follow leader the clock counts backwards
bool done() const { const int time = RaceManager::getWorld()->getTime(); // work around gcc bug (doesn't accept :: in a ?)
return m_end_time<0 ||
(race_manager->getMinorMode()==RaceManager::RM_FOLLOW_LEADER ?
(race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER ?
time<m_end_time : time>m_end_time); }
};
public:

2
src/gui/race_menu.cpp
View File

@ -49,7 +49,7 @@ RaceMenu::RaceMenu()
widget_manager->addTextButtonWgt( WTOK_HELP, 50, 7, _("Help") );
widget_manager->addTextButtonWgt( WTOK_RESTART_RACE, 50, 7, _("Restart Race") );
if(race_manager->getMinorMode()==RaceManager::RM_QUICK_RACE)
if(race_manager->getMinorMode()==RaceManager::MINOR_MODE_QUICK_RACE)
{
widget_manager->addTextButtonWgt( WTOK_SETUP_NEW_RACE, 50, 7,
_("Setup New Race") );

10
src/gui/race_options.cpp
View File

@ -61,7 +61,7 @@ RaceOptions::RaceOptions()
m_num_laps=race_manager->getNumLaps();
// Determine the minimum number of karts
m_min_karts = (int)race_manager->getNumPlayers();
if(race_manager->getMinorMode() == RaceManager::RM_FOLLOW_LEADER)
if(race_manager->getMinorMode() == RaceManager::MINOR_MODE_FOLLOW_LEADER)
{
// if playing follow the leader single mode, there should be at
// least one opponent in addition to the leader
@ -109,8 +109,8 @@ RaceOptions::RaceOptions()
// Number of laps
// ==============
if( race_manager->getMajorMode() != RaceManager::RM_GRAND_PRIX &&
race_manager->getMinorMode() != RaceManager::RM_FOLLOW_LEADER )
if( race_manager->getMajorMode() != RaceManager::MAJOR_MODE_GRAND_PRIX &&
race_manager->getMinorMode() != RaceManager::MINOR_MODE_FOLLOW_LEADER )
{
widget_manager->addTextWgt( WTOK_LAPS_TITLE, DESC_WIDTH, 7, _("Number of laps") );
widget_manager->hideWgtRect(WTOK_LAPS_TITLE);
@ -270,8 +270,8 @@ void RaceOptions::select()
race_manager->setNumKarts(m_num_karts);
if( race_manager->getMajorMode() != RaceManager::RM_GRAND_PRIX &&
race_manager->getMinorMode() != RaceManager::RM_FOLLOW_LEADER )
if( race_manager->getMajorMode() != RaceManager::MAJOR_MODE_GRAND_PRIX &&
race_manager->getMinorMode() != RaceManager::MINOR_MODE_FOLLOW_LEADER )
{
race_manager->setNumLaps( m_num_laps );
}

8
src/gui/race_results_gui.cpp
View File

@ -46,7 +46,7 @@ RaceResultsGUI::RaceResultsGUI()
{
Widget *bottom_of_list;
if(race_manager->getMinorMode()==RaceManager::RM_FOLLOW_LEADER)
if(race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER)
bottom_of_list = displayLeaderResults();
else
bottom_of_list = displayRaceResults();
@ -61,7 +61,7 @@ RaceResultsGUI::RaceResultsGUI()
} else
{
Widget *w;
if(race_manager->getMajorMode()==RaceManager::RM_GRAND_PRIX)
if(race_manager->getMajorMode()==RaceManager::MAJOR_MODE_GRAND_PRIX)
{
w=widget_manager->addTextButtonWgt( WTOK_CONTINUE, 60, 7, _("Continue Grand Prix"));
}
@ -74,7 +74,7 @@ RaceResultsGUI::RaceResultsGUI()
w=widget_manager->addTextButtonWgt( WTOK_RESTART_RACE, 60, 7, _("Race in this track again"));
w->setPosition(WGT_DIR_CENTER, 0.0, NULL, WGT_DIR_UNDER_WIDGET, 0, w_prev);
w_prev = w;
if(race_manager->getMajorMode()==RaceManager::RM_SINGLE)
if(race_manager->getMajorMode()==RaceManager::MAJOR_MODE_SINGLE)
{
w=widget_manager->addTextButtonWgt( WTOK_SETUP_NEW_RACE, 60, 7, _("Setup New Race"));
w->setPosition(WGT_DIR_CENTER, 0, NULL, WGT_DIR_UNDER_WIDGET, 0, w_prev);
@ -212,7 +212,7 @@ Widget *RaceResultsGUI::displayKartList(unsigned int from, unsigned int to,
TimeToString(T, sTime);
//This shows position + driver name + time + points earned + total points
if(race_manager->getMajorMode()==RaceManager::RM_GRAND_PRIX)
if(race_manager->getMajorMode()==RaceManager::MAJOR_MODE_GRAND_PRIX)
{
sprintf((char*)(score + MAX_STR_LEN * i), "%d. %s %s +%d %d",
KART->getPosition(), KART_NAME.c_str(), sTime,

4
src/kart.cpp
View File

@ -426,7 +426,7 @@ void Kart::doLapCounting ()
// Race finished
// =============
if(m_race_lap>=race_manager->getNumLaps() &&
race_manager->getMinorMode()!=RaceManager::RM_FOLLOW_LEADER)
race_manager->getMinorMode()!=RaceManager::MINOR_MODE_FOLLOW_LEADER)
{
raceFinished(RaceManager::getWorld()->getTime());
}
@ -477,7 +477,7 @@ void Kart::doLapCounting ()
m_lap_start_time = -1.0f;
} else
{ // Switch to fast music in case of follow the leader when only 3 karts are left
if(race_manager->getMinorMode()==RaceManager::RM_FOLLOW_LEADER &&
if(race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER &&
RaceManager::getWorld()->getCurrentNumKarts()==3)
{
sound_manager->switchToFastMusic();

8
src/main.cpp
View File

@ -451,8 +451,8 @@ void InitTuxkart()
// default settings for Quickstart
race_manager->setNumPlayers(1);
race_manager->setNumLaps (3);
race_manager->setMajorMode (RaceManager::RM_SINGLE);
race_manager->setMinorMode (RaceManager::RM_QUICK_RACE);
race_manager->setMajorMode (RaceManager::MAJOR_MODE_SINGLE);
race_manager->setMinorMode (RaceManager::MINOR_MODE_QUICK_RACE);
race_manager->setDifficulty(RaceManager::RD_HARD);
menu_manager= new MenuManager();
@ -563,8 +563,8 @@ int main(int argc, char *argv[] )
// =========
race_manager->setNumPlayers(1);
race_manager->setLocalKartInfo(0, kart_properties_manager->getKart("tuxkart")->getIdent());
race_manager->setMajorMode (RaceManager::RM_SINGLE);
race_manager->setMinorMode (RaceManager::RM_QUICK_RACE);
race_manager->setMajorMode (RaceManager::MAJOR_MODE_SINGLE);
race_manager->setMinorMode (RaceManager::MINOR_MODE_QUICK_RACE);
race_manager->setDifficulty(RaceManager::RD_HARD);
race_manager->startNew();
}

22
src/modes/follow_the_leader.cpp
View File

@ -34,12 +34,6 @@ FollowTheLeaderRace::~FollowTheLeaderRace()
{
}
//-----------------------------------------------------------------------------
void FollowTheLeaderRace::restartRace()
{
World::restartRace();
m_leader_intervals = stk_config->m_leader_intervals;
}
#pragma mark -
#pragma mark clock events
@ -59,6 +53,15 @@ void FollowTheLeaderRace::onGo()
m_kart[i]->resetBrakes();
}
}
//-----------------------------------------------------------------------------
void FollowTheLeaderRace::onTerminate()
{
World::terminateRace();
}
#pragma mark -
#pragma mark overridden from World
//-----------------------------------------------------------------------------
void FollowTheLeaderRace::update(float delta)
{
@ -112,7 +115,8 @@ void FollowTheLeaderRace::update(float delta)
}
}
//-----------------------------------------------------------------------------
void FollowTheLeaderRace::onTerminate()
void FollowTheLeaderRace::restartRace()
{
World::terminateRace();
}
World::restartRace();
m_leader_intervals = stk_config->m_leader_intervals;
}

26
src/modes/standard_race.cpp
View File

@ -48,6 +48,15 @@ void StandardRace::onGo()
m_kart[i]->resetBrakes();
}
}
//-----------------------------------------------------------------------------
void StandardRace::onTerminate()
{
World::terminateRace();
}
#pragma mark -
#pragma mark overridden from World
//-----------------------------------------------------------------------------
void StandardRace::restartRace()
{
@ -78,8 +87,21 @@ void StandardRace::update(float delta)
m_clock.raceOver(true /* delay */);
}
}
//-----------------------------------------------------------------------------
void StandardRace::onTerminate()
void StandardRace::getDefaultCollectibles(int& collectible_type, int& amount)
{
World::terminateRace();
// in time trial mode, give zippers
if(race_manager->getMinorMode() == RaceManager::MINOR_MODE_TIME_TRIAL)
{
collectible_type = COLLECT_ZIPPER;
amount = race_manager->getNumLaps();
}
else World::getDefaultCollectibles(collectible_type, amount);
}
//-----------------------------------------------------------------------------
bool StandardRace::useRedHerring()
{
// in time trial mode, don't use "red herrings"
return race_manager->getMinorMode() != RaceManager::MINOR_MODE_TIME_TRIAL;
}

2
src/modes/standard_race.hpp
View File

@ -34,6 +34,8 @@ public:
// overriding World methods
virtual void update(float delta);
virtual void restartRace();
virtual void getDefaultCollectibles(int& collectible_type, int& amount);
virtual bool useRedHerring();
};
#endif

25
src/modes/world.cpp
View File

@ -68,6 +68,9 @@ World::World()
m_clock.setMode( CHRONO );
// FIXME - not really used yet, only a placeholder to be implemented fully later
m_order_karts = true;
// Grab the track file
try
{
@ -156,12 +159,14 @@ World::World()
//ssgSetBackFaceCollisions ( !not defined! race_manager->mirror ) ;
#endif
Highscores::HighscoreType hst = (race_manager->getMinorMode()==RaceManager::RM_TIME_TRIAL)
// FIXME - will need better way to deal with high scores if we have lots of modes
// and we wish to keep them modular
Highscores::HighscoreType hst = (race_manager->getMinorMode()==RaceManager::MINOR_MODE_TIME_TRIAL)
? Highscores::HST_TIMETRIAL_OVERALL_TIME
: Highscores::HST_RACE_OVERALL_TIME;
m_highscores = highscore_manager->getHighscores(hst);
callback_manager->initAll();
menu_manager->switchToRace();
@ -321,9 +326,10 @@ void World::updateHighscores()
PlayerKart *k = (PlayerKart*)m_kart[index[pos]];
Highscores::HighscoreType hst = (race_manager->getMinorMode()==
RaceManager::RM_TIME_TRIAL)
RaceManager::MINOR_MODE_TIME_TRIAL)
? Highscores::HST_TIMETRIAL_OVERALL_TIME
: Highscores::HST_RACE_OVERALL_TIME;
if(m_highscores->addData(hst, k->getName(),
k->getPlayer()->getName(),
k->getFinishTime())>0 )
@ -441,7 +447,7 @@ void World::updateRacePosition ( int k )
if(!m_faster_music_active &&
m_kart[k]->getLap()==race_manager->getNumLaps()-1 &&
p==1 &&
race_manager->getMinorMode()!=RaceManager::RM_FOLLOW_LEADER &&
race_manager->getMinorMode()!=RaceManager::MINOR_MODE_FOLLOW_LEADER &&
m_kart[k]->estimateFinishTime()-getTime()<30.0f )
{
sound_manager->switchToFastMusic();
@ -458,7 +464,7 @@ void World::loadTrack()
// remove old herrings (from previous race), and remove old
// track specific herring models
herring_manager->cleanup();
if(race_manager->getMajorMode()== RaceManager::RM_GRAND_PRIX)
if(race_manager->getMajorMode()== RaceManager::MAJOR_MODE_GRAND_PRIX)
{
try
{
@ -490,7 +496,12 @@ void World::loadTrack()
m_track->loadTrackModel();
} // loadTrack
//-----------------------------------------------------------------------------
void World::getDefaultCollectibles(int& collectible_type, int& amount )
{
collectible_type = COLLECT_NOTHING;
amount = 0;
}
//-----------------------------------------------------------------------------
void World::restartRace()
{

20
src/modes/world.hpp
View File

@ -98,6 +98,10 @@ protected:
bool m_faster_music_active; // true if faster music was activated
/** whether this kind of race orders karts from first to last
*/
bool m_order_karts;
void updateRacePosition(int k);
void updateHighscores ();
void loadTrack ();
@ -120,6 +124,10 @@ public:
virtual void restartRace();
void disableRace(); // Put race into limbo phase
/** whether this kind of race orders karts from first to last
*/
bool areKartsOrdered();
PlayerKart *getPlayerKart(int player) const { return m_player_karts[player]; }
unsigned int getCurrentNumLocalPlayers() const { return m_local_player_karts.size(); }
PlayerKart *getLocalPlayerKart(int n) const { return m_local_player_karts[n]; }
@ -142,11 +150,19 @@ public:
Phase getPhase() const { return m_clock.getPhase(); }
const Clock& getClock() const { return m_clock; }
/**
* Called when race is over and should be terminated (mostly called by the clock).
/** Called when race is over and should be terminated (mostly called by the clock).
*/
void terminateRace();
/** Called to determine the default collectibles to give each player for this
* kind of race. Both parameters are of 'out' type.
*/
virtual void getDefaultCollectibles(int& collectible_type, int& amount );
/** Called to determine whether this race mode uses "red herring".
*/
virtual bool useRedHerring(){ return true; }
void pause();
void unpause();

10
src/network/race_info_message.cpp
View File

@ -27,7 +27,7 @@ RaceInfoMessage::RaceInfoMessage(const std::vector<RemoteKartInfo>& kart_info)
const GrandPrixData *cup=NULL;
int len = 3*getCharLength() // major, minor, difficulty
+ getCharLength(); // num karts
if(race_manager->getMajorMode()==RaceManager::RM_GRAND_PRIX)
if(race_manager->getMajorMode()==RaceManager::MAJOR_MODE_GRAND_PRIX)
{
cup = race_manager->getGrandPrix();
len += getStringLength(cup->getId());
@ -54,7 +54,7 @@ RaceInfoMessage::RaceInfoMessage(const std::vector<RemoteKartInfo>& kart_info)
addChar(race_manager->getMinorMode() );
addChar(race_manager->getDifficulty());
addChar(race_manager->getNumKarts() );
if(race_manager->getMajorMode()==RaceManager::RM_GRAND_PRIX)
if(race_manager->getMajorMode()==RaceManager::MAJOR_MODE_GRAND_PRIX)
addString(cup->getName());
else
{
@ -77,11 +77,11 @@ RaceInfoMessage::RaceInfoMessage(const std::vector<RemoteKartInfo>& kart_info)
// ----------------------------------------------------------------------------
RaceInfoMessage::RaceInfoMessage(ENetPacket* pkt):Message(pkt, MT_RACE_INFO)
{
race_manager->setMajorMode ( RaceManager::RaceModeType(getChar()) );
race_manager->setMinorMode ( RaceManager::RaceModeType(getChar()) );
race_manager->setMajorMode ( RaceManager::MajorRaceModeType(getChar()) );
race_manager->setMinorMode ( RaceManager::MinorRaceModeType(getChar()) );
race_manager->setDifficulty( RaceManager::Difficulty (getChar()) );
race_manager->setNumKarts ( getChar() );
if(race_manager->getMajorMode()==RaceManager::RM_GRAND_PRIX)
if(race_manager->getMajorMode()==RaceManager::MAJOR_MODE_GRAND_PRIX)
{
GrandPrixData cup;
grand_prix_manager->getGrandPrix(getString());

18
src/race_manager.cpp
View File

@ -68,8 +68,8 @@ RaceManager::RaceManager()
{
m_num_karts = user_config->m_karts;
m_difficulty = RD_HARD;
m_major_mode = RM_SINGLE;
m_minor_mode = RM_QUICK_RACE;
m_major_mode = MAJOR_MODE_SINGLE;
m_minor_mode = MINOR_MODE_QUICK_RACE;
m_track_number = 0;
m_active_race = false;
m_score_for_position = stk_config->m_scores;
@ -191,7 +191,7 @@ void RaceManager::computeRandomKartList()
*/
void RaceManager::startNew()
{
if(m_major_mode==RM_GRAND_PRIX) // GP: get tracks and laps from grand prix
if(m_major_mode==MAJOR_MODE_GRAND_PRIX) // GP: get tracks and laps from grand prix
{
m_tracks = m_grand_prix.getTracks();
m_num_laps = m_grand_prix.getLaps();
@ -246,7 +246,7 @@ void RaceManager::startNextRace()
{
// In follow the leader mode do not change the first kart,
// since it's always the leader.
int offset = (m_minor_mode==RM_FOLLOW_LEADER) ? 1 : 0;
int offset = (m_minor_mode==MINOR_MODE_FOLLOW_LEADER) ? 1 : 0;
std::sort(m_kart_status.begin()+offset, m_kart_status.end());
//reverse kart order if flagged in stk_config
@ -262,12 +262,12 @@ void RaceManager::startNextRace()
// and need world to be defined.
/*
RM_GRAND_PRIX, RM_SINGLE,
RM_QUICK_RACE, RM_TIME_TRIAL, RM_FOLLOW_LEADER
MAJOR_MODE_GRAND_PRIX, MAJOR_MODE_SINGLE,
MINOR_MODE_QUICK_RACE, MINOR_MODE_TIME_TRIAL, MINOR_MODE_FOLLOW_LEADER
FIXME
*/
if(m_minor_mode==RM_FOLLOW_LEADER) new FollowTheLeaderRace();
if(m_minor_mode==MINOR_MODE_FOLLOW_LEADER) new FollowTheLeaderRace();
else new StandardRace();
m_active_race = true;
@ -300,7 +300,7 @@ void RaceManager::exit_race()
{
// Only display the grand prix result screen if all tracks
// were finished, and not when a race is aborted.
if(m_major_mode==RM_GRAND_PRIX && m_track_number==(int)m_tracks.size())
if(m_major_mode==MAJOR_MODE_GRAND_PRIX && m_track_number==(int)m_tracks.size())
{
unlock_manager->grandPrixFinished();
menu_manager->switchToGrandPrixEnding();
@ -339,7 +339,7 @@ void RaceManager::RaceFinished(const Kart *kart, float time)
// In follow the leader mode, kart 0 does not get any points,
// so the position of each kart is actually one better --> decrease pos
int pos = kart->getPosition();
if(m_minor_mode==RM_FOLLOW_LEADER)
if(m_minor_mode==MINOR_MODE_FOLLOW_LEADER)
{
pos--;
// If the position is negative (i.e. follow leader and kart on

53
src/race_manager.hpp
View File

@ -63,12 +63,21 @@ class Track;
class RaceManager
{
public:
/** Major and minor game modes. This type should be split into two
* types: MajorRaceModeType and MinorRaceModeType. Differentiating these
* two types allows a GP to consist of mixture oftime trial, crazy race,
* and FollowTheLeader modes. */
enum RaceModeType { RM_GRAND_PRIX, RM_SINGLE, // The two current major modes
RM_QUICK_RACE, RM_TIME_TRIAL, RM_FOLLOW_LEADER };
/** The major types or races supported in STK
*/
enum MajorRaceModeType
{
MAJOR_MODE_GRAND_PRIX,
MAJOR_MODE_SINGLE
};
/** Minor variants to the major types of race.
*/
enum MinorRaceModeType
{
MINOR_MODE_QUICK_RACE,
MINOR_MODE_TIME_TRIAL,
MINOR_MODE_FOLLOW_LEADER
};
/** Difficulty. Atm skidding is implemented as a special difficulty. */
enum Difficulty { RD_EASY, RD_MEDIUM, RD_HARD, RD_SKIDDING };
@ -103,7 +112,8 @@ private:
std::vector<KartStatus> m_kart_status;
Difficulty m_difficulty;
RaceModeType m_major_mode, m_minor_mode;
MajorRaceModeType m_major_mode;
MinorRaceModeType m_minor_mode;
typedef std::vector<std::string> PlayerKarts;
/** Stores remote kart information about all player karts. */
std::vector<RemoteKartInfo> m_player_karts;
@ -154,34 +164,37 @@ public:
void setDifficulty(Difficulty diff);
void setNumLaps(int num) { m_num_laps.clear();
m_num_laps.push_back(num); }
void setMajorMode(RaceModeType mode){ m_major_mode = mode; }
void setMinorMode(RaceModeType mode){ m_minor_mode = mode; }
void setMajorMode(MajorRaceModeType mode)
{ m_major_mode = mode; }
void setMinorMode(MinorRaceModeType mode)
{ m_minor_mode = mode; }
void setNumKarts(int num) { m_num_karts = num; }
void setCoinTarget(int num) { m_coin_target = num; }
RaceModeType getMajorMode() const { return m_major_mode; }
RaceModeType getMinorMode() const { return m_minor_mode; }
MajorRaceModeType
getMajorMode() const { return m_major_mode; }
MinorRaceModeType
getMinorMode() const { return m_minor_mode; }
unsigned int getNumKarts() const { return m_num_karts; }
unsigned int getNumPlayers() const { return m_player_karts.size(); }
int getNumLaps() const { return m_num_laps[m_track_number];}
Difficulty getDifficulty() const { return m_difficulty; }
const std::string&
getTrackName() const { return m_tracks[m_track_number]; }
const GrandPrixData
*getGrandPrix() const { return &m_grand_prix; }
const std::string& getTrackName() const { return m_tracks[m_track_number]; }
const GrandPrixData *getGrandPrix() const { return &m_grand_prix; }
unsigned int getFinishedKarts() const { return m_num_finished_karts; }
unsigned int getFinishedPlayers() const { return m_num_finished_players; }
const std::string&
getHerringStyle() const { return m_grand_prix.getHerringStyle(); }
const std::string& getHerringStyle() const { return m_grand_prix.getHerringStyle(); }
const std::string&
getKartName(int kart) const { return m_kart_status[kart].m_ident;}
int getKartScore(int krt) const { return m_kart_status[krt].m_score; }
int getKartPrevScore(int krt)const { return m_kart_status[krt].m_last_score;}
int getKartLocalPlayerId(int k) const { return m_kart_status[k].m_local_player_id; }
int getKartGlobalPlayerId(int k) const { return m_kart_status[k].m_global_player_id; }
int getKartLocalPlayerId(int k)
const { return m_kart_status[k].m_local_player_id; }
int getKartGlobalPlayerId(int k)
const { return m_kart_status[k].m_global_player_id; }
double getOverallTime(int kart) const { return m_kart_status[kart].m_overall_time;}
KartType getKartType(int kart) const { return m_kart_status[kart].m_kart_type;}
int getCoinTarget() const { return m_coin_target; }
bool raceHasLaps() const { return m_minor_mode!=RM_FOLLOW_LEADER; }
bool raceHasLaps() const { return m_minor_mode!=MINOR_MODE_FOLLOW_LEADER; }
int getPositionScore(int p) const { return m_score_for_position[p-1]; }
int allPlayerFinished() const {return
m_num_finished_players==m_player_karts.size();}

2
src/robots/default_robot.cpp
View File

@ -155,7 +155,7 @@ void DefaultRobot::handle_braking()
{
// In follow the leader mode, the kart should brake if they are ahead of
// the leader (and not the leader, i.e. don't have initial position 1)
if(race_manager->getMinorMode() == RaceManager::RM_FOLLOW_LEADER &&
if(race_manager->getMinorMode() == RaceManager::MINOR_MODE_FOLLOW_LEADER &&
getPosition() < RaceManager::getKart(0)->getPosition() &&
getInitialPosition()>1 )
{

2
src/track.cpp
View File

@ -1331,7 +1331,7 @@ void Track::herring_command (sgVec3 *xyz, char htype, int bNeedHeight )
if ( htype=='S' || htype=='s' ) { type = HE_SILVER ;}
// Time trial does not have any red herrings
if(type==HE_RED && race_manager->getMinorMode()==RaceManager::RM_TIME_TRIAL)
if(type==HE_RED && !RaceManager::getWorld()->useRedHerring())
return;
Vec3 loc((*xyz));
herring_manager->newHerring(type, loc);