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

Mostly cosmetic change: renamed RD_EASY etc to

Browse Source 
DIFFICULTY_EASY to make it easier to understand;and
removed separate DIFFICULTY_COUNT constant and
replaced it with an entry in the enum (this means
one less change if a difficulty is added). 
Changed layout to be closer to our style in race_manager.hpp.


git-svn-id: svn+ssh://svn.code.sf.net/p/supertuxkart/code/main/trunk@11733 178a84e3-b1eb-0310-8ba1-8eac791a3b58
This commit is contained in:
hikerstk 2012-10-21 23:06:33 +00:00
parent 68711524bf
commit 7d33125f54
20 changed files with 377 additions and 254 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/challenges/challenge.cpp
View File

@ -99,8 +99,8 @@ const char* boolstr(bool b)
void Challenge::save(std::ofstream& writer)
{
writer << " <" << m_data->getId().c_str() << ">\n"
<< " <easy solved=\"" << boolstr(isSolved(RaceManager::RD_EASY)) << "\"/>\n"
<< " <medium solved=\"" << boolstr(isSolved(RaceManager::RD_MEDIUM)) << "\"/>\n"
<< " <hard solved=\"" << boolstr(isSolved(RaceManager::RD_HARD)) << "\"/>\n"
<< " <easy solved=\"" << boolstr(isSolved(RaceManager::DIFFICULTY_EASY)) << "\"/>\n"
<< " <medium solved=\"" << boolstr(isSolved(RaceManager::DIFFICULTY_MEDIUM)) << "\"/>\n"
<< " <hard solved=\"" << boolstr(isSolved(RaceManager::DIFFICULTY_HARD)) << "\"/>\n"
<< " </" << m_data->getId().c_str() << ">\n";
} // save

6
src/challenges/challenge.hpp
View File

@ -56,9 +56,9 @@ public:
Challenge(ChallengeData* data)
{
m_data = data;
m_state[RaceManager::RD_EASY] = CH_INACTIVE;
m_state[RaceManager::RD_MEDIUM] = CH_INACTIVE;
m_state[RaceManager::RD_HARD] = CH_INACTIVE;
m_state[RaceManager::DIFFICULTY_EASY] = CH_INACTIVE;
m_state[RaceManager::DIFFICULTY_MEDIUM] = CH_INACTIVE;
m_state[RaceManager::DIFFICULTY_HARD] = CH_INACTIVE;
}
virtual ~Challenge() {};
void load(const XMLNode* config);

2
src/challenges/challenge_data.cpp
View File

@ -45,7 +45,7 @@ ChallengeData::ChallengeData(const std::string& filename)
m_version = 0;
m_num_trophies = 0;
for (int d=0; d<RaceManager::DIFFICULTY_COUNT; d++)
for (int d=0; d<=RaceManager::DIFFICULTY_COUNT; d++)
{
m_num_karts[d] = -1;
m_position[d] = -1;

42
src/challenges/game_slot.cpp
View File

@ -61,32 +61,32 @@ void GameSlot::computeActive()
// all features, so unlock the solved ones (and don't try to
// save the state, since we are currently reading it)
if (i->second->isSolved(RaceManager::RD_EASY))
if (i->second->isSolved(RaceManager::DIFFICULTY_EASY))
{
unlockFeature(i->second, RaceManager::RD_EASY, /*save*/ false);
unlockFeature(i->second, RaceManager::DIFFICULTY_EASY, /*save*/ false);
}
if (i->second->isSolved(RaceManager::RD_MEDIUM))
if (i->second->isSolved(RaceManager::DIFFICULTY_MEDIUM))
{
unlockFeature(i->second, RaceManager::RD_MEDIUM, /*save*/ false);
unlockFeature(i->second, RaceManager::DIFFICULTY_MEDIUM, /*save*/ false);
}
if (i->second->isSolved(RaceManager::RD_HARD))
if (i->second->isSolved(RaceManager::DIFFICULTY_HARD))
{
unlockFeature(i->second, RaceManager::RD_HARD, /*save*/ false);
unlockFeature(i->second, RaceManager::DIFFICULTY_HARD, /*save*/ false);
}
if (i->second->isSolved(RaceManager::RD_HARD))
if (i->second->isSolved(RaceManager::DIFFICULTY_HARD))
{
m_points += CHALLENGE_POINTS[RaceManager::RD_HARD];
m_points += CHALLENGE_POINTS[RaceManager::DIFFICULTY_HARD];
m_hard_challenges++;
}
else if (i->second->isSolved(RaceManager::RD_MEDIUM))
else if (i->second->isSolved(RaceManager::DIFFICULTY_MEDIUM))
{
m_points += CHALLENGE_POINTS[RaceManager::RD_MEDIUM];
m_points += CHALLENGE_POINTS[RaceManager::DIFFICULTY_MEDIUM];
m_medium_challenges++;
}
else if (i->second->isSolved(RaceManager::RD_EASY))
else if (i->second->isSolved(RaceManager::DIFFICULTY_EASY))
{
m_points += CHALLENGE_POINTS[RaceManager::RD_EASY];
m_points += CHALLENGE_POINTS[RaceManager::DIFFICULTY_EASY];
m_easy_challenges++;
}
}
@ -97,25 +97,25 @@ void GameSlot::computeActive()
lockFeature(i->second);
}
if (i->second->isSolved(RaceManager::RD_HARD))
if (i->second->isSolved(RaceManager::DIFFICULTY_HARD))
{
// challenge beaten at hardest, nothing more to do here
continue;
}
else if (i->second->isSolved(RaceManager::RD_MEDIUM))
else if (i->second->isSolved(RaceManager::DIFFICULTY_MEDIUM))
{
i->second->setActive(RaceManager::RD_HARD);
i->second->setActive(RaceManager::DIFFICULTY_HARD);
}
else if (i->second->isSolved(RaceManager::RD_EASY))
else if (i->second->isSolved(RaceManager::DIFFICULTY_EASY))
{
i->second->setActive(RaceManager::RD_HARD);
i->second->setActive(RaceManager::RD_MEDIUM);
i->second->setActive(RaceManager::DIFFICULTY_HARD);
i->second->setActive(RaceManager::DIFFICULTY_MEDIUM);
}
else
{
i->second->setActive(RaceManager::RD_HARD);
i->second->setActive(RaceManager::RD_MEDIUM);
i->second->setActive(RaceManager::RD_EASY);
i->second->setActive(RaceManager::DIFFICULTY_HARD);
i->second->setActive(RaceManager::DIFFICULTY_MEDIUM);
i->second->setActive(RaceManager::DIFFICULTY_EASY);
}
} // for i

