/** \brief Function to start the race with only ghost kart(s) and watch.
* \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::startWatchingReplay(const std::string &track_ident,
const int num_laps)
{
assert(m_watching_replay && m_has_ghost_karts && !m_is_recording_race);
StateManager::get()->enterGameState();
setTrack(track_ident);
setNumLaps(num_laps);
setMajorMode(RaceManager::MAJOR_MODE_SINGLE);
setCoinTarget(0);
m_num_karts = ReplayPlay::get()->getNumGhostKart();
m_kart_status.clear();
Log::verbose("RaceManager", "%u ghost kart(s) for watching replay only\n",
(unsigned int)m_num_karts);
int init_gp_rank = 0;
for(int i = 0; i < m_num_karts; i++)
{
m_kart_status.push_back(KartStatus(ReplayPlay::get()->getGhostKartName(i),
i, -1, -1, init_gp_rank, KT_GHOST, PLAYER_DIFFICULTY_NORMAL));
init_gp_rank ++;
}
m_track_number = 0;
startNextRace();
} // startSingleRace
// ------------------------------------------------------------------------
void addSpareTireKart(const std::string& name)
{
m_kart_status.push_back(KartStatus(name, 0, -1, -1,
-1, KT_SPARE_TIRE, PLAYER_DIFFICULTY_NORMAL));
m_num_spare_tire_karts++;
m_num_karts++;
} // addSpareTireKart
void RaceManager::startNew(bool from_overworld)
{
m_started_from_overworld = from_overworld;
if(m_major_mode==MAJOR_MODE_GRAND_PRIX)
{
// GP: get tracks, laps and reverse info from grand prix
m_tracks = m_grand_prix.getTrackNames();
m_grand_prix.getLaps(&m_num_laps);
m_grand_prix.getReverse(&m_reverse_track);
}
//assert(m_player_karts.size() > 0);
// command line parameters: negative numbers=all karts
if(m_num_karts < 0 ) m_num_karts = stk_config->m_max_karts;
if((size_t)m_num_karts < m_player_karts.size())
m_num_karts = (int)m_player_karts.size();
// Create the kart status data structure to keep track of scores, times, ...
// ==========================================================================
m_kart_status.clear();
Log::verbose("RaceManager", "Nb of karts=%u, ai:%lu players:%lu\n", (unsigned int)m_num_karts, m_ai_kart_list.size(), m_player_karts.size());
assert((unsigned int)m_num_karts == m_ai_kart_list.size()+m_player_karts.size());
// First add the AI karts (randomly chosen)
// ----------------------------------------
// GP ranks start with -1 for the leader.
int init_gp_rank =
race_manager->getMinorMode()==RaceManager::MINOR_MODE_FOLLOW_LEADER
? -1
: 0;
const unsigned int ai_kart_count = m_ai_kart_list.size();
for(unsigned int i=0; i<ai_kart_count; i++)
{
m_kart_status.push_back(KartStatus(m_ai_kart_list[i], i, -1, -1,
init_gp_rank, KT_AI));
init_gp_rank ++;
if(UserConfigParams::m_ftl_debug)
{
Log::debug("RaceManager", "[ftl] rank %d ai-kart %s", init_gp_rank,
m_ai_kart_list[i].c_str());
}
}
// Then the players, which start behind the AI karts
// -------------------------------------------------
for(unsigned int i=0; i<m_player_karts.size(); i++)
{
KartType kt= m_player_karts[i].isNetworkPlayer() ? KT_NETWORK_PLAYER : KT_PLAYER;
m_kart_status.push_back(KartStatus(m_player_karts[i].getKartName(), i,
m_player_karts[i].getLocalPlayerId(),
m_player_karts[i].getGlobalPlayerId(),
init_gp_rank, kt
) );
if(UserConfigParams::m_ftl_debug)
{
Log::debug("RaceManager", "[ftl] rank %d kart %s", init_gp_rank,
m_player_karts[i].getKartName().c_str());
}
init_gp_rank ++;
}
m_track_number = 0;
if(m_major_mode==MAJOR_MODE_GRAND_PRIX && !NetworkWorld::getInstance()->isRunning()) // offline mode only
{
//We look if Player 1 has a saved version of this GP.
// =================================================
SavedGrandPrix* gp = SavedGrandPrix::getSavedGP( StateManager::get()
->getActivePlayerProfile(0)
->getUniqueID(),
m_grand_prix.getId(),
m_difficulty,
m_num_karts,
m_player_karts.size());
// Start the race with the appropriate track
// =========================================
if(gp != NULL)
{
if (m_continue_saved_gp)
{
m_track_number = gp->getNextTrack();
gp->loadKarts(m_kart_status);
}
else
{
gp->remove();
}
}
}
startNextRace();
} // startNew
/** \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
* NetworkManager::setupPlayerKartInfo, but could be done differently
* (e.g. depending on user command line options to test certain AIs)
* \param from_overworld True if the race/GP is started from overworld
* (used to return to overworld at end of race/GP).
*/
void RaceManager::startNew(bool from_overworld)
{
unsigned int gk = 0;
if (m_has_ghost_karts)
gk = ReplayPlay::get()->getNumGhostKart();
m_started_from_overworld = from_overworld;
m_saved_gp = NULL; // There will be checks for this being NULL done later
if (m_major_mode==MAJOR_MODE_GRAND_PRIX)
{
// GP: get tracks, laps and reverse info from grand prix
m_tracks = m_grand_prix.getTrackNames();
m_num_laps = m_grand_prix.getLaps();
m_reverse_track = m_grand_prix.getReverse();
if (!RaceEventManager::getInstance<RaceEventManager>()->isRunning())
{
// We look if Player 1 has a saved version of this GP.
m_saved_gp = SavedGrandPrix::getSavedGP(
StateManager::get()
->getActivePlayerProfile(0)
->getUniqueID(),
m_grand_prix.getId(),
m_minor_mode,
m_player_karts.size());
// Saved GP only in offline mode
if (m_continue_saved_gp)
{
if (m_saved_gp == NULL)
{
Log::error("Race Manager", "Can not continue Grand Prix '%s'"
"because it could not be loaded",
m_grand_prix.getId().c_str());
m_continue_saved_gp = false; // simple and working
}
else
{
setNumKarts(m_saved_gp->getTotalKarts());
setupPlayerKartInfo();
m_grand_prix.changeReverse((GrandPrixData::GPReverseType)
m_saved_gp->getReverseType());
m_reverse_track = m_grand_prix.getReverse();
} // if m_saved_gp==NULL
} // if m_continue_saved_gp
} // if !network_world
} // if grand prix
// command line parameters: negative numbers=all karts
if(m_num_karts < 0 ) m_num_karts = stk_config->m_max_karts;
if((size_t)m_num_karts < m_player_karts.size())
m_num_karts = (int)m_player_karts.size();
// Create the kart status data structure to keep track of scores, times, ...
// ==========================================================================
m_kart_status.clear();
if (gk > 0)
m_num_karts += gk;
Log::verbose("RaceManager", "Nb of karts=%u, ghost karts:%u ai:%lu players:%lu\n",
(unsigned int) m_num_karts, gk, m_ai_kart_list.size(), m_player_karts.size());
assert((unsigned int)m_num_karts == gk+m_ai_kart_list.size()+m_player_karts.size());
// First add the ghost karts (if any)
// ----------------------------------------
// GP ranks start with -1 for the leader.
int init_gp_rank = getMinorMode()==MINOR_MODE_FOLLOW_LEADER ? -1 : 0;
if (gk > 0)
{
for(unsigned int i = 0; i < gk; i++)
{
m_kart_status.push_back(KartStatus(ReplayPlay::get()->getGhostKartName(i),
i, -1, -1, init_gp_rank, KT_GHOST, PLAYER_DIFFICULTY_NORMAL));
init_gp_rank ++;
}
}
// Then add the AI karts (randomly chosen)
// ----------------------------------------
const unsigned int ai_kart_count = m_ai_kart_list.size();
for(unsigned int i = 0; i < ai_kart_count; i++)
{
m_kart_status.push_back(KartStatus(m_ai_kart_list[i], i, -1, -1,
init_gp_rank, KT_AI, PLAYER_DIFFICULTY_NORMAL));
init_gp_rank ++;
if(UserConfigParams::m_ftl_debug)
{
Log::debug("RaceManager", "[ftl] rank %d ai-kart %s", init_gp_rank,
m_ai_kart_list[i].c_str());
}
}
// Finally add the players, which start behind the AI karts
// -----------------------------------------------------
for(unsigned int i = 0; i < m_player_karts.size(); i++)
{
KartType kt= m_player_karts[i].isNetworkPlayer() ? KT_NETWORK_PLAYER
: KT_PLAYER;
m_kart_status.push_back(KartStatus(m_player_karts[i].getKartName(), i,
m_player_karts[i].getLocalPlayerId(),
m_player_karts[i].getGlobalPlayerId(),
init_gp_rank, kt,
m_player_karts[i].getDifficulty()));
if(UserConfigParams::m_ftl_debug)
{
Log::debug("RaceManager", "[ftl] rank %d kart %s", init_gp_rank,
m_player_karts[i].getKartName().c_str());
}
init_gp_rank ++;
}
m_track_number = 0;
if (m_major_mode == MAJOR_MODE_GRAND_PRIX)
{
if (m_continue_saved_gp)
{
m_track_number = m_saved_gp->getNextTrack();
m_saved_gp->loadKarts(m_kart_status);
}
else
{
while (m_saved_gp != NULL)
{
m_saved_gp->remove();
m_saved_gp = SavedGrandPrix::getSavedGP(
StateManager::get()
->getActivePlayerProfile(0)
->getUniqueID(),
m_grand_prix.getId(),
m_minor_mode,
m_player_karts.size());
} // while m_saved_gp
} // if m_continue_saved_gp
} // if grand prix
startNextRace();
} // startNew
