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

Fixed crash at the end of a GP if there is a challenge associated to it. Also, it is now detected properly when you unlock a feature by winnign a GP (however the chest scene doesn't yet apepar)

Browse Source 
git-svn-id: svn+ssh://svn.code.sf.net/p/supertuxkart/code/main/trunk@4954 178a84e3-b1eb-0310-8ba1-8eac791a3b58
This commit is contained in:
auria 2010-03-07 18:42:04 +00:00
parent 32f1e24b4a
commit 0623cce462
5 changed files with 116 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/challenges/challenge_data.cpp
View File

@ -323,10 +323,13 @@ bool ChallengeData::grandPrixFinished()
race_manager->getNumPlayers() > 1) return false;
// check if the player came first.
Kart* kart = World::getWorld()->getPlayerKart(0);
const int rank = race_manager->getKartFinalGPRank(kart->getWorldKartId());
//assert(World::getWorld() != NULL);
// Kart* kart = World::getWorld()->getPlayerKart(0);
//const int rank = race_manager->getKartGPRank(kart->getWorldKartId());
const int rank = race_manager->getLocalPlayerGPRank(0);
//printf("getting rank for %s : %i \n", kart->getName().c_str(), rank );
if( rank != 0 ) return false;
if (rank != 0) return false;
return true;
} // grandPrixFinished

3
src/challenges/unlock_manager.cpp
View File

@ -340,8 +340,9 @@ void UnlockManager::grandPrixFinished()
for(AllChallengesType::iterator i =m_all_challenges.begin();
i!=m_all_challenges.end(); i++)
{
if(i->second->isActive() &&i->second->grandPrixFinished())
if(i->second->isActive() && i->second->grandPrixFinished())
{
std::cout << "===== A FEATURE WAS UNLOCKED BECAUSE YOU WON THE GP!! ==\n";
unlockFeature(i->second);
}
}

4
src/ide/Xcode/STK_XCode.xcodeproj/project.pbxproj
View File

@ -2617,7 +2617,9 @@
GCC_PREFIX_HEADER = "";
GCC_VERSION = 4.0;
GCC_WARN_ABOUT_MISSING_NEWLINE = YES;
GCC_WARN_MISSING_PARENTHESES = YES;
GCC_WARN_NON_VIRTUAL_DESTRUCTOR = YES;
GCC_WARN_SHADOW = NO;
GCC_WARN_UNUSED_FUNCTION = NO;
GCC_WARN_UNUSED_PARAMETER = NO;
HEADER_SEARCH_PATHS = "$(inherited)";
@ -2654,7 +2656,9 @@
GCC_PREFIX_HEADER = "";
GCC_VERSION = 4.0;
GCC_WARN_ABOUT_MISSING_NEWLINE = YES;
GCC_WARN_MISSING_PARENTHESES = YES;
GCC_WARN_NON_VIRTUAL_DESTRUCTOR = YES;
GCC_WARN_SHADOW = NO;
GCC_WARN_UNUSED_FUNCTION = NO;
GCC_WARN_UNUSED_PARAMETER = NO;
HEADER_SEARCH_PATHS = "$(inherited)";

161
src/race/race_manager.cpp
View File