2
src/graphics/slip_stream.cpp
View File

@ -303,7 +303,7 @@ void SlipStream::updateSlipstreamPower()
{
// Low level AIs should not do any slipstreaming.
if(!m_kart->getController()->isPlayerController() &&
race_manager->getDifficulty()==RaceManager::RD_EASY) return;
race_manager->getDifficulty()==RaceManager::DIFFICULTY_EASY) return;
// See if we are currently using accumulated slipstream credits:
// -------------------------------------------------------------

8
src/karts/controller/default_ai_controller.cpp
View File

@ -60,7 +60,7 @@ DefaultAIController::DefaultAIController(AbstractKart *kart)
switch( race_manager->getDifficulty())
{
case RaceManager::RD_EASY:
case RaceManager::DIFFICULTY_EASY:
m_wait_for_players = true;
m_make_use_of_slipstream = false;
m_max_handicap_speed = 0.9f;
@ -73,7 +73,7 @@ DefaultAIController::DefaultAIController(AbstractKart *kart)
m_handle_bomb = false;
setSkiddingFraction(4.0f);
break;
case RaceManager::RD_MEDIUM:
case RaceManager::DIFFICULTY_MEDIUM:
m_wait_for_players = true;
m_make_use_of_slipstream = false;
m_max_handicap_speed = 0.95f;
@ -86,7 +86,7 @@ DefaultAIController::DefaultAIController(AbstractKart *kart)
m_handle_bomb = true;
setSkiddingFraction(3.0f);
break;
case RaceManager::RD_HARD:
case RaceManager::DIFFICULTY_HARD:
m_wait_for_players = false;
m_make_use_of_slipstream = true;
m_max_handicap_speed = 1.0f;
@ -102,6 +102,8 @@ DefaultAIController::DefaultAIController(AbstractKart *kart)
m_handle_bomb = true;
setSkiddingFraction(2.0f);
break;
case RaceManager::DIFFICULTY_COUNT:
assert(0); // keep the compiler happy
}
#ifdef AI_DEBUG

8
src/karts/controller/present_ai.cpp
View File

@ -63,7 +63,7 @@ PresentAI::PresentAI(AbstractKart *kart)
switch( race_manager->getDifficulty())
{
case RaceManager::RD_EASY:
case RaceManager::DIFFICULTY_EASY:
m_wait_for_players = true;
m_make_use_of_slipstream = false;
m_max_handicap_speed = 0.9f;
@ -76,7 +76,7 @@ PresentAI::PresentAI(AbstractKart *kart)
m_handle_bomb = false;
setSkiddingFraction(4.0f);
break;
case RaceManager::RD_MEDIUM:
case RaceManager::DIFFICULTY_MEDIUM:
m_wait_for_players = true;
m_make_use_of_slipstream = false;
m_max_handicap_speed = 0.95f;
@ -89,7 +89,7 @@ PresentAI::PresentAI(AbstractKart *kart)
m_handle_bomb = true;
setSkiddingFraction(3.0f);
break;
case RaceManager::RD_HARD:
case RaceManager::DIFFICULTY_HARD:
m_wait_for_players = false;
m_make_use_of_slipstream = true;
m_max_handicap_speed = 1.0f;
@ -105,6 +105,8 @@ PresentAI::PresentAI(AbstractKart *kart)
m_handle_bomb = true;
setSkiddingFraction(2.0f);
break;
case RaceManager::DIFFICULTY_COUNT:
assert(0); // keep the compiler happy
}
#ifdef AI_DEBUG

8
src/karts/controller/skidding_ai.cpp
View File

@ -83,7 +83,7 @@ SkiddingAI::SkiddingAI(AbstractKart *kart)
switch( race_manager->getDifficulty())
{
case RaceManager::RD_EASY:
case RaceManager::DIFFICULTY_EASY:
m_wait_for_players = true;
m_make_use_of_slipstream = false;
m_max_handicap_speed = 0.9f;
@ -97,7 +97,7 @@ SkiddingAI::SkiddingAI(AbstractKart *kart)
m_handle_bomb = false;
setSkiddingFraction(4.0f);
break;
case RaceManager::RD_MEDIUM:
case RaceManager::DIFFICULTY_MEDIUM:
m_wait_for_players = true;
m_make_use_of_slipstream = false;
m_max_handicap_speed = 0.95f;
@ -111,7 +111,7 @@ SkiddingAI::SkiddingAI(AbstractKart *kart)
m_handle_bomb = true;
setSkiddingFraction(3.0f);
break;
case RaceManager::RD_HARD:
case RaceManager::DIFFICULTY_HARD:
m_wait_for_players = false;
m_make_use_of_slipstream = true;
m_max_handicap_speed = 1.0f;
@ -128,6 +128,8 @@ SkiddingAI::SkiddingAI(AbstractKart *kart)
m_handle_bomb = true;
setSkiddingFraction(2.0f);
break;
case RaceManager::DIFFICULTY_COUNT:
assert(0); // keep the compiler happy
}
m_point_selection_algorithm = PSA_DEFAULT;
setControllerName("Skidding");

