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

24
src/challenges/challenge_data.hpp
View File

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

13
src/collectable.cpp
View File

@ -54,16 +54,9 @@ Collectable::~Collectable()
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void Collectable::reset() void Collectable::reset()
{ {
if(race_manager->getMinorMode()==RaceManager::RM_TIME_TRIAL) int type;
{ RaceManager::getWorld()->getDefaultCollectibles( type, m_number );
m_type = COLLECT_ZIPPER; m_type = (CollectableType)type;
m_number = race_manager->getNumLaps();
}
else
{
m_type = COLLECT_NOTHING;
m_number = 0;
}
} // reset } // 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 // on handling client selections). Waiting for all client infos
// happens in the start_race_feedback menu (which then triggers // happens in the start_race_feedback menu (which then triggers
// sending the race info). // 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); menu_manager->pushMenu(MENUID_GRANDPRIXSELECT);
else else
menu_manager->pushMenu(MENUID_TRACKSEL); menu_manager->pushMenu(MENUID_TRACKSEL);

24
src/gui/game_mode.cpp
View File

@ -150,28 +150,28 @@ void GameMode::select()
switch (mode) switch (mode)
{ {
case WTOK_QUICK_RACE_SINGLE: case WTOK_QUICK_RACE_SINGLE:
race_manager->setMajorMode(RaceManager::RM_SINGLE); race_manager->setMajorMode(RaceManager::MAJOR_MODE_SINGLE);
race_manager->setMinorMode(RaceManager::RM_QUICK_RACE); race_manager->setMinorMode(RaceManager::MINOR_MODE_QUICK_RACE);
break; break;
case WTOK_TIMETRIAL_SINGLE: case WTOK_TIMETRIAL_SINGLE:
race_manager->setMajorMode(RaceManager::RM_SINGLE); race_manager->setMajorMode(RaceManager::MAJOR_MODE_SINGLE);
race_manager->setMinorMode(RaceManager::RM_TIME_TRIAL); race_manager->setMinorMode(RaceManager::MINOR_MODE_TIME_TRIAL);
break; break;
case WTOK_FOLLOW_LEADER_SINGLE: case WTOK_FOLLOW_LEADER_SINGLE:
race_manager->setMajorMode(RaceManager::RM_SINGLE); race_manager->setMajorMode(RaceManager::MAJOR_MODE_SINGLE);
race_manager->setMinorMode(RaceManager::RM_FOLLOW_LEADER); race_manager->setMinorMode(RaceManager::MINOR_MODE_FOLLOW_LEADER);
break; break;
case WTOK_QUICK_RACE_GP: case WTOK_QUICK_RACE_GP:
race_manager->setMajorMode(RaceManager::RM_GRAND_PRIX); race_manager->setMajorMode(RaceManager::MAJOR_MODE_GRAND_PRIX);
race_manager->setMinorMode(RaceManager::RM_QUICK_RACE); race_manager->setMinorMode(RaceManager::MINOR_MODE_QUICK_RACE);
break; break;
case WTOK_TIMETRIAL_GP: case WTOK_TIMETRIAL_GP:
race_manager->setMajorMode(RaceManager::RM_GRAND_PRIX); race_manager->setMajorMode(RaceManager::MAJOR_MODE_GRAND_PRIX);
race_manager->setMinorMode(RaceManager::RM_TIME_TRIAL); race_manager->setMinorMode(RaceManager::MINOR_MODE_TIME_TRIAL);
break; break;
case WTOK_FOLLOW_LEADER_GP: case WTOK_FOLLOW_LEADER_GP:
race_manager->setMajorMode(RaceManager::RM_GRAND_PRIX); race_manager->setMajorMode(RaceManager::MAJOR_MODE_GRAND_PRIX);
race_manager->setMinorMode(RaceManager::RM_FOLLOW_LEADER); race_manager->setMinorMode(RaceManager::MINOR_MODE_FOLLOW_LEADER);
break; break;
case WTOK_HELP: case WTOK_HELP:
menu_manager->pushMenu(MENUID_HELP3); 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]; int *position = new int[NUM_KARTS];
double *race_time = new double[NUM_KARTS]; double *race_time = new double[NUM_KARTS];
// Ignore the first kart if it's a follow-the-leader race. // 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 ) for( unsigned int kart_id = start; kart_id < NUM_KARTS; ++kart_id )
{ {
position[kart_id] = kart_id; position[kart_id] = kart_id;
@ -120,7 +120,7 @@ GrandPrixEnd::GrandPrixEnd()
for(unsigned int i=start; i < NUM_KARTS; ++i) for(unsigned int i=start; i < NUM_KARTS; ++i)
{ {
char sTime[20];sTime[0]=0; 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); TimeToString(race_time[i], sTime);
sprintf((char*)(m_score + MAX_STR_LEN * i), "%d. %s %d %s", 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 ); 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, font_race->PrintShadow(str, 30, ICON_PLAYER_WIDHT+x, y+5,
COLORS); 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}; GLfloat const RED[] = { 1.0f, 0, 0, 1.0f};
font_race->PrintShadow(_("Leader"), 30, ICON_PLAYER_WIDHT+x, y+5, font_race->PrintShadow(_("Leader"), 30, ICON_PLAYER_WIDHT+x, y+5,
@ -1041,12 +1041,12 @@ void RaceGUI::drawStatusText(const float dt)
} // for pla } // for pla
drawTimer (); drawTimer ();
if(RaceManager::getWorld()->getTime()<TIME_MUSIC_DESCRIPTION if(RaceManager::getWorld()->getTime()<TIME_MUSIC_DESCRIPTION
&& race_manager->getMinorMode() != RaceManager::RM_FOLLOW_LEADER) && race_manager->getMinorMode() != RaceManager::MINOR_MODE_FOLLOW_LEADER)
{ {
drawMusicDescription(); drawMusicDescription();
} }
else if (RaceManager::getWorld()->getTime()>stk_config->m_leader_intervals[0]-TIME_MUSIC_DESCRIPTION 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(); drawMusicDescription();
drawMap (); 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; if( time < 0.0f ) m_end_time = -1.0f;
else 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; world->getTime()-time : world->getTime()+time;
} }
m_red=red; m_blue=blue; m_green=green; m_red=red; m_blue=blue; m_green=green;
@ -68,7 +68,7 @@ class RaceGUI: public BaseGUI
// in follow leader the clock counts backwards // 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 ?) bool done() const { const int time = RaceManager::getWorld()->getTime(); // work around gcc bug (doesn't accept :: in a ?)
return m_end_time<0 || 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); } time<m_end_time : time>m_end_time); }
}; };
public: 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_HELP, 50, 7, _("Help") );
widget_manager->addTextButtonWgt( WTOK_RESTART_RACE, 50, 7, _("Restart Race") ); 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, widget_manager->addTextButtonWgt( WTOK_SETUP_NEW_RACE, 50, 7,
_("Setup New Race") ); _("Setup New Race") );