@ -90,13 +90,28 @@ void RaceManager::setPlayerKart(unsigned int player_id, const RemoteKartInfo& ki
*/
void RaceManager::setLocalKartInfo(unsigned int player_id, const std::string& kart)
{
assert(0<=player_id && player_id <m_local_kart_info.size());
assert(0<=player_id && player_id <m_local_player_karts.size());
m_local_kart_info[player_id] = RemoteKartInfo(player_id, kart,
m_local_player_karts[player_id] = RemoteKartInfo(player_id, kart,
StateManager::get()->getActivePlayerProfile(player_id)->getName(),
network_manager->getMyHostId());
} // setLocalKartInfo
//-----------------------------------------------------------------------------
int RaceManager::getLocalPlayerGPRank(const int playerID) const
{
const int amount = m_kart_status.size();
for (int n=0; n<amount; n++)
{
if (m_kart_status[n].m_local_player_id == playerID)
{
return m_kart_status[n].m_gp_rank;
}
}
return -1;
}
//-----------------------------------------------------------------------------
/** Sets the number of local players playing on this computer (including
* split screen).
@ -104,7 +119,7 @@ void RaceManager::setLocalKartInfo(unsigned int player_id, const std::string& ka
*/
void RaceManager::setNumLocalPlayers(unsigned int n)
{
m_local_kart_info.resize(n);
m_local_player_karts.resize(n);
} // setNumLocalPlayers
//-----------------------------------------------------------------------------
@ -294,6 +309,77 @@ void RaceManager::next()
}
} // next
//-----------------------------------------------------------------------------
/**
* Sets/updates the m_gp_rank status of each KartStatus object
*/
void RaceManager::computeGPRanks()
{
// calculate the rank of each kart
const unsigned int NUM_KARTS = getNumberOfKarts();
int *scores = new int[NUM_KARTS];
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::MINOR_MODE_FOLLOW_LEADER) ? 1 : 0;
for (unsigned int kart_id = start; kart_id < NUM_KARTS; ++kart_id)
{
position[kart_id] = kart_id;
scores[kart_id] = race_manager->getKartScore(kart_id);
race_time[kart_id] = race_manager->getOverallTime(kart_id);
}
if (race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER)
{
// fill values for leader
position[0] = -1;
scores[0] = -1;
race_time[0] = -1;
m_kart_status[0].m_gp_rank = -1;
}
//Bubblesort
bool sorted;
do
{
sorted = true;
for( unsigned int i = start; i < NUM_KARTS - 1; ++i )
{
if( scores[i] < scores[i+1] || (scores[i] == scores[i+1]
&& race_time[i] > race_time[i+1]))
{
int tmp_score[2];
double tmp_time;
tmp_score[0] = position[i];
tmp_score[1] = scores[i];
tmp_time = race_time[i];
position[i] = position[i+1];
scores[i] = scores[i+1];
race_time[i] = race_time[i+1];
position[i+1] = tmp_score[0];
scores[i+1] = tmp_score[1];
race_time[i+1] = tmp_time;
sorted = false;
}
}
} while(!sorted);
for (unsigned int i=start; i < NUM_KARTS; ++i)
{
//printf("setting kart %s to rank %i\n", race_manager->getKartName(position[i]).c_str(), i-start);
m_kart_status[position[i]].m_gp_rank = i - start;
}
// printf("kart %s has rank %i\n", 0, m_kart_status[0].m_gp_rank);
delete []scores;
delete []position;
delete []race_time;
}
//-----------------------------------------------------------------------------
/** In GP displays the GP result screen, and then deletes the world.
*/
@ -303,70 +389,7 @@ void RaceManager::exitRace()
// were finished, and not when a race is aborted.
if (m_major_mode==MAJOR_MODE_GRAND_PRIX && m_track_number==(int)m_tracks.size())
{
// calculate the rank of each kart
const unsigned int NUM_KARTS = getNumberOfKarts();
int *scores = new int[NUM_KARTS];
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::MINOR_MODE_FOLLOW_LEADER) ? 1 : 0;
for (unsigned int kart_id = start; kart_id < NUM_KARTS; ++kart_id)
{
position[kart_id] = kart_id;
scores[kart_id] = race_manager->getKartScore(kart_id);
race_time[kart_id] = race_manager->getOverallTime(kart_id);
}
if (race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER)
{
// fill values for leader
position[0] = -1;
scores[0] = -1;
race_time[0] = -1;
m_kart_status[0].m_gp_final_rank = -1;
}
//Bubblesort
bool sorted;
do
{
sorted = true;
for( unsigned int i = start; i < NUM_KARTS - 1; ++i )
{
if( scores[i] < scores[i+1] || (scores[i] == scores[i+1]
&& race_time[i] > race_time[i+1]))
{
int tmp_score[2];
double tmp_time;
tmp_score[0] = position[i];
tmp_score[1] = scores[i];
tmp_time = race_time[i];
position[i] = position[i+1];
scores[i] = scores[i+1];
race_time[i] = race_time[i+1];
position[i+1] = tmp_score[0];
scores[i+1] = tmp_score[1];
race_time[i+1] = tmp_time;
sorted = false;
}
}
} while(!sorted);
for (unsigned int i=start; i < NUM_KARTS; ++i)
{
//printf("setting kart %s to rank %i\n", race_manager->getKartName(position[i]).c_str(), i-start);
m_kart_status[position[i]].m_gp_final_rank = i - start;
}
// printf("kart %s has rank %i\n", 0, m_kart_status[0].m_gp_final_rank);
delete []scores;
delete []position;
delete []race_time;
computeGPRanks();
unlock_manager->grandPrixFinished();
StateManager::get()->resetAndGoToScreen( MainMenuScreen::getInstance() );
@ -375,8 +398,8 @@ void RaceManager::exitRace()
std::string winners[3];
for (unsigned int i=0; i < m_kart_status.size(); ++i)
{
std::cout << m_kart_status[i].m_ident << " has GP final rank " << m_kart_status[i].m_gp_final_rank << std::endl;
const int rank = m_kart_status[i].m_gp_final_rank;
std::cout << m_kart_status[i].m_ident << " has GP final rank " << m_kart_status[i].m_gp_rank << std::endl;
const int rank = m_kart_status[i].m_gp_rank;
if (rank >= 0 && rank < 3)
{
winners[rank] = m_kart_status[i].m_ident;

20
src/race/race_manager.hpp
View File

@ -170,7 +170,7 @@ private:
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_final_rank; // In GPs, at the end, will hold the overall rank of this kart.
int m_gp_rank; // In GPs, at the end, will hold the overall rank of this kart.
KartStatus(const std::string& ident, const int& prev_finish_pos,
int local_player_id, int global_player_id, KartType kt) :
@ -189,7 +189,7 @@ private:
MinorRaceModeType m_minor_mode;
/** Stores remote kart information about all player karts. */
std::vector<RemoteKartInfo> m_player_karts;
std::vector<RemoteKartInfo> m_local_kart_info;
std::vector<RemoteKartInfo> m_local_player_karts;
std::vector<std::string> m_tracks;
std::vector<int> m_host_ids;
std::vector<int> m_num_laps;
@ -216,9 +216,9 @@ public:
void reset();
void setLocalKartInfo(unsigned int player_id, const std::string& kart);
const RemoteKartInfo&
getLocalKartInfo(unsigned int n) const {return m_local_kart_info[n];}
getLocalKartInfo(unsigned int n) const {return m_local_player_karts[n];}
void setNumLocalPlayers(unsigned int n);
unsigned int getNumLocalPlayers() const {return m_local_kart_info.size(); };
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; }
@ -232,9 +232,9 @@ public:
void setNumLaps(int num) { m_num_laps.clear();
m_num_laps.push_back(num); }
void setMajorMode(MajorRaceModeType mode)
{ m_major_mode = mode; }
{ m_major_mode = mode; }
void setMinorMode(MinorRaceModeType mode)
{ m_minor_mode = mode; }
{ m_minor_mode = mode; }
void setNumKarts(int num) { m_num_karts = num; }
void setCoinTarget(int num) { m_coin_target = num; }
MajorRaceModeType
@ -250,8 +250,12 @@ public:
unsigned int getFinishedPlayers() const { return m_num_finished_players; }
const std::string& getItemStyle() const { return m_grand_prix.getItemStyle(); }
int getKartFinalGPRank(const int kart_id)
const { return m_kart_status[kart_id].m_gp_final_rank; }
void computeGPRanks();
int getKartGPRank(const int kart_id)
const { return m_kart_status[kart_id].m_gp_rank; }
/** \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;}