8
src/main.cpp
View File

@ -770,13 +770,13 @@ int handleCmdLine(int argc, char **argv)
switch (atoi(argv[i+1]))
{
case 1:
race_manager->setDifficulty(RaceManager::RD_EASY);
race_manager->setDifficulty(RaceManager::DIFFICULTY_EASY);
break;
case 2:
race_manager->setDifficulty(RaceManager::RD_MEDIUM);
race_manager->setDifficulty(RaceManager::DIFFICULTY_MEDIUM);
break;
case 3:
race_manager->setDifficulty(RaceManager::RD_HARD);
race_manager->setDifficulty(RaceManager::DIFFICULTY_HARD);
break;
}
i++;
@ -1432,7 +1432,7 @@ int main(int argc, char *argv[] )
// Profiling
// =========
race_manager->setMajorMode (RaceManager::MAJOR_MODE_SINGLE);
race_manager->setDifficulty(RaceManager::RD_HARD);
race_manager->setDifficulty(RaceManager::DIFFICULTY_HARD);
network_manager->setupPlayerKartInfo();
race_manager->startNew(false);
}

2
src/modes/demo_world.cpp
View File

@ -45,7 +45,7 @@ DemoWorld::DemoWorld()
ProfileWorld::setProfileModeLaps(m_num_laps);
race_manager->setReverseTrack(false);
race_manager->setMinorMode (RaceManager::MINOR_MODE_NORMAL_RACE);
race_manager->setDifficulty(RaceManager::RD_HARD);
race_manager->setDifficulty(RaceManager::DIFFICULTY_HARD);
race_manager->setNumKarts(m_num_karts);
race_manager->setNumLocalPlayers(1);
race_manager->setLocalKartInfo(0, UserConfigParams::m_default_kart);

2
src/modes/overworld.cpp
View File

@ -43,7 +43,7 @@ void OverWorld::enterOverWorld()
race_manager->setMinorMode (RaceManager::MINOR_MODE_OVERWORLD);
race_manager->setNumKarts( 1 );
race_manager->setTrack( "overworld" );
race_manager->setDifficulty(RaceManager::RD_HARD);
race_manager->setDifficulty(RaceManager::DIFFICULTY_HARD);
// Use keyboard 0 by default (FIXME: let player choose?)
InputDevice* device = input_manager->getDeviceList()->getKeyboard(0);

40
src/race/race_manager.cpp
View File

