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

Removed player- and network-kart lists from world, so now

Browse Source 
there is only one list used to access all karts in world.


git-svn-id: svn+ssh://svn.code.sf.net/p/supertuxkart/code/main/trunk@4680 178a84e3-b1eb-0310-8ba1-8eac791a3b58
This commit is contained in:
hikerstk
2010-02-10 22:59:17 +00:00
parent b9051bd402
commit 4a96f98182
13 changed files with 141 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/karts/kart.hpp
View File

@@ -315,7 +315,8 @@ public:
void handleExplosion (const Vec3& pos, bool direct_hit);
virtual const irr::core::stringw& getName() const {return m_kart_properties->getName();}
const std::string& getIdent () const {return m_kart_properties->getIdent();}
virtual bool isPlayerKart () const {return false; }
virtual bool isPlayerKart () const {return false; }
virtual bool isNetworkKart () const { return true; }
// addMessages gets called by world to add messages to the gui
virtual void addMessages () {};
virtual void collectedItem (const Item &item, int random_attachment);

12
src/modes/follow_the_leader.cpp
View File

@@ -53,13 +53,13 @@ void FollowTheLeaderRace::countdownReachedZero()
int kart_number;
// If the leader kart is not the first kart, remove the first
// kart, otherwise remove the last kart.
int position_to_remove = m_kart[0]->getPosition()==1
int position_to_remove = m_karts[0]->getPosition()==1
? getCurrentNumKarts() : 1;
const int kart_amount = m_kart.size();
const int kart_amount = m_karts.size();
for (kart_number=0; kart_number<kart_amount; kart_number++)
{
if(m_kart[kart_number]->isEliminated()) continue;
if(m_kart[kart_number]->getPosition()==position_to_remove)
if(m_karts[kart_number]->isEliminated()) continue;
if(m_karts[kart_number]->getPosition()==position_to_remove)
break;
}
if(kart_number==kart_amount)
@@ -69,14 +69,14 @@ void FollowTheLeaderRace::countdownReachedZero()
for(int i=0; i<kart_amount; i++)
{
fprintf(stderr,"kart %d: eliminated %d position %d\n",
i,m_kart[i]->isEliminated(), m_kart[i]->getPosition());
i,m_karts[i]->isEliminated(), m_karts[i]->getPosition());
} // for i
} // kart_number==m_kart.size()
else
{
// In case that the kart on position 1 was removed, we have to set
// the correct position (which equals the remaining number of karts).
m_kart[kart_number]->setPosition(getCurrentNumKarts());
m_karts[kart_number]->setPosition(getCurrentNumKarts());
removeKart(kart_number);
}

68
src/modes/linear_world.cpp
View File