10
src/gui/race_options.cpp
View File

@ -61,7 +61,7 @@ RaceOptions::RaceOptions()
m_num_laps=race_manager->getNumLaps(); m_num_laps=race_manager->getNumLaps();
// Determine the minimum number of karts // Determine the minimum number of karts
m_min_karts = (int)race_manager->getNumPlayers(); 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 // if playing follow the leader single mode, there should be at
// least one opponent in addition to the leader // least one opponent in addition to the leader
@ -109,8 +109,8 @@ RaceOptions::RaceOptions()
// Number of laps // Number of laps
// ============== // ==============
if( race_manager->getMajorMode() != RaceManager::RM_GRAND_PRIX && if( race_manager->getMajorMode() != RaceManager::MAJOR_MODE_GRAND_PRIX &&
race_manager->getMinorMode() != RaceManager::RM_FOLLOW_LEADER ) race_manager->getMinorMode() != RaceManager::MINOR_MODE_FOLLOW_LEADER )
{ {
widget_manager->addTextWgt( WTOK_LAPS_TITLE, DESC_WIDTH, 7, _("Number of laps") ); widget_manager->addTextWgt( WTOK_LAPS_TITLE, DESC_WIDTH, 7, _("Number of laps") );
widget_manager->hideWgtRect(WTOK_LAPS_TITLE); widget_manager->hideWgtRect(WTOK_LAPS_TITLE);
@ -270,8 +270,8 @@ void RaceOptions::select()
race_manager->setNumKarts(m_num_karts); race_manager->setNumKarts(m_num_karts);
if( race_manager->getMajorMode() != RaceManager::RM_GRAND_PRIX && if( race_manager->getMajorMode() != RaceManager::MAJOR_MODE_GRAND_PRIX &&
race_manager->getMinorMode() != RaceManager::RM_FOLLOW_LEADER ) race_manager->getMinorMode() != RaceManager::MINOR_MODE_FOLLOW_LEADER )
{ {
race_manager->setNumLaps( m_num_laps ); 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; 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(); bottom_of_list = displayLeaderResults();
else else
bottom_of_list = displayRaceResults(); bottom_of_list = displayRaceResults();
@ -61,7 +61,7 @@ RaceResultsGUI::RaceResultsGUI()
} else } else
{ {
Widget *w; 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")); 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=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->setPosition(WGT_DIR_CENTER, 0.0, NULL, WGT_DIR_UNDER_WIDGET, 0, w_prev);
w_prev = w; 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=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); 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); TimeToString(T, sTime);
//This shows position + driver name + time + points earned + total points //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", sprintf((char*)(score + MAX_STR_LEN * i), "%d. %s %s +%d %d",
KART->getPosition(), KART_NAME.c_str(), sTime, KART->getPosition(), KART_NAME.c_str(), sTime,

4
src/kart.cpp
View File

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

8
src/main.cpp
View File

@ -451,8 +451,8 @@ void InitTuxkart()
// default settings for Quickstart // default settings for Quickstart
race_manager->setNumPlayers(1); race_manager->setNumPlayers(1);
race_manager->setNumLaps (3); race_manager->setNumLaps (3);
race_manager->setMajorMode (RaceManager::RM_SINGLE); race_manager->setMajorMode (RaceManager::MAJOR_MODE_SINGLE);
race_manager->setMinorMode (RaceManager::RM_QUICK_RACE); race_manager->setMinorMode (RaceManager::MINOR_MODE_QUICK_RACE);
race_manager->setDifficulty(RaceManager::RD_HARD); race_manager->setDifficulty(RaceManager::RD_HARD);
menu_manager= new MenuManager(); menu_manager= new MenuManager();
@ -563,8 +563,8 @@ int main(int argc, char *argv[] )
// ========= // =========
race_manager->setNumPlayers(1); race_manager->setNumPlayers(1);
race_manager->setLocalKartInfo(0, kart_properties_manager->getKart("tuxkart")->getIdent()); race_manager->setLocalKartInfo(0, kart_properties_manager->getKart("tuxkart")->getIdent());
race_manager->setMajorMode (RaceManager::RM_SINGLE); race_manager->setMajorMode (RaceManager::MAJOR_MODE_SINGLE);
race_manager->setMinorMode (RaceManager::RM_QUICK_RACE); race_manager->setMinorMode (RaceManager::MINOR_MODE_QUICK_RACE);
race_manager->setDifficulty(RaceManager::RD_HARD); race_manager->setDifficulty(RaceManager::RD_HARD);
race_manager->startNew(); 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 -
#pragma mark clock events #pragma mark clock events
@ -59,6 +53,15 @@ void FollowTheLeaderRace::onGo()
m_kart[i]->resetBrakes(); m_kart[i]->resetBrakes();
} }
} }
//-----------------------------------------------------------------------------
void FollowTheLeaderRace::onTerminate()
{
World::terminateRace();
}
#pragma mark -
#pragma mark overridden from World
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void FollowTheLeaderRace::update(float delta) 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(); m_kart[i]->resetBrakes();
} }
} }
//-----------------------------------------------------------------------------
void StandardRace::onTerminate()
{
World::terminateRace();
}
#pragma mark -
#pragma mark overridden from World
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void StandardRace::restartRace() void StandardRace::restartRace()
{ {
@ -78,8 +87,21 @@ void StandardRace::update(float delta)
m_clock.raceOver(true /* delay */); 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 // overriding World methods
virtual void update(float delta); virtual void update(float delta);
virtual void restartRace(); virtual void restartRace();
virtual void getDefaultCollectibles(int& collectible_type, int& amount);
virtual bool useRedHerring();
}; };
#endif #endif