@ -54,7 +54,7 @@ RaceManager* race_manager= NULL;
RaceManager::RaceManager()
{
m_num_karts = UserConfigParams::m_num_karts;
m_difficulty = RD_HARD;
m_difficulty = DIFFICULTY_HARD;
m_major_mode = MAJOR_MODE_SINGLE;
m_minor_mode = MINOR_MODE_NORMAL_RACE;
m_ai_superpower = SUPERPOWER_NONE;
@ -451,21 +451,26 @@ void RaceManager::next()
*/
namespace computeGPRanksData
{
class SortData
{
public:
int m_score;
int m_position;
float m_race_time;
bool operator<(const SortData &a)
class SortData
{
return ( (m_score > a.m_score) ||
(m_score == a.m_score && m_race_time < a.m_race_time) );
}
public:
int m_score;
int m_position;
float m_race_time;
bool operator<(const SortData &a)
{
return ( (m_score > a.m_score) ||
(m_score == a.m_score && m_race_time < a.m_race_time) );
}
}; // SortData
}; // SortData
} // namespace
// ----------------------------------------------------------------------------
/** Sort karts and update the m_gp_rank KartStatus member, in preparation
* for future calls to RaceManager::getKartGPRank or
* RaceManager::getKartWithGPRank
*/
void RaceManager::computeGPRanks()
{
// calculate the rank of each kart
@ -654,13 +659,18 @@ void RaceManager::startGP(const GrandPrixData* gp, bool from_overworld)
}
//-----------------------------------------------------------------------------
void RaceManager::startSingleRace(const std::string trackIdent,
/** \brief Higher-level method to start a GP without having to care about
* the exact startup sequence.
* \param trackIdent Internal name of the track to race on
* \param num_laps Number of laps to race, or -1 if number of laps is
* not relevant in current mode
*/
void RaceManager::startSingleRace(const std::string &track_ident,
const int num_laps,
bool from_overworld)
{
StateManager::get()->enterGameState();
setTrack(trackIdent.c_str());
setTrack(track_ident.c_str());
if (num_laps != -1) setNumLaps( num_laps );

431
src/race/race_manager.hpp
View File

@ -90,9 +90,12 @@ public:
};
// quick method to tell the difference between battle modes and race modes
// think of it like a bitmask, but done in decimal to avoid endianness issues
// think of it like a bitmask, but done in decimal to avoid endianness
// issues
#define LINEAR_RACE(ID, COUNT_LAPSES) (1000+ID+100*COUNT_LAPSES)
#define BATTLE_ARENA(ID) (2000+ID)
// ------------------------------------------------------------------------
/** Minor variants to the major types of race.
* Make sure to use the 'LINEAR_RACE/BATTLE_ARENA' macros. */
enum MinorRaceModeType
@ -108,13 +111,16 @@ public:
MINOR_MODE_CUTSCENE = BATTLE_ARENA(1)
};
// ------------------------------------------------------------------------
/** True if the AI should have additional abbilities, e.g.
* nolik will get special bubble gums in the final challenge. */
enum AISuperPower
{
SUPERPOWER_NONE = 0,
SUPERPOWER_NONE = 0,
SUPERPOWER_NOLOK_BOSS = 1
};
// ------------------------------------------------------------------------
/** Returns a string identifier for each minor race mode.
* \param mode Minor race mode.
*/
@ -167,6 +173,7 @@ public:
}
}
// ------------------------------------------------------------------------
static bool hasAI(const MinorRaceModeType mode)
{
switch (mode)
@ -185,7 +192,8 @@ public:
* used from challenge_data, which reads the mode from a challenge file.
* \param name The name of the minor mode.
*/
static const MinorRaceModeType getModeIDFromInternalName(const std::string &name)
static const MinorRaceModeType getModeIDFromInternalName(
const std::string &name)
{
if (name==IDENT_STD ) return MINOR_MODE_NORMAL_RACE;
else if (name==IDENT_TTRIAL ) return MINOR_MODE_TIME_TRIAL;
@ -200,13 +208,15 @@ public:
#undef BATTLE_ARENA
/** Game difficulty. */
enum Difficulty { RD_EASY, RD_MEDIUM, RD_HARD };
static const int DIFFICULTY_COUNT = 3;
enum Difficulty { DIFFICULTY_EASY,
DIFFICULTY_MEDIUM,
DIFFICULTY_HARD,
DIFFICULTY_COUNT};
/** Different kart types: A local player, a player connected via network,
* an AI kart, the leader kart (currently not used), a ghost kart. */
enum KartType { KT_PLAYER, KT_NETWORK_PLAYER, KT_AI, KT_LEADER, KT_GHOST };
enum KartType { KT_PLAYER, KT_NETWORK_PLAYER, KT_AI, KT_LEADER,
KT_GHOST };
private:
bool m_started_from_overworld;
@ -215,18 +225,29 @@ private:
* each race. */
struct KartStatus
{
std::string m_ident; // The .tkkf filename without the .tkkf
std::string m_player_name; // for networked karts
int m_score; // score for this kart
int m_last_score; // needed for restart race, and for race results GUI.
float m_overall_time; // sum of times of all races
float m_last_time; // needed for restart
int m_prev_finish_pos; // previous finished position
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_rank; // In GPs, at the end, will hold the overall
// rank of this kart (0<=m_gp_rank < num_karts-1)
/** The kart identifier. */
std::string m_ident;
/** For networked karts. */
std::string m_player_name;
// Score for this kart. */
int m_score;
/** Needed for restart race, and for race results GUI. */
int m_last_score;
/** Sum of times of all races. */
float m_overall_time;
/** Needed for restart. */
float m_last_time;
/** Previous finished position. */
int m_prev_finish_pos;
/** Kart type: AI, player, network player etc. */
KartType m_kart_type;
/** Player controling the kart, for AI: -1 */
int m_local_player_id;
/** Global ID of player. */
int m_global_player_id;
/** In GPs, at the end, will hold the overall rank of this kart
* (0<=m_gp_rank < num_karts-1). */
int m_gp_rank;
KartStatus(const std::string& ident, const int& prev_finish_pos,
int local_player_id, int global_player_id,
@ -300,12 +321,12 @@ private:
Vec3 m_kart_last_position_on_overworld;
public:
RaceManager();
~RaceManager();
RaceManager();
~RaceManager();
/** Resets the race manager. It is called by world when restarting a race. */
void reset();
/** Resets the race manager. It is called by world when restarting a race.
*/
void reset();
/**
* \{
@ -316,122 +337,188 @@ public:
* \param player_id Id of the local player for which the kart is set.
* \param kart Kart name this player is using.
*/
void setLocalKartInfo(unsigned int player_id, const std::string& kart);
void setLocalKartInfo(unsigned int player_id, const std::string& kart);
/** Sets the number of local players playing on this computer (including
* split screen).
* \param n Number of local players.
*/
void setNumLocalPlayers(unsigned int n);
void setAIKartOverride(const std::string& kart) { m_ai_kart_override = kart; }
void setAISuperPower(AISuperPower superpower) { m_ai_superpower = superpower; }
AISuperPower getAISuperPower() const { return m_ai_superpower; }
void setNumLocalPlayers(unsigned int n);
/** In case of non GP mode set the track to use.
* \param track Pointer to the track to use.
*/
void setTrack(const std::string& track);
void setTrack(const std::string& track);
void setGrandPrix(const GrandPrixData &gp){ m_grand_prix = gp; m_coin_target = 0; }
/** \brief Sets the difficulty.
* \param diff Difficulty.
*/
void setDifficulty(Difficulty diff);
void setNumLaps(int num) { m_num_laps.clear();
m_num_laps.push_back(num); }
void setReverseTrack(bool r_t) { m_reverse_track.clear();
m_reverse_track.push_back(r_t); }
void setMajorMode(MajorRaceModeType mode)
{ m_major_mode = mode; }
void setMinorMode(MinorRaceModeType mode)
{ m_minor_mode = mode; }
void setNumKarts(int num) { m_num_karts = num;
m_ai_kart_override = "";
m_ai_superpower = SUPERPOWER_NONE;}
void setCoinTarget(int num) { m_coin_target = num; }
/** \} */
/** Sort karts and update the m_gp_rank KartStatus member, in preparation
* for future calls to RaceManager::getKartGPRank or RaceManager::getKartWithGPRank
*/
void computeGPRanks();
/** \{
* \name Getters
* Get current race manager state and settings
*/
const RemoteKartInfo&
getLocalKartInfo(unsigned int n) const { return m_local_player_karts[n]; }
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; }
MajorRaceModeType
getMajorMode() const { return m_major_mode; }
MinorRaceModeType
getMinorMode() const { return m_minor_mode; }
unsigned int getNumPlayers() const { return m_player_karts.size(); }
/** \brief Returns the number lf laps.
* In case of FTL or battle mode always return 9999, since they don't have laps.
* This avoids problems in FTL GP, since in this case no laps would be set
* (otherwise we would need many more tests in calls to getNumLaps).
*/
int getNumLaps() const
{
if(m_minor_mode==MINOR_MODE_3_STRIKES || m_minor_mode==MINOR_MODE_FOLLOW_LEADER)
return 9999;
return m_num_laps[m_track_number];
} // getNumLaps
// ------------------------------------------------------------------------
/** \return whether the track should be reversed */
bool getReverseTrack() const { return m_reverse_track[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; }
unsigned int getFinishedKarts() const { return m_num_finished_karts; }
unsigned int getFinishedPlayers() const { return m_num_finished_players; }
int getKartGPRank(const int kart_id)
const { return m_kart_status[kart_id].m_gp_rank; }
/** \brief Returns the kart with a given GP rank (or NULL if no such kart exists).
/** \brief Returns the kart with a given GP rank (or NULL if no such
* kart exists).
* \param n Rank (0<=n<num_karts) to look for.
*/
const AbstractKart* getKartWithGPRank(unsigned int n);
/** \return the GP rank of a local player, or -1 if the given player ID doesn't exist */
int getLocalPlayerGPRank(const int playerID) const;
/** \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;}
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; }
float 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; }
int getPositionScore(int p) const { return m_score_for_position[p-1]; }
int getTrackNumber() const { return m_track_number; }
/** Sort karts and update the m_gp_rank KartStatus member, in preparation
* for future calls to RaceManager::getKartGPRank or
* RaceManager::getKartWithGPRank
*/
void computeGPRanks();
/** \brief Sets the difficulty.
* \param diff Difficulty.
*/
void setDifficulty(Difficulty diff);
// ------------------------------------------------------------------------
void setGrandPrix(const GrandPrixData &gp)
{
m_grand_prix = gp;
m_coin_target = 0;
}
// ------------------------------------------------------------------------
void setAIKartOverride(const std::string& kart)
{
m_ai_kart_override = kart;
}
// ------------------------------------------------------------------------
void setAISuperPower(AISuperPower superpower)
{
m_ai_superpower = superpower;
}
// ------------------------------------------------------------------------
AISuperPower getAISuperPower() const { return m_ai_superpower; }
// ------------------------------------------------------------------------
void setNumLaps(int num) {
m_num_laps.clear();
m_num_laps.push_back(num);
}
// ------------------------------------------------------------------------
void setReverseTrack(bool r_t)
{
m_reverse_track.clear();
m_reverse_track.push_back(r_t);
}
// ------------------------------------------------------------------------
void setMajorMode(MajorRaceModeType mode) { m_major_mode = mode; }
// ------------------------------------------------------------------------
void setMinorMode(MinorRaceModeType mode) { m_minor_mode = mode; }
// ------------------------------------------------------------------------
void setNumKarts(int num)
{
m_num_karts = num;
m_ai_kart_override = "";
m_ai_superpower = SUPERPOWER_NONE;
}
// ------------------------------------------------------------------------
void setCoinTarget(int num) { m_coin_target = num; }
/** \} */
// ------------------------------------------------------------------------
/** \{
* \name Getters
* Get current race manager state and settings
*/
const RemoteKartInfo& getLocalKartInfo(unsigned int n) const
{
return m_local_player_karts[n];
}
// ------------------------------------------------------------------------
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; }
// ------------------------------------------------------------------------
MajorRaceModeType getMajorMode() const { return m_major_mode; }
// ------------------------------------------------------------------------
MinorRaceModeType getMinorMode() const { return m_minor_mode; }
// ------------------------------------------------------------------------
unsigned int getNumPlayers() const { return m_player_karts.size(); }
// ------------------------------------------------------------------------
/** \brief Returns the number lf laps.
* In case of FTL or battle mode always return 9999, since they don't
* have laps. This avoids problems in FTL GP, since in this case no laps
* would be set (otherwise we would need many more tests in calls to
* getNumLaps).
*/
int getNumLaps() const
{
if(m_minor_mode==MINOR_MODE_3_STRIKES ||
m_minor_mode==MINOR_MODE_FOLLOW_LEADER )
return 9999;
return m_num_laps[m_track_number];
} // getNumLaps
// ------------------------------------------------------------------------
/** \return whether the track should be reversed */
bool getReverseTrack() const { return m_reverse_track[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; }
// ------------------------------------------------------------------------
unsigned int getFinishedKarts() const { return m_num_finished_karts; }
// ------------------------------------------------------------------------
unsigned int getFinishedPlayers() const { return m_num_finished_players; }
// ------------------------------------------------------------------------
int getKartGPRank(const int kart_id)const
{
return m_kart_status[kart_id].m_gp_rank;
}
// ------------------------------------------------------------------------
const std::string& getKartIdent(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;
}
// ------------------------------------------------------------------------
float 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; }
// ------------------------------------------------------------------------
int getPositionScore(int p) const { return m_score_for_position[p-1]; }
// ------------------------------------------------------------------------
int getTrackNumber() const { return m_track_number; }
// ------------------------------------------------------------------------
/** Returns the list of AI karts to use. Used for networking, and for
* the --ai= command line option. */
const std::vector<std::string>&
getAIKartList() const { return m_ai_kart_list; }
const std::vector<std::string>& getAIKartList() const
{
return m_ai_kart_list;
}
// ------------------------------------------------------------------------
/** \brief get information about given mode (returns true if 'mode' is of
* linear races type) */
@ -442,18 +529,18 @@ public:
// and BATTLE_ARENA above for exact meaning.
if(id > 999 && id < 2000) return true;
else return false;
}
} // isLinearRaceMode
// ------------------------------------------------------------------------
/** \brief Returns true if the current mode is a battle mode. */
bool isBattleMode()
{
const int id = (int)m_minor_mode;
// This uses the numerical id of the mode, see the macros LINEAR_RACE and
// BATTLE_ARENA above for exact meaning.
// This uses the numerical id of the mode, see the macros
// LINEAR_RACE and BATTLE_ARENA above for exact meaning.
if (id >= 2000) return true;
else return false;
}
} // isBattleMode
// ------------------------------------------------------------------------
/** \brief Returns true if the current mode has laps. */
@ -464,21 +551,22 @@ public:
// See meaning of IDs above
const int answer = (id-1000)/100;
return answer!=0;
}
} // modeHasLaps
// ------------------------------------------------------------------------
/** Returns true if the currently selected minor mode has highscores. */
bool modeHasHighscores()
{
//FIXME: this information is duplicated. RaceManager knows about it, and
// each World may set m_use_highscores to true or false. The reason
// for this duplication is that we might want to know whether to
// display highscores without creating a World.
//FIXME: this information is duplicated. RaceManager knows about it,
// and each World may set m_use_highscores to true or false.
// The reason for this duplication is that we might want to know
// whether to display highscores without creating a World.
return m_minor_mode != MINOR_MODE_3_STRIKES &&
m_minor_mode != MINOR_MODE_FOLLOW_LEADER;
}
} // modeHasHighscore
/** \} */
// ------------------------------------------------------------------------
/**
* \{
* \name Controlling race
@ -487,36 +575,38 @@ public:
/**
* \brief Starts a new race or GP (or other mode).
* It sets up the list of player karts, AI karts, GP tracks if relevant etc.
* \pre The list of AI karts to use must be set up first. This is usually being
* done by a call to computeRandomKartList() from
* It sets up the list of player karts, AI karts, GP tracks if relevant
* etc.
* \pre The list of AI karts to use must be set up first. This is
* usually being done by a call to computeRandomKartList() from
* NetworkManager::setupPlayerKartInfo, but could be done differently
* (e.g. depending on user command line options to test certain AIs)
*/
void startNew(bool from_overworld);
void startNew(bool from_overworld);
/** \brief Start the next race or go back to the start screen
* If there are more races to do, starts the next race, otherwise
* calls exitRace to finish the race.
*/
void next();
void next();
/** \brief Rerun the same race again
* This is called after a race is finished, and it will adjust
* the number of points and the overall time before restarting the race.
*/
void rerunRace();
void rerunRace();
/** \brief Exit a race (and don't start the next one)
* \note In GP, displays the GP result screen first
* \note Deletes the world.
*/
void exitRace(bool delete_world=true);
void exitRace(bool delete_world=true);
/**
* \brief Higher-level method to start a GP without having to care about the exact startup sequence
* \brief Higher-level method to start a GP without having to care about
* the exact startup sequence
*/
void startGP(const GrandPrixData* gp, bool from_overworld);
void startGP(const GrandPrixData* gp, bool from_overworld);
/**
* \brief Higher-level method to start a GP without having to care about
@ -525,20 +615,27 @@ public:
* \param num_laps Number of laps to race, or -1 if number of laps is
* not relevant in current mode
*/
void startSingleRace(const std::string trackIdent, const int num_laps,
bool from_overworld);
void startSingleRace(const std::string &track_ident, const int num_laps,
bool from_overworld);
bool raceWasStartedFromOverworld() const { return m_started_from_overworld; }
bool raceWasStartedFromOverworld() const
{
return m_started_from_overworld;
}
/** \} */
// ------------------------------------------------------------------------
/**
* \{
* \name Callbacks from the race classes
* These methods are to be used by the classes that manage the various races, to let
* the race manager know about current status
* These methods are to be used by the classes that manage the various
* races, to let the race manager know about current status
*/
bool allPlayerFinished() const {return m_num_finished_players==m_player_karts.size();}
bool allPlayerFinished() const
{
return m_num_finished_players==m_player_karts.size();
}
// ------------------------------------------------------------------------
void kartFinishedRace(const AbstractKart* kart, float time);
/** \} */
@ -549,29 +646,39 @@ public:
* Functions for internal use by RaceManager or its close friends;
* You shouldn't need to call any of those from higher-level code.
*/
void setNumPlayers(int num);
void setNumPlayers(int num);
void setPlayerKart(unsigned int player_id,
const RemoteKartInfo& ki);
void setDefaultAIKartList(const std::vector<std::string> &ai_list);
void computeRandomKartList();
void setPlayerKart(unsigned int player_id,
const RemoteKartInfo& ki);
void setDefaultAIKartList(const std::vector<std::string> &ai_list);
void computeRandomKartList();
/** Sets the AI to use. This is used in networking mode to set the karts
* that will be used by the server to the client. It will take precedence
* over the random selection. */
void setAIKartList(const std::vector<std::string>& rkl)
{ m_ai_kart_list = rkl; }
void setAIKartList(const std::vector<std::string>& rkl)
{
m_ai_kart_list = rkl;
}
/** \} */
bool haveKartLastPositionOnOverworld() { return m_have_kart_last_position_on_overworld; }
void setKartLastPositionOnOverworld(Vec3 pos)
// ------------------------------------------------------------------------
bool haveKartLastPositionOnOverworld()
{
return m_have_kart_last_position_on_overworld;
}
// ------------------------------------------------------------------------
void setKartLastPositionOnOverworld(Vec3 pos)
{
m_have_kart_last_position_on_overworld = true;
m_kart_last_position_on_overworld = pos;
}
Vec3 getKartLastPositionOnOverworld() { return m_kart_last_position_on_overworld; }
// ------------------------------------------------------------------------
Vec3 getKartLastPositionOnOverworld()
{
return m_kart_last_position_on_overworld;
}
};
}; // RaceManager
extern RaceManager *race_manager;
#endif

