/** \brief Exit a race (and don't start the next one)
* \note In GP, displays the GP result screen first
* \param delete_world If set deletes the world.
*/
void RaceManager::exitRace(bool delete_world)
{
// Only display the grand prix result screen if all tracks
// were finished, and not when a race is aborted.
if ( m_major_mode==MAJOR_MODE_GRAND_PRIX &&
m_track_number==(int)m_tracks.size() )
{
PlayerManager::getCurrentPlayer()->grandPrixFinished();
if( m_major_mode==MAJOR_MODE_GRAND_PRIX &&
!RaceEventManager::getInstance()->isRunning() )
{
if(m_saved_gp != NULL)
m_saved_gp->remove();
}
StateManager::get()->resetAndGoToScreen( MainMenuScreen::getInstance() );
bool some_human_player_won = false;
const unsigned int kart_status_count = (unsigned int)m_kart_status.size();
const int loserThreshold = 3;
std::string winners[3];
// because we don't care about AIs that lost
std::vector<std::string> humanLosers;
for (unsigned int i=0; i < kart_status_count; ++i)
{
if(UserConfigParams::logMisc())
{
Log::info("RaceManager", "%s has GP final rank %d",
m_kart_status[i].m_ident.c_str(), m_kart_status[i].m_gp_rank);
}
const int rank = m_kart_status[i].m_gp_rank;
if (rank >= 0 && rank < loserThreshold)
{
winners[rank] = m_kart_status[i].m_ident;
if (m_kart_status[i].m_kart_type == KT_PLAYER ||
m_kart_status[i].m_kart_type == KT_NETWORK_PLAYER)
{
some_human_player_won = true;
}
}
else if (rank >= loserThreshold)
{
if (m_kart_status[i].m_kart_type == KT_PLAYER ||
m_kart_status[i].m_kart_type == KT_NETWORK_PLAYER)
{
humanLosers.push_back(m_kart_status[i].m_ident);
}
}
}
if (delete_world)
{
PropertyAnimator::get()->clear();
World::deleteWorld();
}
delete_world = false;
StateManager::get()->enterGameState();
race_manager->setMinorMode(RaceManager::MINOR_MODE_CUTSCENE);
race_manager->setNumKarts(0);
race_manager->setNumPlayers(0);
if (some_human_player_won)
{
race_manager->startSingleRace("gpwin", 999,
race_manager->raceWasStartedFromOverworld());
GrandPrixWin* scene = GrandPrixWin::getInstance();
scene->push();
scene->setKarts(winners);
}
else
{
race_manager->startSingleRace("gplose", 999,
race_manager->raceWasStartedFromOverworld());
GrandPrixLose* scene = GrandPrixLose::getInstance();
scene->push();
if (humanLosers.size() >= 1)
{
scene->setKarts(humanLosers);
}
else
{
Log::error("RaceManager", "There are no winners and no losers."
"This should have never happend\n");
std::vector<std::string> karts;
karts.push_back(UserConfigParams::m_default_kart);
scene->setKarts(karts);
}
}
}
if (delete_world)
{
PropertyAnimator::get()->clear();
World::deleteWorld();
}
m_saved_gp = NULL;
m_track_number = 0;
} // exitRace
void MainMenuScreen::eventCallback(Widget* widget, const std::string& name,
const int playerID)
{
if(name=="user-id")
{
UserScreen::getInstance()->push();
return;
}
// most interesting stuff is in the ribbons, so start there
RibbonWidget* ribbon = dynamic_cast<RibbonWidget*>(widget);
if (ribbon == NULL) return; // what's that event??
// ---- A ribbon icon was clicked
std::string selection =
ribbon->getSelectionIDString(PLAYER_ID_GAME_MASTER);
/*
if (selection == "story")
{
StateManager::get()->enterGameState();
race_manager->setMinorMode(RaceManager::MINOR_MODE_CUTSCENE);
race_manager->setNumKarts( 0 );
race_manager->setNumPlayers(0);
race_manager->setNumPlayers(0);
race_manager->startSingleRace("endcutscene", 999, false);
std::vector<std::string> parts;
parts.push_back("introcutscene");
parts.push_back("introcutscene2");
((CutsceneWorld*)World::getWorld())->setParts(parts);
//race_manager->startSingleRace("introcutscene2", 999, false);
return;
}
*/
#if DEBUG_MENU_ITEM
if (selection == "test_gpwin")
{
StoryModeStatus* sms = PlayerManager::getCurrentPlayer()->getStoryModeStatus();
sms->unlockFeature(const_cast<ChallengeStatus*>(sms->getChallengeStatus("gp1")),
RaceManager::DIFFICULTY_HARD);
StateManager::get()->enterGameState();
race_manager->setMinorMode(RaceManager::MINOR_MODE_CUTSCENE);
race_manager->setNumKarts(0);
race_manager->setNumPlayers(0);
race_manager->setNumPlayers(0);
race_manager->startSingleRace("gpwin", 999, false);
GrandPrixWin* scene = GrandPrixWin::getInstance();
scene->push();
const std::string winners[] = { "kiki", "nolok", "pidgin" };
scene->setKarts(winners);
}
else if (selection == "test_gplose")
{
StateManager::get()->enterGameState();
race_manager->setMinorMode(RaceManager::MINOR_MODE_CUTSCENE);
race_manager->setNumKarts(0);
race_manager->setNumPlayers(0);
race_manager->setNumPlayers(0);
race_manager->startSingleRace("gplose", 999, false);
GrandPrixLose* scene = GrandPrixLose::getInstance();
scene->push();
std::vector<std::string> losers;
losers.push_back("nolok");
losers.push_back("kiki");
//losers.push_back("wilber");
//losers.push_back("tux");
scene->setKarts(losers);
}
else if (selection == "test_unlocked" || selection == "test_unlocked2")
{
StoryModeStatus* sms = PlayerManager::getCurrentPlayer()->getStoryModeStatus();
sms->unlockFeature(const_cast<ChallengeStatus*>(sms->getChallengeStatus("gp1")),
RaceManager::DIFFICULTY_HARD);
StateManager::get()->enterGameState();
race_manager->setMinorMode(RaceManager::MINOR_MODE_CUTSCENE);
race_manager->setNumKarts(0);
race_manager->setNumPlayers(0);
race_manager->setNumPlayers(0);
race_manager->startSingleRace("featunlocked", 999, false);
FeatureUnlockedCutScene* scene =
FeatureUnlockedCutScene::getInstance();
std::vector<std::string> parts;
parts.push_back("featunlocked");
((CutsceneWorld*)World::getWorld())->setParts(parts);
scene->addTrophy(RaceManager::DIFFICULTY_EASY);
if (selection == "test_unlocked")
{
// the passed kart will not be modified, that's why I allow myself
// to use const_cast
scene->addUnlockedKart(
const_cast<KartProperties*>(
kart_properties_manager->getKart("tux")
),
L"You unlocked <actual text would go here...>"
);
scene->addUnlockedTrack(track_manager->getTrack("lighthouse"));
scene->push();
}
else if (selection == "test_unlocked2")
{
std::vector<video::ITexture*> textures;
textures.push_back(irr_driver->getTexture(
track_manager->getTrack("lighthouse")
->getScreenshotFile().c_str()));
textures.push_back(irr_driver->getTexture(
track_manager->getTrack("snowtuxpeak")
->getScreenshotFile().c_str()));
textures.push_back(irr_driver->getTexture(
track_manager->getTrack("sandtrack")
->getScreenshotFile().c_str()));
textures.push_back(irr_driver->getTexture(
track_manager->getTrack("snowmountain")
->getScreenshotFile().c_str()));
scene->addUnlockedPictures(textures, 4.0, 3.0, L"You unlocked <actual text would go here...>");
scene->push();
}
}
else if (selection == "test_intro")
{
CutsceneWorld::setUseDuration(true);
StateManager::get()->enterGameState();
race_manager->setMinorMode(RaceManager::MINOR_MODE_CUTSCENE);
race_manager->setNumKarts(0);
race_manager->setNumPlayers(0);
race_manager->setNumPlayers(0);
race_manager->startSingleRace("introcutscene", 999, false);
std::vector<std::string> parts;
parts.push_back("introcutscene");
parts.push_back("introcutscene2");
((CutsceneWorld*)World::getWorld())->setParts(parts);
//race_manager->startSingleRace("introcutscene2", 999, false);
return;
}
else if (selection == "test_outro")
{
CutsceneWorld::setUseDuration(true);
StateManager::get()->enterGameState();
race_manager->setMinorMode(RaceManager::MINOR_MODE_CUTSCENE);
race_manager->setNumKarts(0);
race_manager->setNumPlayers(0);
race_manager->setNumPlayers(0);
race_manager->startSingleRace("endcutscene", 999, false);
std::vector<std::string> parts;
parts.push_back("endcutscene");
((CutsceneWorld*)World::getWorld())->setParts(parts);
}
else
#endif
if (selection == "new")
{
NetworkConfig::get()->unsetNetworking();
KartSelectionScreen* s = OfflineKartSelectionScreen::getInstance();
s->setMultiplayer(false);
s->setFromOverworld(false);
s->push();
}
else if (selection == "multiplayer")
{
KartSelectionScreen* s = OfflineKartSelectionScreen::getInstance();
NetworkConfig::get()->unsetNetworking();
s->setMultiplayer(true);
s->setFromOverworld(false);
s->push();
}
else if (selection == "options")
{
OptionsScreenVideo::getInstance()->push();
}
else if (selection == "quit")
{
StateManager::get()->popMenu();
return;
}
else if (selection == "about")
{
CreditsScreen::getInstance()->push();
}
else if (selection == "help")
{
HelpScreen1::getInstance()->push();
}
else if (selection == "startTutorial")
{
race_manager->setNumPlayers(1);
race_manager->setMajorMode (RaceManager::MAJOR_MODE_SINGLE);
race_manager->setMinorMode (RaceManager::MINOR_MODE_TUTORIAL);
race_manager->setNumKarts( 1 );
race_manager->setTrack( "tutorial" );
race_manager->setDifficulty(RaceManager::DIFFICULTY_EASY);
race_manager->setReverseTrack(false);
// Use keyboard 0 by default (FIXME: let player choose?)
InputDevice* device = input_manager->getDeviceManager()->getKeyboard(0);
// Create player and associate player with keyboard
StateManager::get()->createActivePlayer(PlayerManager::getCurrentPlayer(),
device);
if (kart_properties_manager->getKart(UserConfigParams::m_default_kart) == NULL)
{
Log::warn("MainMenuScreen", "Cannot find kart '%s', will revert to default",
UserConfigParams::m_default_kart.c_str());
UserConfigParams::m_default_kart.revertToDefaults();
}
race_manager->setPlayerKart(0, UserConfigParams::m_default_kart);
// ASSIGN should make sure that only input from assigned devices
// is read.
input_manager->getDeviceManager()->setAssignMode(ASSIGN);
input_manager->getDeviceManager()
->setSinglePlayer( StateManager::get()->getActivePlayer(0) );
StateManager::get()->enterGameState();
race_manager->setupPlayerKartInfo();
race_manager->startNew(false);
}
else if (selection == "story")
{
NetworkConfig::get()->unsetNetworking();
PlayerProfile *player = PlayerManager::getCurrentPlayer();
if (player->isFirstTime())
{
CutsceneWorld::setUseDuration(true);
StateManager::get()->enterGameState();
race_manager->setMinorMode(RaceManager::MINOR_MODE_CUTSCENE);
race_manager->setNumKarts( 0 );
race_manager->setNumPlayers(0);
race_manager->startSingleRace("introcutscene", 999, false);
std::vector<std::string> parts;
parts.push_back("introcutscene");
parts.push_back("introcutscene2");
((CutsceneWorld*)World::getWorld())->setParts(parts);
//race_manager->startSingleRace("introcutscene2", 999, false);
return;
}
else
{
const std::string default_kart = UserConfigParams::m_default_kart;
if (player->isLocked(default_kart))
{
KartSelectionScreen *next = OfflineKartSelectionScreen::getInstance();
next->setGoToOverworldNext();
next->setMultiplayer(false);
StateManager::get()->resetAndGoToScreen(next);
return;
}
OverWorld::enterOverWorld();
}
}
else if (selection == "online")
{
if(UserConfigParams::m_internet_status!=RequestManager::IPERM_ALLOWED)
{
new MessageDialog(_("You can not play online without internet access. "
"If you want to play online, go to options, select "
" tab 'User Interface', and edit "
"\"Connect to the Internet\"."));
return;
}
// Define this to require a login to the stk server (default behaviour)
// Undefine for testing LAN only.
if (MainMenuScreen::m_enable_online)
{
OnlineScreen::getInstance()->push();
}
else
{
if (PlayerManager::getCurrentOnlineId())
{
ProfileManager::get()->setVisiting(PlayerManager::getCurrentOnlineId());
TabOnlineProfileAchievements::getInstance()->push();
}
else
{
UserScreen::getInstance()->push();
}
}
}
else if (selection == "addons")
{
// Don't go to addons if there is no internet, unless some addons are
// already installed (so that you can delete addons without being online).
if(UserConfigParams::m_internet_status!=RequestManager::IPERM_ALLOWED &&
!addons_manager->anyAddonsInstalled())
{
new MessageDialog(_("You can not download addons without internet access. "
"If you want to download addons, go to options, select "
" tab 'User Interface', and edit "
"\"Connect to the Internet\"."));
return;
}
AddonsScreen::getInstance()->push();
}
else if (selection == "gpEditor")
{
GrandPrixEditorScreen::getInstance()->push();
}
else if (selection == "achievements")
{
OnlineProfileAchievements::getInstance()->push();
}
} // eventCallback
void RaceManager::exitRace(bool delete_world)
{
// Only display the grand prix result screen if all tracks
// were finished, and not when a race is aborted.
if (m_major_mode==MAJOR_MODE_GRAND_PRIX && m_track_number==(int)m_tracks.size())
{
PlayerManager::getCurrentPlayer()->grandPrixFinished();
if(m_major_mode==MAJOR_MODE_GRAND_PRIX&& !NetworkWorld::getInstance()->isRunning())
{
//Delete saved GP
SavedGrandPrix* gp =
SavedGrandPrix::getSavedGP(StateManager::get()
->getActivePlayerProfile(0)
->getUniqueID(),
m_grand_prix.getId(),
m_difficulty,
m_num_karts,
m_player_karts.size());
if(gp != NULL) gp->remove();
}
StateManager::get()->resetAndGoToScreen( MainMenuScreen::getInstance() );
bool someHumanPlayerWon = false;
const unsigned int kartStatusCount = m_kart_status.size();
const int loserThreshold = 3;
std::string winners[3];
std::vector<std::string> humanLosers; // because we don't care about AIs that lost
for (unsigned int i=0; i < kartStatusCount; ++i)
{
if(UserConfigParams::logMisc())
{
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 < loserThreshold)
{
winners[rank] = m_kart_status[i].m_ident;
if (m_kart_status[i].m_kart_type == KT_PLAYER ||
m_kart_status[i].m_kart_type == KT_NETWORK_PLAYER)
{
someHumanPlayerWon = true;
}
}
else if (rank >= loserThreshold)
{
if (m_kart_status[i].m_kart_type == KT_PLAYER ||
m_kart_status[i].m_kart_type == KT_NETWORK_PLAYER)
{
humanLosers.push_back(m_kart_status[i].m_ident);
}
}
}
if (someHumanPlayerWon)
{
if (delete_world) World::deleteWorld();
delete_world = false;
StateManager::get()->enterGameState();
race_manager->setMinorMode(RaceManager::MINOR_MODE_CUTSCENE);
race_manager->setNumKarts(0);
race_manager->setNumPlayers(0);
race_manager->setNumLocalPlayers(0);
race_manager->startSingleRace("gpwin", 999, false);
GrandPrixWin* scene = GrandPrixWin::getInstance();
StateManager::get()->pushScreen(scene);
scene->setKarts(winners);
}
else
{
if (delete_world) World::deleteWorld();
delete_world = false;
StateManager::get()->enterGameState();
race_manager->setMinorMode(RaceManager::MINOR_MODE_CUTSCENE);
race_manager->setNumKarts(0);
race_manager->setNumPlayers(0);
race_manager->setNumLocalPlayers(0);
race_manager->startSingleRace("gplose", 999, false);
GrandPrixLose* scene = GrandPrixLose::getInstance();
StateManager::get()->pushScreen(scene);
if (humanLosers.size() >= 1)
{
scene->setKarts(humanLosers);
}
else
{
std::cerr << "RaceManager::exitRace() : what's going on?? no winners and no losers??\n";
std::vector<std::string> karts;
karts.push_back(UserConfigParams::m_default_kart);
scene->setKarts(karts);
}
}
}
if (delete_world) World::deleteWorld();
m_track_number = 0;
} // exitRace