25
src/modes/world.cpp
View File

@ -68,6 +68,9 @@ World::World()
m_clock.setMode( CHRONO ); 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 // Grab the track file
try try
{ {
@ -156,12 +159,14 @@ World::World()
//ssgSetBackFaceCollisions ( !not defined! race_manager->mirror ) ; //ssgSetBackFaceCollisions ( !not defined! race_manager->mirror ) ;
#endif #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_TIMETRIAL_OVERALL_TIME
: Highscores::HST_RACE_OVERALL_TIME; : Highscores::HST_RACE_OVERALL_TIME;
m_highscores = highscore_manager->getHighscores(hst); m_highscores = highscore_manager->getHighscores(hst);
callback_manager->initAll(); callback_manager->initAll();
menu_manager->switchToRace(); menu_manager->switchToRace();
@ -321,9 +326,10 @@ void World::updateHighscores()
PlayerKart *k = (PlayerKart*)m_kart[index[pos]]; PlayerKart *k = (PlayerKart*)m_kart[index[pos]];
Highscores::HighscoreType hst = (race_manager->getMinorMode()== Highscores::HighscoreType hst = (race_manager->getMinorMode()==
RaceManager::RM_TIME_TRIAL) RaceManager::MINOR_MODE_TIME_TRIAL)
? Highscores::HST_TIMETRIAL_OVERALL_TIME ? Highscores::HST_TIMETRIAL_OVERALL_TIME
: Highscores::HST_RACE_OVERALL_TIME; : Highscores::HST_RACE_OVERALL_TIME;
if(m_highscores->addData(hst, k->getName(), if(m_highscores->addData(hst, k->getName(),
k->getPlayer()->getName(), k->getPlayer()->getName(),
k->getFinishTime())>0 ) k->getFinishTime())>0 )
@ -441,7 +447,7 @@ void World::updateRacePosition ( int k )
if(!m_faster_music_active && if(!m_faster_music_active &&
m_kart[k]->getLap()==race_manager->getNumLaps()-1 && m_kart[k]->getLap()==race_manager->getNumLaps()-1 &&
p==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 ) m_kart[k]->estimateFinishTime()-getTime()<30.0f )
{ {
sound_manager->switchToFastMusic(); sound_manager->switchToFastMusic();
@ -458,7 +464,7 @@ void World::loadTrack()
// remove old herrings (from previous race), and remove old // remove old herrings (from previous race), and remove old
// track specific herring models // track specific herring models
herring_manager->cleanup(); herring_manager->cleanup();
if(race_manager->getMajorMode()== RaceManager::RM_GRAND_PRIX) if(race_manager->getMajorMode()== RaceManager::MAJOR_MODE_GRAND_PRIX)
{ {
try try
{ {
@ -490,7 +496,12 @@ void World::loadTrack()
m_track->loadTrackModel(); m_track->loadTrackModel();
} // loadTrack } // loadTrack
//-----------------------------------------------------------------------------
void World::getDefaultCollectibles(int& collectible_type, int& amount )
{
collectible_type = COLLECT_NOTHING;
amount = 0;
}
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void World::restartRace() 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 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 updateRacePosition(int k);
void updateHighscores (); void updateHighscores ();
void loadTrack (); void loadTrack ();
@ -120,6 +124,10 @@ public:
virtual void restartRace(); virtual void restartRace();
void disableRace(); // Put race into limbo phase 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]; } PlayerKart *getPlayerKart(int player) const { return m_player_karts[player]; }
unsigned int getCurrentNumLocalPlayers() const { return m_local_player_karts.size(); } unsigned int getCurrentNumLocalPlayers() const { return m_local_player_karts.size(); }
PlayerKart *getLocalPlayerKart(int n) const { return m_local_player_karts[n]; } PlayerKart *getLocalPlayerKart(int n) const { return m_local_player_karts[n]; }
@ -142,11 +150,19 @@ public:
Phase getPhase() const { return m_clock.getPhase(); } Phase getPhase() const { return m_clock.getPhase(); }
const Clock& getClock() const { return m_clock; } 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(); 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 pause();
void unpause(); 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; const GrandPrixData *cup=NULL;
int len = 3*getCharLength() // major, minor, difficulty int len = 3*getCharLength() // major, minor, difficulty
+ getCharLength(); // num karts + getCharLength(); // num karts
if(race_manager->getMajorMode()==RaceManager::RM_GRAND_PRIX) if(race_manager->getMajorMode()==RaceManager::MAJOR_MODE_GRAND_PRIX)
{ {
cup = race_manager->getGrandPrix(); cup = race_manager->getGrandPrix();
len += getStringLength(cup->getId()); len += getStringLength(cup->getId());
@ -54,7 +54,7 @@ RaceInfoMessage::RaceInfoMessage(const std::vector<RemoteKartInfo>& kart_info)
addChar(race_manager->getMinorMode() ); addChar(race_manager->getMinorMode() );
addChar(race_manager->getDifficulty()); addChar(race_manager->getDifficulty());
addChar(race_manager->getNumKarts() ); addChar(race_manager->getNumKarts() );
if(race_manager->getMajorMode()==RaceManager::RM_GRAND_PRIX) if(race_manager->getMajorMode()==RaceManager::MAJOR_MODE_GRAND_PRIX)
addString(cup->getName()); addString(cup->getName());
else else
{ {
@ -77,11 +77,11 @@ RaceInfoMessage::RaceInfoMessage(const std::vector<RemoteKartInfo>& kart_info)
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
RaceInfoMessage::RaceInfoMessage(ENetPacket* pkt):Message(pkt, MT_RACE_INFO) RaceInfoMessage::RaceInfoMessage(ENetPacket* pkt):Message(pkt, MT_RACE_INFO)
{ {
race_manager->setMajorMode ( RaceManager::RaceModeType(getChar()) ); race_manager->setMajorMode ( RaceManager::MajorRaceModeType(getChar()) );
race_manager->setMinorMode ( RaceManager::RaceModeType(getChar()) ); race_manager->setMinorMode ( RaceManager::MinorRaceModeType(getChar()) );
race_manager->setDifficulty( RaceManager::Difficulty (getChar()) ); race_manager->setDifficulty( RaceManager::Difficulty (getChar()) );
race_manager->setNumKarts ( getChar() ); race_manager->setNumKarts ( getChar() );
if(race_manager->getMajorMode()==RaceManager::RM_GRAND_PRIX) if(race_manager->getMajorMode()==RaceManager::MAJOR_MODE_GRAND_PRIX)
{ {
GrandPrixData cup; GrandPrixData cup;
grand_prix_manager->getGrandPrix(getString()); 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_num_karts = user_config->m_karts;
m_difficulty = RD_HARD; m_difficulty = RD_HARD;
m_major_mode = RM_SINGLE; m_major_mode = MAJOR_MODE_SINGLE;
m_minor_mode = RM_QUICK_RACE; m_minor_mode = MINOR_MODE_QUICK_RACE;
m_track_number = 0; m_track_number = 0;
m_active_race = false; m_active_race = false;
m_score_for_position = stk_config->m_scores; m_score_for_position = stk_config->m_scores;
@ -191,7 +191,7 @@ void RaceManager::computeRandomKartList()
*/ */
void RaceManager::startNew() 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_tracks = m_grand_prix.getTracks();
m_num_laps = m_grand_prix.getLaps(); 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, // In follow the leader mode do not change the first kart,
// since it's always the leader. // 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()); std::sort(m_kart_status.begin()+offset, m_kart_status.end());
//reverse kart order if flagged in stk_config //reverse kart order if flagged in stk_config
@ -262,12 +262,12 @@ void RaceManager::startNextRace()
// and need world to be defined. // and need world to be defined.
/* /*
RM_GRAND_PRIX, RM_SINGLE, MAJOR_MODE_GRAND_PRIX, MAJOR_MODE_SINGLE,
RM_QUICK_RACE, RM_TIME_TRIAL, RM_FOLLOW_LEADER MINOR_MODE_QUICK_RACE, MINOR_MODE_TIME_TRIAL, MINOR_MODE_FOLLOW_LEADER
FIXME FIXME
*/ */
if(m_minor_mode==RM_FOLLOW_LEADER) new FollowTheLeaderRace(); if(m_minor_mode==MINOR_MODE_FOLLOW_LEADER) new FollowTheLeaderRace();
else new StandardRace(); else new StandardRace();
m_active_race = true; m_active_race = true;
@ -300,7 +300,7 @@ void RaceManager::exit_race()
{ {
// Only display the grand prix result screen if all tracks // Only display the grand prix result screen if all tracks
// were finished, and not when a race is aborted. // 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(); unlock_manager->grandPrixFinished();
menu_manager->switchToGrandPrixEnding(); 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, // In follow the leader mode, kart 0 does not get any points,
// so the position of each kart is actually one better --> decrease pos // so the position of each kart is actually one better --> decrease pos
int pos = kart->getPosition(); int pos = kart->getPosition();
if(m_minor_mode==RM_FOLLOW_LEADER) if(m_minor_mode==MINOR_MODE_FOLLOW_LEADER)
{ {
pos--; pos--;
// If the position is negative (i.e. follow leader and kart on // 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 class RaceManager
{ {
public: public:
/** Major and minor game modes. This type should be split into two /** The major types or races supported in STK
* types: MajorRaceModeType and MinorRaceModeType. Differentiating these */
* two types allows a GP to consist of mixture oftime trial, crazy race, enum MajorRaceModeType
* and FollowTheLeader modes. */ {
enum RaceModeType { RM_GRAND_PRIX, RM_SINGLE, // The two current major modes MAJOR_MODE_GRAND_PRIX,
RM_QUICK_RACE, RM_TIME_TRIAL, RM_FOLLOW_LEADER }; 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. */ /** Difficulty. Atm skidding is implemented as a special difficulty. */
enum Difficulty { RD_EASY, RD_MEDIUM, RD_HARD, RD_SKIDDING }; enum Difficulty { RD_EASY, RD_MEDIUM, RD_HARD, RD_SKIDDING };
@ -103,7 +112,8 @@ private:
std::vector<KartStatus> m_kart_status; std::vector<KartStatus> m_kart_status;
Difficulty m_difficulty; Difficulty m_difficulty;
RaceModeType m_major_mode, m_minor_mode; MajorRaceModeType m_major_mode;
MinorRaceModeType m_minor_mode;
typedef std::vector<std::string> PlayerKarts; typedef std::vector<std::string> PlayerKarts;
/** Stores remote kart information about all player karts. */ /** Stores remote kart information about all player karts. */
std::vector<RemoteKartInfo> m_player_karts; std::vector<RemoteKartInfo> m_player_karts;
@ -154,34 +164,37 @@ public:
void setDifficulty(Difficulty diff); void setDifficulty(Difficulty diff);
void setNumLaps(int num) { m_num_laps.clear(); void setNumLaps(int num) { m_num_laps.clear();
m_num_laps.push_back(num); } m_num_laps.push_back(num); }
void setMajorMode(RaceModeType mode){ m_major_mode = mode; } void setMajorMode(MajorRaceModeType mode)
void setMinorMode(RaceModeType mode){ m_minor_mode = mode; } { 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; }
void setCoinTarget(int num) { m_coin_target = num; } void setCoinTarget(int num) { m_coin_target = num; }
RaceModeType getMajorMode() const { return m_major_mode; } MajorRaceModeType
RaceModeType getMinorMode() const { return m_minor_mode; } getMajorMode() const { return m_major_mode; }
MinorRaceModeType
getMinorMode() const { return m_minor_mode; }
unsigned int getNumKarts() const { return m_num_karts; } unsigned int getNumKarts() const { return m_num_karts; }
unsigned int getNumPlayers() const { return m_player_karts.size(); } unsigned int getNumPlayers() const { return m_player_karts.size(); }
int getNumLaps() const { return m_num_laps[m_track_number];} int getNumLaps() const { return m_num_laps[m_track_number];}
Difficulty getDifficulty() const { return m_difficulty; } Difficulty getDifficulty() const { return m_difficulty; }
const std::string& const std::string& getTrackName() const { return m_tracks[m_track_number]; }
getTrackName() const { return m_tracks[m_track_number]; } const GrandPrixData *getGrandPrix() const { return &m_grand_prix; }
const GrandPrixData
*getGrandPrix() const { return &m_grand_prix; }
unsigned int getFinishedKarts() const { return m_num_finished_karts; } unsigned int getFinishedKarts() const { return m_num_finished_karts; }
unsigned int getFinishedPlayers() const { return m_num_finished_players; } unsigned int getFinishedPlayers() const { return m_num_finished_players; }
const std::string& const std::string& getHerringStyle() const { return m_grand_prix.getHerringStyle(); }
getHerringStyle() const { return m_grand_prix.getHerringStyle(); }
const std::string& const std::string&
getKartName(int kart) const { return m_kart_status[kart].m_ident;} getKartName(int kart) const { return m_kart_status[kart].m_ident;}
int getKartScore(int krt) const { return m_kart_status[krt].m_score; } 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 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 getKartLocalPlayerId(int k)
int getKartGlobalPlayerId(int k) const { return m_kart_status[k].m_global_player_id; } 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;} 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;} KartType getKartType(int kart) const { return m_kart_status[kart].m_kart_type;}
int getCoinTarget() const { return m_coin_target; } 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 getPositionScore(int p) const { return m_score_for_position[p-1]; }
int allPlayerFinished() const {return int allPlayerFinished() const {return
m_num_finished_players==m_player_karts.size();} 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 // 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) // 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() && getPosition() < RaceManager::getKart(0)->getPosition() &&
getInitialPosition()>1 ) 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 ;} if ( htype=='S' || htype=='s' ) { type = HE_SILVER ;}
// Time trial does not have any red herrings // 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; return;
Vec3 loc((*xyz)); Vec3 loc((*xyz));
herring_manager->newHerring(type, loc); herring_manager->newHerring(type, loc);