18
src/states_screens/dialogs/select_challenge.cpp
View File

@ -87,21 +87,21 @@ SelectChallengeDialog::SelectChallengeDialog(const float percentWidth,
const Challenge* c = unlock_manager->getCurrentSlot()->getChallenge(challenge_id);
if (c->isSolved(RaceManager::RD_EASY))
if (c->isSolved(RaceManager::DIFFICULTY_EASY))
{
IconButtonWidget* btn = getWidget<IconButtonWidget>("novice");
btn->setImage(file_manager->getTextureFile("cup_bronze.png").c_str(),
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE);
}
if (c->isSolved(RaceManager::RD_MEDIUM))
if (c->isSolved(RaceManager::DIFFICULTY_MEDIUM))
{
IconButtonWidget* btn = getWidget<IconButtonWidget>("intermediate");
btn->setImage(file_manager->getTextureFile("cup_silver.png").c_str(),
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE);
}
if (c->isSolved(RaceManager::RD_HARD))
if (c->isSolved(RaceManager::DIFFICULTY_HARD))
{
IconButtonWidget* btn = getWidget<IconButtonWidget>("expert");
btn->setImage(file_manager->getTextureFile("cup_gold.png").c_str(),
@ -113,9 +113,9 @@ SelectChallengeDialog::SelectChallengeDialog(const float percentWidth,
LabelWidget* medium_label = getWidget<LabelWidget>("intermediate_label");
LabelWidget* expert_label = getWidget<LabelWidget>("difficult_label");
novice_label->setText( getLabel(RaceManager::RD_EASY, c->getData()), false );
medium_label->setText( getLabel(RaceManager::RD_MEDIUM, c->getData()), false );
expert_label->setText( getLabel(RaceManager::RD_HARD, c->getData()), false );
novice_label->setText( getLabel(RaceManager::DIFFICULTY_EASY, c->getData()), false );
medium_label->setText( getLabel(RaceManager::DIFFICULTY_MEDIUM, c->getData()), false );
expert_label->setText( getLabel(RaceManager::DIFFICULTY_HARD, c->getData()), false );
if (c->getData()->getMajorMode() == RaceManager::MAJOR_MODE_GRAND_PRIX)
{
@ -189,17 +189,17 @@ GUIEngine::EventPropagation SelectChallengeDialog::processEvent(const std::strin
// Launch challenge
if (eventSource == "novice")
{
challenge->setRace(RaceManager::RD_EASY);
challenge->setRace(RaceManager::DIFFICULTY_EASY);
UserConfigParams::m_difficulty = 0;
}
else if (eventSource == "intermediate")
{
challenge->setRace(RaceManager::RD_MEDIUM);
challenge->setRace(RaceManager::DIFFICULTY_MEDIUM);
UserConfigParams::m_difficulty = 1;
}
else if (eventSource == "expert")
{
challenge->setRace(RaceManager::RD_HARD);
challenge->setRace(RaceManager::DIFFICULTY_HARD);
UserConfigParams::m_difficulty = 2;
}
else

18
src/states_screens/feature_unlocked.cpp
View File

@ -146,17 +146,17 @@ void FeatureUnlockedCutScene::addTrophy(RaceManager::Difficulty difficulty)
core::stringw msg;
switch (difficulty)
{
case RaceManager::RD_EASY:
case RaceManager::DIFFICULTY_EASY:
msg = _("You completed the easy challenge! This trophy is worth %i points",
CHALLENGE_POINTS[RaceManager::RD_EASY]);
CHALLENGE_POINTS[RaceManager::DIFFICULTY_EASY]);
break;
case RaceManager::RD_MEDIUM:
case RaceManager::DIFFICULTY_MEDIUM:
msg = _("You completed the intermediate challenge! This trophy is worth %i points",
CHALLENGE_POINTS[RaceManager::RD_MEDIUM]);
CHALLENGE_POINTS[RaceManager::DIFFICULTY_MEDIUM]);
break;
case RaceManager::RD_HARD:
case RaceManager::DIFFICULTY_HARD:
msg = _("You completed the difficult challenge! This trophy is worth %i points",
CHALLENGE_POINTS[RaceManager::RD_HARD]);
CHALLENGE_POINTS[RaceManager::DIFFICULTY_HARD]);
break;
default:
assert(false);
@ -165,13 +165,13 @@ void FeatureUnlockedCutScene::addTrophy(RaceManager::Difficulty difficulty)
std::string model;
switch (difficulty)
{
case RaceManager::RD_EASY:
case RaceManager::DIFFICULTY_EASY:
model = file_manager->getModelFile("trophy_bronze.b3d");
break;
case RaceManager::RD_MEDIUM:
case RaceManager::DIFFICULTY_MEDIUM:
model = file_manager->getModelFile("trophy_silver.b3d");
break;
case RaceManager::RD_HARD:
case RaceManager::DIFFICULTY_HARD:
model = file_manager->getModelFile("trophy_gold.b3d");
break;
default:

2
src/states_screens/main_menu_screen.cpp
View File

@ -205,7 +205,7 @@ void MainMenuScreen::eventCallback(Widget* widget, const std::string& name,
FeatureUnlockedCutScene* scene =
FeatureUnlockedCutScene::getInstance();
scene->addTrophy(RaceManager::RD_EASY);
scene->addTrophy(RaceManager::DIFFICULTY_EASY);
StateManager::get()->pushScreen(scene);
/*

6
src/states_screens/race_gui_overworld.cpp
View File

@ -374,9 +374,9 @@ void RaceGUIOverworld::drawGlobalMiniMap()
int state = (challenges[n].getForceField().m_is_locked ? LOCKED : OPEN);
const Challenge* c = unlock_manager->getCurrentSlot()->getChallenge(challenges[n].m_challenge_id);
if (c->isSolved(RaceManager::RD_HARD)) state = COMPLETED_HARD;
else if (c->isSolved(RaceManager::RD_MEDIUM)) state = COMPLETED_MEDIUM;
else if (c->isSolved(RaceManager::RD_EASY)) state = COMPLETED_EASY;
if (c->isSolved(RaceManager::DIFFICULTY_HARD)) state = COMPLETED_HARD;
else if (c->isSolved(RaceManager::DIFFICULTY_MEDIUM)) state = COMPLETED_MEDIUM;
else if (c->isSolved(RaceManager::DIFFICULTY_EASY)) state = COMPLETED_EASY;
const core::rect<s32> source(core::position2d<s32>(0,0),
m_icons[state]->getOriginalSize());

12
src/states_screens/race_setup_screen.cpp
View File

@ -79,18 +79,18 @@ void RaceSetupScreen::eventCallback(Widget* widget, const std::string& name, con
if (selection == "novice")
{
UserConfigParams::m_difficulty = RaceManager::RD_EASY;
race_manager->setDifficulty(RaceManager::RD_EASY);
UserConfigParams::m_difficulty = RaceManager::DIFFICULTY_EASY;
race_manager->setDifficulty(RaceManager::DIFFICULTY_EASY);
}
else if (selection == "intermediate")
{
UserConfigParams::m_difficulty = RaceManager::RD_MEDIUM;
race_manager->setDifficulty(RaceManager::RD_MEDIUM);
UserConfigParams::m_difficulty = RaceManager::DIFFICULTY_MEDIUM;
race_manager->setDifficulty(RaceManager::DIFFICULTY_MEDIUM);
}
else if (selection == "expert")
{
UserConfigParams::m_difficulty = RaceManager::RD_HARD;
race_manager->setDifficulty(RaceManager::RD_HARD);
UserConfigParams::m_difficulty = RaceManager::DIFFICULTY_HARD;
race_manager->setDifficulty(RaceManager::DIFFICULTY_HARD);
}
}
else if (name == "gamemode")

2
src/states_screens/tutorial_screen.cpp
View File

@ -176,7 +176,7 @@ void TutorialScreen::eventCallback(GUIEngine::Widget* widget, const std::string&
m_minor = RaceManager::MINOR_MODE_NORMAL_RACE;
m_major = RaceManager::MAJOR_MODE_SINGLE;
m_difficulty = RaceManager::RD_EASY;
m_difficulty = RaceManager::DIFFICULTY_EASY;
race_manager->setMinorMode(m_minor);
race_manager->setMajorMode(m_major);

8
src/tutorial/tutorial_data.cpp
View File

@ -38,7 +38,7 @@ TutorialData::TutorialData(const std::string& filename)
m_filename = filename;
m_major = RaceManager::MAJOR_MODE_SINGLE;
m_minor = RaceManager::MINOR_MODE_NORMAL_RACE;
m_difficulty = RaceManager::RD_EASY;
m_difficulty = RaceManager::DIFFICULTY_EASY;
m_num_laps = -1;
m_num_karts = -1;
m_time = -1.0f;
@ -259,11 +259,11 @@ void TutorialData::setTrack(std::string track_name)
void TutorialData::setDifficulty(std::string difficulty)
{
if(difficulty == "easy")
this->m_difficulty = RaceManager::RD_EASY;
this->m_difficulty = RaceManager::DIFFICULTY_EASY;
else if(difficulty =="medium")
this->m_difficulty = RaceManager::RD_MEDIUM;
this->m_difficulty = RaceManager::DIFFICULTY_MEDIUM;
else if(difficulty =="hard")
this->m_difficulty = RaceManager::RD_HARD;
this->m_difficulty = RaceManager::DIFFICULTY_HARD;
else
error("difficulty");
}