@@ -37,7 +37,7 @@ LinearWorld::LinearWorld() : World()
void LinearWorld::init()
{
World::init();
const unsigned int kart_amount = m_kart.size();
const unsigned int kart_amount = m_karts.size();
m_kart_display_info = new RaceGUI::KartIconDisplayInfo[kart_amount];
@@ -48,7 +48,7 @@ void LinearWorld::init()
info.m_last_valid_sector = QuadGraph::UNKNOWN_SECTOR;
info.m_last_valid_race_lap = -1;
info.m_lap_start_time = 0;
m_track->getQuadGraph().findRoadSector(m_kart[n]->getXYZ(),
m_track->getQuadGraph().findRoadSector(m_karts[n]->getXYZ(),
&info.m_track_sector);
//If m_track_sector == UNKNOWN_SECTOR, then the kart is not on top of
@@ -57,12 +57,12 @@ void LinearWorld::init()
if (!info.m_on_road)
{
info.m_track_sector =
m_track->getQuadGraph().findOutOfRoadSector(m_kart[n]->getXYZ(),
m_track->getQuadGraph().findOutOfRoadSector(m_karts[n]->getXYZ(),
QuadGraph::UNKNOWN_SECTOR );
}
m_track->getQuadGraph().spatialToTrack(&info.m_curr_track_coords,
m_kart[n]->getXYZ(),
m_karts[n]->getXYZ(),
info.m_track_sector );
info.m_race_lap = -1;
@@ -88,14 +88,14 @@ void LinearWorld::restartRace()
{
World::restartRace();
const unsigned int kart_amount = m_kart.size();
const unsigned int kart_amount = m_karts.size();
for(unsigned int n=0; n<kart_amount; n++)
{
KartInfo& info = m_kart_info[n];
info.m_track_sector = QuadGraph::UNKNOWN_SECTOR;
info.m_last_valid_sector = QuadGraph::UNKNOWN_SECTOR;
info.m_lap_start_time = 0;
m_track->getQuadGraph().findRoadSector(m_kart[n]->getXYZ(),
m_track->getQuadGraph().findRoadSector(m_karts[n]->getXYZ(),
&info.m_track_sector);
//If m_track_sector == UNKNOWN_SECTOR, then the kart is not on top of
@@ -104,18 +104,18 @@ void LinearWorld::restartRace()
if (!info.m_on_road)
{
info.m_track_sector =
m_track->getQuadGraph().findOutOfRoadSector(m_kart[n]->getXYZ(),
QuadGraph::UNKNOWN_SECTOR );
m_track->getQuadGraph().findOutOfRoadSector(m_karts[n]->getXYZ(),
QuadGraph::UNKNOWN_SECTOR );
}
m_track->getQuadGraph().spatialToTrack(&info.m_curr_track_coords,
m_kart[n]->getXYZ(),
m_karts[n]->getXYZ(),
info.m_track_sector );
info.m_race_lap = -1;
info.m_lap_start_time = -0;
info.m_time_at_last_lap = 99999.9f;
updateRacePosition(m_kart[n], info);
updateRacePosition(m_karts[n], info);
} // next kart
} // restartRace
@@ -133,7 +133,7 @@ void LinearWorld::update(float delta)
for(unsigned int n=0; n<kart_amount; n++)
{
KartInfo& kart_info = m_kart_info[n];
Kart* kart = m_kart[n];
Kart* kart = m_karts[n];
// Nothing to do for karts that are currently being rescued.
if(kart->isRescue()) continue;
@@ -172,13 +172,13 @@ void LinearWorld::update(float delta)
for(unsigned int i=0; i<kart_amount; i++)
{
// ---------- update rank ------
if(!m_kart[i]->hasFinishedRace() && !m_kart[i]->isEliminated())
if(!m_karts[i]->hasFinishedRace() && !m_karts[i]->isEliminated())
{
updateRacePosition(m_kart[i], m_kart_info[i]);
updateRacePosition(m_karts[i], m_kart_info[i]);
// During the last lap update the estimated finish time.
// This is used to play the faster music, and by the AI
if(m_kart_info[i].m_race_lap == race_manager->getNumLaps()-1)
m_kart_info[i].m_estimated_finish = estimateFinishTimeForKart(m_kart[i]);
m_kart_info[i].m_estimated_finish = estimateFinishTimeForKart(m_karts[i]);
checkForWrongDirection(i);
}
}
@@ -189,18 +189,18 @@ void LinearWorld::update(float delta)
for(int i=0; i<10; i++) pos_used[i]=-99;
for(unsigned int i=0; i<kart_amount; i++)
{
if(pos_used[m_kart[i]->getPosition()]!=-99)
if(pos_used[m_karts[i]->getPosition()]!=-99)
{
for(unsigned int j =0; j<kart_amount; j++)
{
printf("j %d pos %d finished %d laps %d distance %f\n",
j, m_kart[j]->getPosition(),
m_kart[j]->hasFinishedRace(),
j, m_karts[j]->getPosition(),
m_karts[j]->hasFinishedRace(),
m_kart_info[j].m_race_lap,
getDistanceDownTrackForKart(m_kart[j]->getWorldKartId()));
getDistanceDownTrackForKart(m_karts[j]->getWorldKartId()));
}
}
pos_used[m_kart[i]->getPosition()]=i;
pos_used[m_karts[i]->getPosition()]=i;
}
#endif
@@ -213,7 +213,7 @@ void LinearWorld::update(float delta)
void LinearWorld::newLap(unsigned int kart_index)
{
KartInfo &kart_info = m_kart_info[kart_index];
Kart *kart = m_kart[kart_index];
Kart *kart = m_karts[kart_index];
// Only increase the lap counter and set the new time if the
// kart hasn't already finished the race (otherwise the race_gui
// will begin another countdown).
@@ -226,7 +226,7 @@ void LinearWorld::newLap(unsigned int kart_index)
// Last lap message (kart_index's assert in previous block already)
if(kart_info.m_race_lap+1 == race_manager->getNumLaps())
{
m_race_gui->addMessage(_("Final lap!"), m_kart[kart_index],
m_race_gui->addMessage(_("Final lap!"), m_karts[kart_index],
3.0f, 40, video::SColor(255, 210, 100, 50));
}
// Race finished
@@ -327,7 +327,7 @@ RaceGUI::KartIconDisplayInfo* LinearWorld::getKartsDisplayInfo()
for(unsigned int i = 0; i < kart_amount ; i++)
{
RaceGUI::KartIconDisplayInfo& rank_info = m_kart_display_info[i];
Kart* kart = m_kart[i];
Kart* kart = m_karts[i];
// reset color
rank_info.r = 1.0;
@@ -357,7 +357,7 @@ RaceGUI::KartIconDisplayInfo* LinearWorld::getKartsDisplayInfo()
{
RaceGUI::KartIconDisplayInfo& rank_info = m_kart_display_info[i];
KartInfo& kart_info = m_kart_info[i];
Kart* kart = m_kart[i];
Kart* kart = m_karts[i];
const int position = kart->getPosition();
@@ -409,14 +409,14 @@ void LinearWorld::terminateRace()
// if some karts have not yet finished the race yet, estimate
// their times and use these values to proceed without waiting
const unsigned int kart_amount = m_kart.size();
for ( Karts::size_type i = 0; i < kart_amount; ++i)
const unsigned int kart_amount = m_karts.size();
for ( KartList::size_type i = 0; i < kart_amount; ++i)
{
// Eliminated karts have already called raceFinished.
if(!m_kart[i]->hasFinishedRace() && !m_kart[i]->isEliminated())
if(!m_karts[i]->hasFinishedRace() && !m_karts[i]->isEliminated())
{
const float est_finish_time = m_kart_info[i].m_estimated_finish;
m_kart[i]->raceFinished(est_finish_time);
m_karts[i]->raceFinished(est_finish_time);
} // if !hasFinishedRace
} // for i
} // terminateRace
@@ -530,22 +530,22 @@ void LinearWorld::updateRacePosition ( Kart* kart, KartInfo& kart_info )
{
int p = 1 ;
const unsigned int kart_amount = m_kart.size();
const unsigned int kart_amount = m_karts.size();
const int my_id = kart->getWorldKartId();
const int my_laps = getLapForKart(my_id);
const float my_progression = getDistanceDownTrackForKart(my_id);
for ( unsigned int j = 0 ; j < kart_amount ; j++ )
{
if(j == kart->getWorldKartId()) continue; // don't compare a kart with itself
if(m_kart[j]->isEliminated()) continue; // dismiss eliminated karts
if(m_karts[j]->isEliminated()) continue; // dismiss eliminated karts
// Count karts ahead of the current kart, i.e. kart that are already
// finished (the current kart k has not yet finished!!), have done more
// laps, or the same number of laps, but a greater distance.
if(m_kart[j]->hasFinishedRace()) { p++; continue; }
if(m_karts[j]->hasFinishedRace()) { p++; continue; }
/* has done more or less lapses */
assert(j==m_kart[j]->getWorldKartId());
assert(j==m_karts[j]->getWorldKartId());
int other_laps = getLapForKart(j);
if (other_laps != my_laps)
{
@@ -558,7 +558,7 @@ void LinearWorld::updateRacePosition ( Kart* kart, KartInfo& kart_info )
float other_progression = getDistanceDownTrackForKart(j);
if(other_progression > my_progression ||
(other_progression == my_progression &&
m_kart[j]->getInitialPosition() > kart->getInitialPosition()) )
m_karts[j]->getInitialPosition() > kart->getInitialPosition()) )
{
p++;
}
@@ -587,13 +587,13 @@ void LinearWorld::updateRacePosition ( Kart* kart, KartInfo& kart_info )
*/
void LinearWorld::checkForWrongDirection(unsigned int i)
{
if(!m_kart[i]->isPlayerKart()) return;
if(!m_karts[i]->isPlayerKart()) return;
if(!m_kart_info[i].m_on_road) return;
// FIXME: Don't do this if the in-game option menu is on the screen!
// if(option_menu) return;
const Kart *kart=m_kart[i];
const Kart *kart=m_karts[i];
// If the kart can go in more than one directions from the current track
// don't do any reverse message handling, since it is likely that there
// will be one direction in which it isn't going backwards anyway.

19
src/modes/profile_world.cpp
View File

@@ -93,9 +93,6 @@ Kart *ProfileWorld::createKart(const std::string &kart_ident, int index,
// of profile mode???
new Camera(index, newkart);
}
//m_local_player_karts[index] = static_cast<PlayerKart*>(newkart);
//m_player_karts[index] = static_cast<PlayerKart*>(newkart);
m_player_karts.clear();
return newkart;
} // createKart
@@ -129,17 +126,17 @@ void ProfileWorld::enterRaceOverState(const bool delay)
m_frame_count, runtime, (float)m_frame_count/runtime);
float min_t=999999.9f, max_t=0.0, av_t=0.0;
for ( Karts::size_type i = 0; i < m_kart.size(); ++i)
for ( KartList::size_type i = 0; i < m_karts.size(); ++i)
{
max_t = std::max(max_t, m_kart[i]->getFinishTime());
min_t = std::min(min_t, m_kart[i]->getFinishTime());
av_t += m_kart[i]->getFinishTime();
max_t = std::max(max_t, m_karts[i]->getFinishTime());
min_t = std::min(min_t, m_karts[i]->getFinishTime());
av_t += m_karts[i]->getFinishTime();
printf("%ls start %d end %d time %f\n",
m_kart[i]->getName().c_str(),(int)i,
m_kart[i]->getPosition(),
m_kart[i]->getFinishTime());
m_karts[i]->getName().c_str(),(int)i,
m_karts[i]->getPosition(),
m_karts[i]->getFinishTime());
}
printf("min %f max %f av %f\n",min_t, max_t, av_t/m_kart.size());
printf("min %f max %f av %f\n",min_t, max_t, av_t/m_karts.size());
std::exit(-2);
} // enterRaceOverState

4
src/modes/standard_race.cpp
View File

@@ -56,8 +56,8 @@ void StandardRace::update(float dt)
const unsigned int kart_amount = getNumKarts();
for(unsigned int i = 0; i < kart_amount ; i++)
{
if(!m_kart[i]->hasFinishedRace())
m_kart[i]->raceFinished(estimateFinishTimeForKart(m_kart[i]));
if(!m_karts[i]->hasFinishedRace())
m_karts[i]->raceFinished(estimateFinishTimeForKart(m_karts[i]));
} // i<kart_amount
// Set delay mode to have time for camera animation, and

36
src/modes/three_strikes_battle.cpp
View File

@@ -38,7 +38,7 @@ ThreeStrikesBattle::ThreeStrikesBattle() : World()
exit(1);
}
const unsigned int kart_amount = m_kart.size();
const unsigned int kart_amount = m_karts.size();
m_kart_display_info = new RaceGUI::KartIconDisplayInfo[kart_amount];
for(unsigned int n=0; n<kart_amount; n++)
@@ -49,7 +49,7 @@ ThreeStrikesBattle::ThreeStrikesBattle() : World()
m_kart_info.push_back(info);
// no positions in this mode
m_kart[n]->setPosition(-1);
m_karts[n]->setPosition(-1);
}// next kart
} // ThreeStrikesBattle
@@ -66,12 +66,12 @@ void ThreeStrikesBattle::terminateRace()
updateKartRanks();
// if some karts have not yet finished yet
const unsigned int kart_amount = m_kart.size();
for ( Karts::size_type i = 0; i < kart_amount; ++i)
const unsigned int kart_amount = m_karts.size();
for ( KartList::size_type i = 0; i < kart_amount; ++i)
{
if(!m_kart[i]->hasFinishedRace())
if(!m_karts[i]->hasFinishedRace())
{
m_kart[i]->raceFinished(WorldStatus::getTime());
m_karts[i]->raceFinished(WorldStatus::getTime());
} // if !hasFinishedRace
} // for i
@@ -82,7 +82,7 @@ void ThreeStrikesBattle::terminateRace()
void ThreeStrikesBattle::kartHit(const int kart_id)
{
assert(kart_id >= 0);
assert(kart_id < (int)m_kart.size());
assert(kart_id < (int)m_karts.size());
// make kart lose a life
m_kart_info[kart_id].m_lives--;
@@ -92,7 +92,7 @@ void ThreeStrikesBattle::kartHit(const int kart_id)
// check if kart is 'dead'
if(m_kart_info[kart_id].m_lives < 1)
{
m_kart[kart_id]->raceFinished(WorldStatus::getTime());
m_karts[kart_id]->raceFinished(WorldStatus::getTime());
removeKart(kart_id);
}
@@ -138,10 +138,10 @@ void ThreeStrikesBattle::updateKartRanks()
sorted = true;
for( unsigned int n = 0; n < NUM_KARTS-1; ++n )
{
const int this_karts_time = m_kart[karts_list[n]]->hasFinishedRace() ?
(int)m_kart[karts_list[n]]->getFinishTime() : (int)WorldStatus::getTime();
const int next_karts_time = m_kart[karts_list[n+1]]->hasFinishedRace() ?
(int)m_kart[karts_list[n+1]]->getFinishTime() : (int)WorldStatus::getTime();
const int this_karts_time = m_karts[karts_list[n]]->hasFinishedRace() ?
(int)m_karts[karts_list[n]]->getFinishTime() : (int)WorldStatus::getTime();
const int next_karts_time = m_karts[karts_list[n+1]]->hasFinishedRace() ?
(int)m_karts[karts_list[n+1]]->getFinishTime() : (int)WorldStatus::getTime();
bool swap = false;
@@ -163,7 +163,7 @@ void ThreeStrikesBattle::updateKartRanks()
for( unsigned int n = 0; n < NUM_KARTS; ++n )
{
m_kart[ karts_list[n] ]->setPosition( n+1 );
m_karts[ karts_list[n] ]->setPosition( n+1 );
}
delete [] karts_list;
} // updateKartRank
@@ -174,8 +174,8 @@ void ThreeStrikesBattle::enterRaceOverState(const bool delay)
World::enterRaceOverState(delay);
// Add the results for the remaining kart
for(unsigned int i=0; i<getNumKarts(); i++)
if(!m_kart[i]->isEliminated())
race_manager->RaceFinished(m_kart[i], WorldStatus::getTime());
if(!m_karts[i]->isEliminated())
race_manager->RaceFinished(m_karts[i], WorldStatus::getTime());
} // enterRaceOverState
//-----------------------------------------------------------------------------
@@ -191,14 +191,14 @@ void ThreeStrikesBattle::restartRace()
{
World::restartRace();
const unsigned int kart_amount = m_kart.size();
const unsigned int kart_amount = m_karts.size();
for(unsigned int n=0; n<kart_amount; n++)
{
m_kart_info[n].m_lives = 3;
// no positions in this mode
m_kart[n]->setPosition(-1);
m_karts[n]->setPosition(-1);
}// next kart
} // restartRace
@@ -316,7 +316,7 @@ void ThreeStrikesBattle::raceResultOrder( int* order )
const unsigned int num_karts = getNumKarts();
for( unsigned int kart_id = 0; kart_id < num_karts; ++kart_id )
{
const int pos = m_kart[kart_id]->getPosition() - 1;
const int pos = m_karts[kart_id]->getPosition() - 1;
assert(pos >= 0);
assert(pos < (int)num_karts);
order[pos] = kart_id;

81
src/modes/world.cpp
View File

@@ -110,9 +110,6 @@ void World::init()
// karts can be positioned properly on (and not in) the tracks.
m_track->loadTrackModel();
m_player_karts.resize(race_manager->getNumPlayers());
m_network_karts.resize(race_manager->getNumPlayers());
for(unsigned int i=0; i<num_karts; i++)
{
btTransform init_pos=m_track->getStartTransform(i);
@@ -121,8 +118,8 @@ void World::init()
int global_player_id = race_manager->getKartGlobalPlayerId(i);
Kart* newkart = createKart(kart_ident, i, local_player_id,
global_player_id, init_pos);
m_kart.push_back(newkart);
newkart->setWorldKartId(m_kart.size()-1);
m_karts.push_back(newkart);
newkart->setWorldKartId(m_karts.size()-1);
} // for i
resetAllKarts();
@@ -160,13 +157,10 @@ Kart *World::createKart(const std::string &kart_ident, int index,
newkart = new PlayerKart(kart_ident, position,
StateManager::get()->getActivePlayer(local_player_id),
init_pos, local_player_id);
m_player_karts[global_player_id] = (PlayerKart*)newkart;
break;
case RaceManager::KT_NETWORK_PLAYER:
newkart = new NetworkKart(kart_ident, position, init_pos,
global_player_id);
m_network_karts[global_player_id] = static_cast<NetworkKart*>(newkart);
m_player_karts[global_player_id] = (PlayerKart*)newkart;
break;
case RaceManager::KT_AI:
std::cout << "===== World : creating AI kart for #" << index << "===========\n";
@@ -222,10 +216,10 @@ World::~World()
if(m_track)
m_track->cleanup();
for ( unsigned int i = 0 ; i < m_kart.size() ; i++ )
delete m_kart[i];
for ( unsigned int i = 0 ; i < m_karts.size() ; i++ )
delete m_karts[i];
m_kart.clear();
m_karts.clear();
projectile_manager->cleanup();
// In case that the track is not found, m_physics is still undefined.
if(m_physics)
@@ -243,9 +237,9 @@ void World::onGo()
// Reset the brakes now that the prestart
// phase is over (braking prevents the karts
// from sliding downhill)
for(unsigned int i=0; i<m_kart.size(); i++)
for(unsigned int i=0; i<m_karts.size(); i++)
{
m_kart[i]->resetBrakes();
m_karts[i]->resetBrakes();
}
} // onGo
@@ -270,7 +264,7 @@ void World::resetAllKarts()
{
//Project karts onto track from above. This will lower each kart so
//that at least one of its wheel will be on the surface of the track
for ( Karts::iterator i=m_kart.begin(); i!=m_kart.end(); i++)
for ( KartList::iterator i=m_karts.begin(); i!=m_karts.end(); i++)
{
///start projection from top of kart
btVector3 up_offset(0, 0, 0.5f * ((*i)->getKartHeight()));
@@ -281,7 +275,7 @@ void World::resetAllKarts()
if (!kart_over_ground)
{
fprintf(stderr, "ERROR: no valid starting position for kart %d on track %s.\n",
(int)(i-m_kart.begin()), m_track->getIdent().c_str());
(int)(i-m_karts.begin()), m_track->getIdent().c_str());
exit(-1);
}
}
@@ -301,7 +295,7 @@ void World::resetAllKarts()
{
m_physics->update(1.f/60.f);
all_finished=true;
for ( Karts::iterator i=m_kart.begin(); i!=m_kart.end(); i++)
for ( KartList::iterator i=m_karts.begin(); i!=m_karts.end(); i++)
{
if(!(*i)->isInRest())
{
@@ -319,7 +313,7 @@ void World::resetAllKarts()
if(!material)
{
fprintf(stderr, "ERROR: no valid starting position for kart %d on track %s.\n",
(int)(i-m_kart.begin()), m_track->getIdent().c_str());
(int)(i-m_karts.begin()), m_track->getIdent().c_str());
exit(-1);
}
all_finished=false;
@@ -330,10 +324,11 @@ void World::resetAllKarts()
// Now store the current (i.e. in rest) suspension length for each kart,
// so that the karts can visualise the suspension.
for ( Karts::iterator i=m_kart.begin(); i!=m_kart.end(); i++)
for ( KartList::iterator i=m_karts.begin(); i!=m_karts.end(); i++)
(*i)->setSuspensionLength();
for(unsigned int i=0; i<m_player_karts.size(); i++)
m_player_karts[i]->getCamera()->setInitialTransform();
for(unsigned int i=0; i<m_karts.size(); i++)
if(m_karts[i]->getCamera())
m_karts[i]->getCamera()->setInitialTransform();
} // resetAllKarts
//-----------------------------------------------------------------------------
@@ -350,11 +345,11 @@ void World::update(float dt)
m_physics->update(dt);
}
const int kart_amount = m_kart.size();
const int kart_amount = m_karts.size();
for (int i = 0 ; i < kart_amount; ++i)
{
// Update all karts that are not eliminated
if(!m_kart[i]->isEliminated()) m_kart[i]->update(dt) ;
if(!m_karts[i]->isEliminated()) m_karts[i]->update(dt) ;
}
// The order of updates is rather important: if track update would
// be called before kart update, then the check manager (called from
@@ -406,16 +401,16 @@ void World::updateHighscores()
// someone might get into the highscore list, only to be kicked out
// again by a faster kart in the same race), which might be confusing
// if we ever decide to display a message (e.g. during a race)
unsigned int *index = new unsigned int[m_kart.size()];
unsigned int *index = new unsigned int[m_karts.size()];
const unsigned int kart_amount = m_kart.size();
const unsigned int kart_amount = m_karts.size();
for (unsigned int i=0; i<kart_amount; i++ )
{
index[i] = 999; // first reset the contents of the array
}
for (unsigned int i=0; i<kart_amount; i++ )
{
const int pos = m_kart[i]->getPosition()-1;
const int pos = m_karts[i]->getPosition()-1;
if(pos < 0 || pos >= (int)kart_amount) continue; // wrong position
index[pos] = i;
}
@@ -430,21 +425,21 @@ void World::updateHighscores()
#ifdef DEBUG
fprintf(stderr, "Error, incorrect kart positions:");
for (unsigned int i=0; i<m_kart.size(); i++ )
for (unsigned int i=0; i<m_karts.size(); i++ )
{
fprintf(stderr, "i=%d position %d\n",i, m_kart[i]->getPosition());
fprintf(stderr, "i=%d position %d\n",i, m_karts[i]->getPosition());
}
#endif
continue;
}
// Only record times for player karts and only if they finished the race
if(!m_kart[index[pos]]->isPlayerKart()) continue;
if (!m_kart[index[pos]]->hasFinishedRace()) continue;
if(!m_karts[index[pos]]->isPlayerKart()) continue;
if (!m_karts[index[pos]]->hasFinishedRace()) continue;
assert(index[pos] >= 0);
assert(index[pos] < m_kart.size());
PlayerKart *k = (PlayerKart*)m_kart[index[pos]];
assert(index[pos] < m_karts.size());
PlayerKart *k = (PlayerKart*)m_karts[index[pos]];
HighscoreEntry* highscores = getHighscores();
@@ -468,11 +463,11 @@ PlayerKart *World::getPlayerKart(int n) const
{
unsigned int count=-1;
for(unsigned int i=0; i<m_kart.size(); i++)
if(m_kart[i]->isPlayerKart())
for(unsigned int i=0; i<m_karts.size(); i++)
if(m_karts[i]->isPlayerKart())
{
count++;
if(count==n) return (PlayerKart*)m_kart[i];
if(count==n) return (PlayerKart*)m_karts[i];
}
return NULL;
} // getPlayerKart
@@ -484,12 +479,12 @@ PlayerKart *World::getPlayerKart(int n) const
PlayerKart *World::getLocalPlayerKart(int n) const
{
unsigned int count=-1;
for(unsigned int i=0; i<m_kart.size(); i++)
for(unsigned int i=0; i<m_karts.size(); i++)
{
if(m_kart[i]->getCamera() && m_kart[i]->isPlayerKart())
if(m_karts[i]->getCamera() && m_karts[i]->isPlayerKart())
{
count++;
if(count==n) return (PlayerKart*)m_kart[i];
if(count==n) return (PlayerKart*)m_karts[i];
}
}
return NULL;
@@ -500,12 +495,12 @@ PlayerKart *World::getLocalPlayerKart(int n) const
*/
void World::removeKart(int kart_number)
{
Kart *kart = m_kart[kart_number];
Kart *kart = m_karts[kart_number];
// Display a message about the eliminated kart in the race gui
for (std::vector<PlayerKart*>::iterator i = m_player_karts.begin();
i != m_player_karts.end(); i++ )
for (KartList::iterator i = m_karts.begin(); i != m_karts.end(); i++ )
{
if(!(*i)->getCamera()) continue;
if(*i==kart)
{
m_race_gui->addMessage(_("You have been\neliminated!"), *i, 2.0f, 60);
@@ -551,7 +546,7 @@ void World::restartRace()
m_eliminated_karts = 0;
m_eliminated_players = 0;
for ( Karts::iterator i = m_kart.begin(); i != m_kart.end() ; ++i )
for ( KartList::iterator i = m_karts.begin(); i != m_karts.end() ; ++i )
{
(*i)->reset();
}
@@ -584,8 +579,8 @@ void World::unpause()
sound_manager->resumeMusic() ;
sfx_manager->resumeAll();
WorldStatus::unpause();
for(unsigned int i=0; i<m_player_karts.size(); i++)
m_player_karts[i]->resetInputState();
for(unsigned int i=0; i<m_karts.size(); i++)
if(m_karts[i]->isPlayerKart()) ((PlayerKart*)m_karts[i])->resetInputState();
} // pause
/* EOF */

32
src/modes/world.hpp
View File

@@ -78,20 +78,23 @@ class Track;
class World : public WorldStatus
{
public:
typedef std::vector<Kart*> Karts;
typedef std::vector<Kart*> KartList;
protected:
std::vector<PlayerKart*> m_player_karts;
std::vector<NetworkKart*> m_network_karts;
/** The list of all karts. */
KartList m_karts;
RandomGenerator m_random;
Karts m_kart;
Physics* m_physics;
float m_fastest_lap;
Kart* m_fastest_kart;
Phase m_previous_phase; // used during the race popup menu
int m_eliminated_karts; // number of eliminated karts
int m_eliminated_players; // number of eliminated players
/** Used during the race popup menu. */
Phase m_previous_phase;
/** Number of eliminated karts. */
int m_eliminated_karts;
/** Number of eliminated players. */
int m_eliminated_players;
/** OVerall number of players. */
int m_num_players;
bool m_faster_music_active; // true if faster music was activated
@@ -136,14 +139,15 @@ public:
RaceGUI *getRaceGUI() const { return m_race_gui; }
PlayerKart *getPlayerKart(int player) const;
PlayerKart *getLocalPlayerKart(int n) const;
NetworkKart *getNetworkKart(int n) const { return m_network_karts[n]; }
unsigned int getNumKarts() const { return m_kart.size(); }
unsigned int getNumKarts() const { return m_karts.size(); }
Kart *getKart(int kartId) const { assert(kartId >= 0 &&
kartId < int(m_kart.size()));
return m_kart[kartId]; }
unsigned int getCurrentNumKarts() const { return (int)m_kart.size() -
kartId < int(m_karts.size()));
return m_karts[kartId]; }
/** Returns the number of currently active (i.e.non-elikminated) karts. */
unsigned int getCurrentNumKarts() const { return (int)m_karts.size() -
m_eliminated_karts; }
unsigned int getCurrentNumPlayers() const { return (int)m_player_karts.size()-
/** Returns the number of currently active (i.e. non-eliminated) players. */
unsigned int getCurrentNumPlayers() const { return m_num_players -
m_eliminated_players; }
Physics *getPhysics() const { return m_physics; }

16
src/network/kart_control_message.cpp
View File

@@ -38,17 +38,25 @@ KartControlMessage::KartControlMessage()
}
} // KartControlMessage
// ----------------------------------------------------------------------------
// kart_id_offset is the global id of the first kart on the host from which
// this packet was received.
/** Receives a kart control message.
* \param kart_id_offset is the global id of the first kart on the host from
* which this packet was received.
*/
KartControlMessage::KartControlMessage(ENetPacket* pkt, int kart_id_offset,
int num_local_players)
: Message(pkt, MT_KART_CONTROL)
{
// FIXME: This probably does not work anymore - it assume that
// num_local_Players is the number of all local karts, while it might
// only be the number of all network karts.
for(int i=kart_id_offset; i<kart_id_offset+num_local_players; i++)
{
KartControl kc(this);
NetworkKart *kart = RaceManager::getWorld()->getNetworkKart(i);
kart->setControl(kc);
Kart *kart = RaceManager::getWorld()->getKart(i);
if(kart->isNetworkKart())
{
((NetworkKart*)kart)->setControl(kc);
}
}
}; // KartControlMessage

1
src/network/network_kart.hpp
View File

@@ -31,5 +31,6 @@ public:
const btTransform& init_transform,
int global_player_id);
void setControl(const KartControl& kc);
virtual bool isNetworkKart() const { return true; }
}; // NetworkKart
#endif

1
src/race/race_manager.hpp
View File

@@ -173,7 +173,6 @@ private:
Difficulty m_difficulty;
MajorRaceModeType m_major_mode;
MinorRaceModeType m_minor_mode;
typedef std::vector<std::string> PlayerKarts;
/** Stores remote kart information about all player karts. */
std::vector<RemoteKartInfo> m_player_karts;
std::vector<RemoteKartInfo> m_local_kart_info;

2
src/robots/default_robot.cpp
View File

@@ -629,7 +629,7 @@ void DefaultRobot::handleAcceleration( const float DELTA )
//Find if any player is ahead of this kart
bool player_winning = false;
for(unsigned int i = 0; i < race_manager->getNumPlayers(); ++i )
if( getPosition() > RaceManager::getPlayerKart(i)->getPosition() )
if( getPosition() > m_world->getPlayerKart(i)->getPosition() )
{
player_winning = true;
break;

2
src/robots/new_ai.cpp
View File

@@ -625,7 +625,7 @@ void NewAI::handleAcceleration( const float DELTA )
//Find if any player is ahead of this kart
bool player_winning = false;
for(unsigned int i = 0; i < race_manager->getNumPlayers(); ++i )
if( getPosition() > RaceManager::getPlayerKart(i)->getPosition() )
if( getPosition() > m_world->getPlayerKart(i)->getPosition() )
{
player_winning = true;
break;