GUIEngine::EventPropagation MessageDialog::processEvent(const std::string& eventSource)
{
RibbonWidget* ribbon = getWidget<RibbonWidget>(eventSource.c_str());
if (ribbon->getSelectionIDString(PLAYER_ID_GAME_MASTER) == "cancel")
{
if (m_listener == NULL)
{
ModalDialog::dismiss();
}
else
{
m_listener->onCancel();
}
return GUIEngine::EVENT_BLOCK;
}
else if (ribbon->getSelectionIDString(PLAYER_ID_GAME_MASTER) == "confirm")
{
if (m_listener == NULL)
{
ModalDialog::dismiss();
}
else
{
m_listener->onConfirm();
}
return GUIEngine::EVENT_BLOCK;
}
return GUIEngine::EVENT_LET;
}
const std::string& DynamicRibbonWidget::getSelectionIDString(const int playerID)
{
RibbonWidget* row = (RibbonWidget*)(m_rows.size() == 1 ? m_rows.get(0) : getSelectedRibbon(playerID));
if (row != NULL) return row->getSelectionIDString(playerID);
static const std::string nothing = "";
return nothing;
}
/** Rebuild the list of tracks and GPs. This need to be recomputed e.g. to
* take unlocked tracks into account.
*/
void TracksScreen::buildTrackList()
{
DynamicRibbonWidget* tracks_widget = this->getWidget<DynamicRibbonWidget>("tracks");
RibbonWidget* tabs = this->getWidget<RibbonWidget>("trackgroups");
// Reset track list everytime (accounts for locking changes, etc.)
tracks_widget->clearItems();
m_random_track_list.clear();
const std::string& curr_group_name = tabs->getSelectionIDString(0);
const int track_amount = (int)track_manager->getNumberOfTracks();
// First build a list of all tracks to be displayed
// (e.g. exclude arenas, ...)
PtrVector<Track, REF> tracks;
for (int n = 0; n < track_amount; n++)
{
Track* curr = track_manager->getTrack(n);
if (race_manager->getMinorMode() == RaceManager::MINOR_MODE_EASTER_EGG
&& !curr->hasEasterEggs())
continue;
if (curr->isArena() || curr->isSoccer()||curr->isInternal()) continue;
if (curr_group_name != ALL_TRACK_GROUPS_ID &&
!curr->isInGroup(curr_group_name)) continue;
tracks.push_back(curr);
} // for n<track_amount
tracks.insertionSort();
for (unsigned int i = 0; i < tracks.size(); i++)
{
Track *curr = tracks.get(i);
if (PlayerManager::getCurrentPlayer()->isLocked(curr->getIdent()))
{
tracks_widget->addItem(
_("Locked : solve active challenges to gain access to more!"),
"locked", curr->getScreenshotFile(), LOCKED_BADGE,
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE);
}
else
{
tracks_widget->addItem(translations->fribidize(curr->getName()),
curr->getIdent(),
curr->getScreenshotFile(), 0,
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE);
m_random_track_list.push_back(curr->getIdent());
}
}
tracks_widget->addItem(_("Random Track"), "random_track",
"/gui/track_random.png", 0 /* no badge */,
IconButtonWidget::ICON_PATH_TYPE_RELATIVE);
tracks_widget->updateItemDisplay();
std::random_shuffle( m_random_track_list.begin(), m_random_track_list.end() );
} // buildTrackList
// -----------------------------------------------------------------------------
EventPropagation DynamicRibbonWidget::leftPressed(const int playerID)
{
if (m_deactivated) return EVENT_LET;
RibbonWidget* w = getSelectedRibbon(playerID);
if (w != NULL)
{
updateLabel();
propagateSelection();
for_var_in (DynamicRibbonHoverListener*, listener, m_hover_listeners)
{
listener->onSelectionChanged(this, w->getSelectionIDString(playerID),
w->getSelectionText(playerID), playerID);
}
/** Process input events.
* \event_source name of the widget that triggered the event.
*/
EventPropagation RegistrationDialog::processEvent(const std::string& event_source)
{
if (event_source == "options")
{
RibbonWidget *rib = getWidget<RibbonWidget>("options");
std::string s = rib->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if(s=="accept")
{
Screen *s = GUIEngine::getCurrentScreen();
RegisterScreen *r = dynamic_cast<RegisterScreen*>(s);
assert(r);
r->acceptTerms();
}
// If it's not accept, it's cancel - anyway, close dialog
ModalDialog::dismiss();
return EVENT_BLOCK;
}
return EVENT_LET;
} // processEvent
// -----------------------------------------------------------------------------
void EditTrackScreen::eventCallback(GUIEngine::Widget* widget, const std::string& name,
const int playerID)
{
if (name == "ok")
{
m_result = true;
StateManager::get()->popMenu();
}
else if (name == "cancel")
{
m_result = false;
StateManager::get()->popMenu();
}
else if (name == "tracks")
{
DynamicRibbonWidget* tracks = getWidget<DynamicRibbonWidget>("tracks");
assert(tracks != NULL);
selectTrack(tracks->getSelectionIDString(PLAYER_ID_GAME_MASTER));
}
else if (name == "trackgroups")
{
RibbonWidget* tabs = getWidget<RibbonWidget>("trackgroups");
assert(tabs != NULL);
m_track_group = tabs->getSelectionIDString(PLAYER_ID_GAME_MASTER);
loadTrackList();
}
else if (name == "laps")
{
SpinnerWidget* laps = getWidget<SpinnerWidget>("laps");
assert(laps != NULL);
m_laps = laps->getValue();
}
else if (name == "reverse")
{
CheckBoxWidget* reverse = getWidget<CheckBoxWidget>("reverse");
assert(reverse != NULL);
m_reverse = reverse->getState();
}
}
void OnlineScreen::eventCallback(Widget* widget, const std::string& name,
const int playerID)
{
if (name == m_back_widget->m_properties[PROP_ID])
{
StateManager::get()->escapePressed();
return;
}
RibbonWidget* ribbon = dynamic_cast<RibbonWidget*>(widget);
if (ribbon == NULL) return;
std::string selection = ribbon->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (selection == m_sign_out_widget->m_properties[PROP_ID])
{
PlayerManager::requestSignOut();
StateManager::get()->popMenu();
}
else if (selection == m_profile_widget->m_properties[PROP_ID])
{
ProfileManager::get()->setVisiting(PlayerManager::getCurrentOnlineId());
OnlineProfileAchievements::getInstance()->push();
}
else if (selection == m_find_server_widget->m_properties[PROP_ID])
{
ServerSelection::getInstance()->push();
}
else if (selection == m_create_server_widget->m_properties[PROP_ID])
{
CreateServerScreen::getInstance()->push();
}
else if (selection == m_quick_play_widget->m_properties[PROP_ID])
{
doQuickPlay();
}
} // eventCallback
void EasterEggScreen::eventCallback(Widget* widget, const std::string& name, const int playerID)
{
// -- track selection screen
if (name == "tracks")
{
DynamicRibbonWidget* w2 = dynamic_cast<DynamicRibbonWidget*>(widget);
if (w2 != NULL)
{
const std::string selection = w2->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if(UserConfigParams::logGUI())
std::cout << "Clicked on track " << selection.c_str()
<< std::endl;
UserConfigParams::m_last_track = selection;
if (selection == "random_track")
{
RibbonWidget* tabs = this->getWidget<RibbonWidget>("trackgroups");
assert( tabs != NULL );
if (m_random_track_list.empty()) return;
std::string track = m_random_track_list.front();
m_random_track_list.pop_front();
m_random_track_list.push_back(track);
Track* clicked_track = track_manager->getTrack( track );
if (clicked_track != NULL)
{
TrackInfoScreen::getInstance()->setTrack(clicked_track);
StateManager::get()->pushScreen(TrackInfoScreen::getInstance());
}
}
else if (selection == "locked")
{
unlock_manager->playLockSound();
}
else if (selection != RibbonWidget::NO_ITEM_ID)
{
Track* clicked_track = track_manager->getTrack(selection);
if (clicked_track != NULL)
{
TrackInfoScreen::getInstance()->setTrack(clicked_track);
StateManager::get()->pushScreen(TrackInfoScreen::getInstance());
}
}
}
}
else if (name == "trackgroups")
{
RibbonWidget* tabs = this->getWidget<RibbonWidget>("trackgroups");
assert( tabs != NULL );
UserConfigParams::m_last_used_track_group = tabs->getSelectionIDString(0);
buildTrackList();
}
else if (name == "back")
{
StateManager::get()->escapePressed();
}
}
void EasterEggScreen::eventCallback(Widget* widget, const std::string& name, const int playerID)
{
// -- track selection screen
if (name == "tracks")
{
DynamicRibbonWidget* w2 = dynamic_cast<DynamicRibbonWidget*>(widget);
if (w2 != NULL)
{
const std::string selection = w2->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if(UserConfigParams::logGUI())
std::cout << "Clicked on track " << selection.c_str()
<< std::endl;
UserConfigParams::m_last_track = selection;
if (selection == "random_track")
{
RibbonWidget* tabs = this->getWidget<RibbonWidget>("trackgroups");
assert( tabs != NULL );
if (m_random_track_list.empty()) return;
std::string track = m_random_track_list.front();
m_random_track_list.pop_front();
m_random_track_list.push_back(track);
Track* clickedTrack = track_manager->getTrack( track );
if (clickedTrack != NULL)
{
ITexture* screenshot =
irr_driver->getTexture( clickedTrack->getScreenshotFile(),
"While loading screenshot for track '%s':",
clickedTrack->getFilename() );
new TrackInfoDialog(selection, clickedTrack->getIdent(),
translations->fribidize(clickedTrack->getName()),
screenshot, 0.8f, 0.7f);
}
}
else if (selection == "locked")
{
unlock_manager->playLockSound();
}
else if (selection == RibbonWidget::NO_ITEM_ID)
{
}
else
{
Track* clickedTrack = track_manager->getTrack(selection);
if (clickedTrack != NULL)
{
ITexture* screenshot =
irr_driver->getTexture( clickedTrack->getScreenshotFile(),
"While loading screenshot for track '%s'",
clickedTrack->getFilename());
new TrackInfoDialog(selection, clickedTrack->getIdent(),
translations->fribidize(clickedTrack->getName()),
screenshot, 0.8f, 0.7f);
}
}
}
}
else if (name == "trackgroups")
{
RibbonWidget* tabs = this->getWidget<RibbonWidget>("trackgroups");
assert( tabs != NULL );
UserConfigParams::m_last_used_track_group = tabs->getSelectionIDString(0);
buildTrackList();
}
else if (name == "back")
{
StateManager::get()->escapePressed();
}
}
void EasterEggScreen::buildTrackList()
{
DynamicRibbonWidget* tracks_widget = this->getWidget<DynamicRibbonWidget>("tracks");
assert( tracks_widget != NULL );
RibbonWidget* tabs = this->getWidget<RibbonWidget>("trackgroups");
assert( tabs != NULL );
// Reset track list everytime (accounts for locking changes, etc.)
tracks_widget->clearItems();
m_random_track_list.clear();
const std::string curr_group_name = tabs->getSelectionIDString(0);
// Build track list
if (curr_group_name == ALL_TRACK_GROUPS_ID)
{
const int trackAmount = track_manager->getNumberOfTracks();
for (int n=0; n<trackAmount; n++)
{
Track* curr = track_manager->getTrack( n );
if(race_manager->getMinorMode()==RaceManager::MINOR_MODE_EASTER_EGG
&& !curr->hasEasterEggs())
continue;
if (curr->isArena() || curr->isSoccer()) continue;
if (curr->isInternal()) continue;
if (PlayerManager::getCurrentPlayer()->isLocked(curr->getIdent()))
{
tracks_widget->addItem( _("Locked : solve active challenges to gain access to more!"),
"locked", curr->getScreenshotFile(), LOCKED_BADGE,
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE);
}
else
{
tracks_widget->addItem(translations->fribidize(curr->getName()), curr->getIdent(),
curr->getScreenshotFile(), 0,
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE );
m_random_track_list.push_back(curr->getIdent());
}
}
}
else
{
const std::vector<int>& curr_group = track_manager->getTracksInGroup( curr_group_name );
const int trackAmount = curr_group.size();
for (int n=0; n<trackAmount; n++)
{
Track* curr = track_manager->getTrack( curr_group[n] );
if(race_manager->getMinorMode()==RaceManager::MINOR_MODE_EASTER_EGG
&& !curr->hasEasterEggs())
continue;
if (curr->isArena()) continue;
if (curr->isSoccer()) continue;
if (curr->isInternal()) continue;
if (PlayerManager::getCurrentPlayer()->isLocked(curr->getIdent()))
{
tracks_widget->addItem( _("Locked : solve active challenges to gain access to more!"),
"locked", curr->getScreenshotFile(), LOCKED_BADGE,
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE);
}
else
{
tracks_widget->addItem(translations->fribidize(curr->getName()), curr->getIdent(),
curr->getScreenshotFile(), 0 /* no badge */,
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE );
m_random_track_list.push_back(curr->getIdent());
}
}
}
tracks_widget->addItem(_("Random Track"), "random_track", "/gui/track_random.png",
0 /* no badge */, IconButtonWidget::ICON_PATH_TYPE_RELATIVE);
tracks_widget->updateItemDisplay();
std::random_shuffle( m_random_track_list.begin(), m_random_track_list.end() );
}
/**
* Callback handling events from the kart selection menu
*/
void KartSelectionScreen::eventCallback(Widget* widget,
const std::string& name,
const int player_id)
{
// don't allow changing group after someone confirmed
if (name == "kartgroups" && !m_game_master_confirmed)
{
RibbonWidget* tabs = getWidget<RibbonWidget>("kartgroups");
assert(tabs != NULL);
DynamicRibbonWidget* w = getWidget<DynamicRibbonWidget>("karts");
assert(w != NULL);
setKartsFromCurrentGroup();
const std::string &selected_kart_group =
tabs->getSelectionIDString(PLAYER_ID_GAME_MASTER);
UserConfigParams::m_last_used_kart_group = selected_kart_group;
RandomGenerator random;
const int num_players = m_kart_widgets.size();
for (int n=0; n<num_players; n++)
{
// The game master is the one that can change the groups, leave
// his focus on the tabs for others, remove focus from kart that
// might no more exist in this tab.
if (n != PLAYER_ID_GAME_MASTER)
GUIEngine::focusNothingForPlayer(n);
if (!m_kart_widgets[n].isReady())
{
// try to preserve the same kart for each player (except for
// game master, since it's the one that can change the
// groups, so focus for this player must remain on the tabs)
const std::string& selected_kart =
m_kart_widgets[n].getKartInternalName();
if (!w->setSelection( selected_kart, n,
n != PLAYER_ID_GAME_MASTER))
{
// if we get here, it means one player "lost" his kart in
// the tab switch
if (UserConfigParams::logGUI())
Log::info("KartSelectionScreen", "Player %u"
" lost their selection when switching tabs!!!",n);
// Select a random kart in this case
const int count = (int) w->getItems().size();
if (count > 0)
{
// FIXME: two players may be given the same kart by
// the use of random
const int random_id = random.get( count );
// select kart for players > 0 (player 0 is the one
// that can change the groups, so focus for player 0
// must remain on the tabs)
const bool success =
w->setSelection( random_id, n,
n != PLAYER_ID_GAME_MASTER );
if (!success)
Log::warn("KartSelectionScreen",
"setting kart of player %u failed");
}
else
{
Log::warn("KartSelectionScreen", " 0 items "
"in the ribbon");
}
}
}
} // end for
}
else if (name == "karts")
{
if (m_kart_widgets.size() > unsigned(player_id))
playerConfirm(player_id);
}
else if (name == "back")
{
StateManager::get()->escapePressed();
}
else
{
// Transmit to all subwidgets, maybe *they* care about this event
const int amount = m_kart_widgets.size();
for (int n=0; n<amount; n++)
{
m_kart_widgets[n].transmitEvent(widget, name, player_id);
}
// those events may mean that a player selection changed, so
// validate again
validateIdentChoices();
validateKartChoices();
}
} // eventCallback
void MainMenuScreen::eventCallback(Widget* widget, const std::string& name,
const int playerID)
{
// 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->setNumLocalPlayers(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 == "options")
{
// The DEBUG item
FeatureUnlockedCutScene* scene =
FeatureUnlockedCutScene::getInstance();
scene->addTrophy(RaceManager::DIFFICULTY_EASY);
StateManager::get()->pushScreen(scene);
/*
static int i = 1;
i++;
if (i % 4 == 0)
{
// 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"Unlocked"
);
StateManager::get()->pushScreen(scene);
}
else if (i % 4 == 1)
{
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("crescentcrossing")
->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, 1.0, 0.75, L"You did it");
StateManager::get()->pushScreen(scene);
}
else if (i % 4 == 2)
{
GrandPrixWin* scene = GrandPrixWin::getInstance();
const std::string winners[] = { "elephpant", "nolok", "pidgin" };
StateManager::get()->pushScreen(scene);
scene->setKarts( winners );
}
else
{
GrandPrixLose* scene = GrandPrixLose::getInstance();
StateManager::get()->pushScreen(scene);
std::vector<std::string> losers;
losers.push_back("nolok");
losers.push_back("elephpant");
losers.push_back("wilber");
scene->setKarts( losers );
}
*/
}
else
#endif
if (selection == "new")
{
KartSelectionScreen* s = KartSelectionScreen::getInstance();
s->setMultiplayer(false);
s->setFromOverworld(false);
StateManager::get()->pushScreen( s );
}
else if (selection == "multiplayer")
{
KartSelectionScreen* s = KartSelectionScreen::getInstance();
s->setMultiplayer(true);
s->setFromOverworld(false);
StateManager::get()->pushScreen( s );
}
else if (selection == "options")
{
StateManager::get()->pushScreen( OptionsScreenVideo::getInstance() );
}
else if (selection == "quit")
{
StateManager::get()->popMenu();
return;
}
else if (selection == "about")
{
StateManager::get()->pushScreen(CreditsScreen::getInstance());
}
else if (selection == "help")
{
StateManager::get()->pushScreen(HelpScreen1::getInstance());
}
else if (selection == "story")
{
GameSlot* slot = unlock_manager->getCurrentSlot();
if (slot->isFirstTime())
{
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("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
{
OverWorld::enterOverWorld();
}
}
else if (selection == "tutorial")
{
StateManager::get()->pushScreen(TutorialScreen::getInstance());
}
else if (selection == "addons")
{
StateManager::get()->pushScreen(AddonsScreen::getInstance());
}
} // eventCallback
void ArenasScreen::eventCallback(Widget* widget, const std::string& name, const int playerID)
{
if (name == "tracks")
{
DynamicRibbonWidget* w2 = dynamic_cast<DynamicRibbonWidget*>(widget);
if (w2 == NULL) return;
const std::string selection = w2->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (UserConfigParams::logGUI())
std::cout << "Clicked on arena " << selection.c_str() << std::endl;
if (selection == "random_track")
{
RibbonWidget* tabs = this->getWidget<RibbonWidget>("trackgroups");
assert( tabs != NULL );
const std::vector<int>& curr_group = track_manager->getArenasInGroup(
tabs->getSelectionIDString(PLAYER_ID_GAME_MASTER) );
RandomGenerator random;
const int randomID = random.get(curr_group.size());
Track* clickedTrack = track_manager->getTrack( curr_group[randomID] );
if (clickedTrack != NULL)
{
ITexture* screenshot = irr_driver->getTexture( clickedTrack->getScreenshotFile().c_str() );
new TrackInfoDialog(selection, clickedTrack->getIdent(), clickedTrack->getName(),
screenshot, 0.8f, 0.7f);
}
}
else if (selection == "locked")
{
unlock_manager->playLockSound();
}
else if (selection == RibbonWidget::NO_ITEM_ID)
{
}
else
{
Track* clickedTrack = track_manager->getTrack(selection);
if (clickedTrack != NULL)
{
ITexture* screenshot = irr_driver->getTexture( clickedTrack->getScreenshotFile().c_str() );
new TrackInfoDialog(selection, clickedTrack->getIdent(), clickedTrack->getName(),
screenshot, 0.8f, 0.7f);
} // clickedTrack != NULL
} // if random_track
}
else if (name == "trackgroups")
{
buildTrackList();
}
else if (name == "back")
{
StateManager::get()->escapePressed();
}
} // eventCallback
void ArenasScreen::eventCallback(Widget* widget, const std::string& name, const int playerID)
{
if (name == "tracks")
{
DynamicRibbonWidget* w2 = dynamic_cast<DynamicRibbonWidget*>(widget);
if (w2 == NULL) return;
const std::string selection = w2->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (UserConfigParams::logGUI())
Log::info("ArenasScreen", "Clicked on arena %s", selection.c_str());
if (selection == "random_track")
{
RibbonWidget* tabs = this->getWidget<RibbonWidget>("trackgroups");
assert( tabs != NULL );
bool soccer_mode = race_manager->getMinorMode() == RaceManager::MINOR_MODE_SOCCER;
std::vector<int> curr_group;
if (tabs->getSelectionIDString(PLAYER_ID_GAME_MASTER) == ALL_ARENA_GROUPS_ID)
{
const std::vector<std::string>& groups = track_manager->getAllArenaGroups();
for (unsigned int i = 0; i < groups.size(); i++)
{
const std::vector<int>& tmp_group = track_manager->getArenasInGroup(groups[i], soccer_mode);
// Append to our main vector
curr_group.insert(curr_group.end(), tmp_group.begin(), tmp_group.end());
}
} // if on tab "all"
else
{
curr_group = track_manager->getArenasInGroup(
tabs->getSelectionIDString(PLAYER_ID_GAME_MASTER), soccer_mode );
}
// Remove unsupported arena
if (m_unsupported_arena.size() > 0)
{
for (std::set<int>::iterator it = m_unsupported_arena.begin();
it != m_unsupported_arena.end(); ++it)
{
curr_group.erase(std::remove(curr_group.begin(),
curr_group.end(), *it), curr_group.end());
}
}
RandomGenerator random;
const int randomID = random.get((int)curr_group.size());
Track* clicked_track = track_manager->getTrack( curr_group[randomID] );
if (clicked_track != NULL)
{
TrackInfoScreen::getInstance()->setTrack(clicked_track);
TrackInfoScreen::getInstance()->push();
}
}
else if (selection == "locked")
{
unlock_manager->playLockSound();
}
else if (selection == RibbonWidget::NO_ITEM_ID)
{
}
else
{
Track* clicked_track = track_manager->getTrack(selection);
if (clicked_track != NULL)
{
TrackInfoScreen::getInstance()->setTrack(clicked_track);
TrackInfoScreen::getInstance()->push();
} // clickedTrack != NULL
} // if random_track
}
else if (name == "trackgroups")
{
buildTrackList();
}
else if (name == "back")
{
StateManager::get()->escapePressed();
}
} // eventCallback
void TracksScreen::eventCallback(Widget* widget, const std::string& name,
const int playerID)
{
if ((name == "lap-spinner" || name == "reverse") &&
STKHost::existHost() && m_selected_track != NULL)
{
voteForPlayer();
}
else if (name == "vote-list")
{
auto cl = LobbyProtocol::get<ClientLobby>();
ListWidget* list = dynamic_cast<ListWidget*>(widget);
DynamicRibbonWidget* tracks_widget =
getWidget<DynamicRibbonWidget>("tracks");
if (!list || !cl || !tracks_widget || !m_laps || !m_reversed)
return;
// Vote to agree with selection of host id
uint32_t host_id = -1;
if (StringUtils::fromString(list->getSelectionInternalName(),
host_id) && host_id != STKHost::get()->getMyHostId())
{
const PeerVote* host_vote = cl->getVote(host_id);
if (host_vote)
{
m_selected_track = track_manager->getTrack(
host_vote->m_track_name);
if (!m_selected_track)
return;
tracks_widget->setBadge(host_vote->m_track_name, OK_BADGE);
m_laps->setValue(host_vote->m_num_laps);
m_reversed->setState(host_vote->m_reverse);
voteForPlayer();
}
}
}
else if (name == "tracks")
{
DynamicRibbonWidget* w2 = dynamic_cast<DynamicRibbonWidget*>(widget);
if(!w2) return;
std::string selection = w2->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (UserConfigParams::logGUI())
{
Log::info("TracksScreen", "Clicked on track '%s'.",
selection.c_str());
}
UserConfigParams::m_last_track = selection;
if (selection == "locked" && race_manager->getNumLocalPlayers() == 1)
{
unlock_manager->playLockSound();
return;
}
else if (selection == RibbonWidget::NO_ITEM_ID)
{
return;
}
if (selection == "random_track")
{
if (m_random_track_list.empty()) return;
selection = m_random_track_list.front();
m_random_track_list.pop_front();
m_random_track_list.push_back(selection);
} // selection=="random_track"
m_selected_track = track_manager->getTrack(selection);
if (m_selected_track)
{
if (STKHost::existHost())
{
w2->setBadge(selection, OK_BADGE);
voteForPlayer();
}
else
{
TrackInfoScreen::getInstance()->setTrack(m_selected_track);
TrackInfoScreen::getInstance()->push();
}
} // if clicked_track
} // name=="tracks"
else if (name == "trackgroups")
{
RibbonWidget* tabs = this->getWidget<RibbonWidget>("trackgroups");
UserConfigParams::m_last_used_track_group = tabs->getSelectionIDString(0);
buildTrackList();
if (m_network_tracks)
{
auto cl = LobbyProtocol::get<ClientLobby>();
const PeerVote* vote = cl->getVote(STKHost::get()->getMyHostId());
if (vote)
{
DynamicRibbonWidget* w2 = getWidget<DynamicRibbonWidget>("tracks");
w2->setBadge(vote->m_track_name, OK_BADGE);
}
}
}
else if (name == "back")
{
StateManager::get()->escapePressed();
}
} // eventCallback
// -----------------------------------------------------------------------------
void EditGPScreen::eventCallback(GUIEngine::Widget* widget, const std::string& name,
const int playerID)
{
setSelected(m_list->getSelectionID());
if (name == "tracks")
{
m_action = "edit";
edit();
}
else if (name == "menu")
{
RibbonWidget* menu = getWidget<RibbonWidget>("menu");
assert(menu != NULL);
m_action = menu->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (m_action == "up")
{
if (canMoveUp())
{
m_gp->moveUp(m_selected--);
loadList(m_selected);
setModified(true);
}
}
else if (m_action == "down")
{
if (canMoveDown())
{
m_gp->moveDown(m_selected++);
loadList(m_selected);
setModified(true);
}
}
else if (m_action == "add" || m_action == "edit")
{
if (m_action == "edit")
{
edit();
}
else
{
EditTrackScreen* edit = EditTrackScreen::getInstance();
assert(edit != NULL);
//By default, 3 laps and no reversing
edit->setSelection(NULL, 3, false);
StateManager::get()->pushScreen(edit);
}
}
else if (m_action == "remove")
{
if (m_selected >= 0 && m_selected < m_list->getItemCount())
{
new MessageDialog(
_("Are you sure you want to remove '%s'?",
m_gp->getTrackName(m_selected).c_str()),
MessageDialog::MESSAGE_DIALOG_CONFIRM,
this, false);
}
}
else if (m_action == "save")
{
save();
}
}
else if (name == "back")
{
if (m_modified)
{
m_action = "back";
new MessageDialog(
_("Do you want to save your changes?"),
MessageDialog::MESSAGE_DIALOG_CONFIRM,
this, false);
}
else
{
back();
}
}
}
void RaceSetupScreen::eventCallback(Widget* widget, const std::string& name, const int playerID)
{
if (name == "difficulty")
{
RibbonWidget* w = dynamic_cast<RibbonWidget*>(widget);
assert(w != NULL);
const std::string& selection = w->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (selection == "novice")
{
UserConfigParams::m_difficulty = RaceManager::DIFFICULTY_EASY;
race_manager->setDifficulty(RaceManager::DIFFICULTY_EASY);
}
else if (selection == "intermediate")
{
UserConfigParams::m_difficulty = RaceManager::DIFFICULTY_MEDIUM;
race_manager->setDifficulty(RaceManager::DIFFICULTY_MEDIUM);
}
else if (selection == "expert")
{
UserConfigParams::m_difficulty = RaceManager::DIFFICULTY_HARD;
race_manager->setDifficulty(RaceManager::DIFFICULTY_HARD);
}
}
else if (name == "gamemode")
{
DynamicRibbonWidget* w = dynamic_cast<DynamicRibbonWidget*>(widget);
const std::string& selectedMode = w->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (selectedMode == IDENT_STD)
{
race_manager->setMinorMode(RaceManager::MINOR_MODE_NORMAL_RACE);
UserConfigParams::m_game_mode = CONFIG_CODE_NORMAL;
StateManager::get()->pushScreen( TracksScreen::getInstance() );
}
else if (selectedMode == IDENT_TTRIAL)
{
race_manager->setMinorMode(RaceManager::MINOR_MODE_TIME_TRIAL);
UserConfigParams::m_game_mode = CONFIG_CODE_TIMETRIAL;
StateManager::get()->pushScreen( TracksScreen::getInstance() );
}
else if (selectedMode == IDENT_FTL)
{
// Make sure there are at least three karts, otherwise FTL doesn't
if(race_manager->getNumberOfKarts()<3)
race_manager->setNumKarts(3);
race_manager->setMinorMode(RaceManager::MINOR_MODE_FOLLOW_LEADER);
UserConfigParams::m_game_mode = CONFIG_CODE_FTL;
StateManager::get()->pushScreen( TracksScreen::getInstance() );
}
else if (selectedMode == IDENT_STRIKES)
{
race_manager->setMinorMode(RaceManager::MINOR_MODE_3_STRIKES);
UserConfigParams::m_game_mode = CONFIG_CODE_3STRIKES;
race_manager->setNumKarts( race_manager->getNumLocalPlayers() ); // no AI karts;
StateManager::get()->pushScreen( ArenasScreen::getInstance() );
}
else if (selectedMode == "locked")
{
unlock_manager->playLockSound();
}
}
else if (name == "aikartamount")
{
SpinnerWidget* w = dynamic_cast<SpinnerWidget*>(widget);
race_manager->setNumKarts( race_manager->getNumLocalPlayers() + w->getValue() );
UserConfigParams::m_num_karts = race_manager->getNumLocalPlayers() + w->getValue();
}
else if (name == "back")
{
StateManager::get()->escapePressed();
}
}
// -----------------------------------------------------------------------------
void GrandPrixEditorScreen::eventCallback(Widget* widget, const std::string& name, const int playerID)
{
if (name == "gplist")
{
DynamicRibbonWidget* gplist_widget = getWidget<DynamicRibbonWidget>("gplist");
assert (gplist_widget != NULL);
std::string selected = gplist_widget->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (!selected.empty())
{
if (m_selection != NULL && selected == m_selection->getId() && m_selection->isEditable())
showEditScreen(m_selection);
else
setSelection (grand_prix_manager->getGrandPrix(selected));
}
}
else if (name == "menu")
{
RibbonWidget* menu = getWidget<RibbonWidget>("menu");
assert(menu != NULL);
m_action = menu->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (m_action == "new" || m_action == "copy")
{
new EnterGPNameDialog(this, 0.5f, 0.4f);
}
else if (m_action == "edit" && m_selection != NULL)
{
showEditScreen(m_selection);
}
else if (m_action == "remove" && m_selection != NULL)
{
new MessageDialog(
_("Are you sure you want to remove '%s'?", m_selection->getName().c_str()),
MessageDialog::MESSAGE_DIALOG_CONFIRM,
this, false);
}
else if (m_action == "rename" && m_selection != NULL)
{
new EnterGPNameDialog(this, 0.5f, 0.4f);
}
}
else if (name == "gpgroups")
{
RibbonWidget* tabs = getWidget<RibbonWidget>("gpgroups");
assert(tabs != NULL);
enum GrandPrixData::GPGroupType group = (enum GrandPrixData::GPGroupType)atoi(
tabs->getSelectionIDString(PLAYER_ID_GAME_MASTER).c_str());
if (m_gpgroup != group)
{
m_gpgroup = group;
loadGPList();
setSelection(NULL);
}
}
else if (name == "back")
{
m_gpgroup = GrandPrixData::GP_NONE;
setSelection(NULL);
StateManager::get()->escapePressed();
}
}
void TracksScreen::eventCallback(Widget* widget, const std::string& name, const int playerID)
{
// -- track selection screen
if (name == "tracks")
{
DynamicRibbonWidget* w2 = dynamic_cast<DynamicRibbonWidget*>(widget);
if (w2 != NULL)
{
const std::string selection = w2->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if(UserConfigParams::logGUI())
std::cout << "Clicked on track " << selection.c_str()
<< std::endl;
UserConfigParams::m_last_track = selection;
if (selection == "random_track")
{
RibbonWidget* tabs = this->getWidget<RibbonWidget>("trackgroups");
assert( tabs != NULL );
if (m_random_track_list.empty()) return;
/*
const std::vector<int>& curr_group = track_manager->getTracksInGroup( tabs->getSelectionIDString(0) );
RandomGenerator random;
int attempts = 0; // just to avoid an infinite loop, in case all tracks are locked...
int randomID;
do
{
randomID = random.get(curr_group.size());
attempts++;
if (attempts > 100) return;
}
while (unlock_manager->isLocked( track_manager->getTrack(curr_group[randomID])->getIdent()));
Track* clickedTrack = track_manager->getTrack( curr_group[randomID] );
*/
std::string track = m_random_track_list.front();
m_random_track_list.pop_front();
m_random_track_list.push_back(track);
Track* clickedTrack = track_manager->getTrack( track );
if (clickedTrack != NULL)
{
ITexture* screenshot = irr_driver->getTexture( clickedTrack->getScreenshotFile().c_str() );
new TrackInfoDialog(selection, clickedTrack->getIdent(),
translations->fribidize(clickedTrack->getName()),
screenshot, 0.8f, 0.7f);
}
}
else if (selection == "locked")
{
unlock_manager->playLockSound();
}
else if (selection == RibbonWidget::NO_ITEM_ID)
{
}
else
{
Track* clickedTrack = track_manager->getTrack(selection);
if (clickedTrack != NULL)
{
ITexture* screenshot = irr_driver->getTexture( clickedTrack->getScreenshotFile().c_str() );
new TrackInfoDialog(selection, clickedTrack->getIdent(),
translations->fribidize(clickedTrack->getName()),
screenshot, 0.8f, 0.7f);
}
}
}
}
else if (name == "gps")
{
DynamicRibbonWidget* gps_widget = dynamic_cast<DynamicRibbonWidget*>(widget);
if (gps_widget != NULL)
{
std::string selection = gps_widget->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (selection == "locked")
{
unlock_manager->playLockSound();
}
else
{
new GPInfoDialog( selection, 0.8f, 0.7f );
}
}
else
{
assert(false);
}
}
else if (name == "trackgroups")
{
RibbonWidget* tabs = this->getWidget<RibbonWidget>("trackgroups");
assert( tabs != NULL );
UserConfigParams::m_last_used_track_group = tabs->getSelectionIDString(0);
buildTrackList();
}
else if (name == "back")
{
StateManager::get()->escapePressed();
}
}
void MainMenuScreen::eventCallback(Widget* widget, const std::string& name,
const int playerID)
{
// 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->setNumLocalPlayers(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 == "options")
{
// The DEBUG item
FeatureUnlockedCutScene* scene =
FeatureUnlockedCutScene::getInstance();
scene->addTrophy(RaceManager::DIFFICULTY_EASY);
StateManager::get()->pushScreen(scene);
/*
static int i = 1;
i++;
if (i % 4 == 0)
{
// 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"Unlocked"
);
StateManager::get()->pushScreen(scene);
}
else if (i % 4 == 1)
{
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("crescentcrossing")
->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, 1.0, 0.75, L"You did it");
StateManager::get()->pushScreen(scene);
}
else if (i % 4 == 2)
{
GrandPrixWin* scene = GrandPrixWin::getInstance();
const std::string winners[] = { "elephpant", "nolok", "pidgin" };
StateManager::get()->pushScreen(scene);
scene->setKarts( winners );
}
else
{
GrandPrixLose* scene = GrandPrixLose::getInstance();
StateManager::get()->pushScreen(scene);
std::vector<std::string> losers;
losers.push_back("nolok");
losers.push_back("elephpant");
losers.push_back("wilber");
scene->setKarts( losers );
}
*/
}
else
#endif
if (selection == "new")
{
KartSelectionScreen* s = OfflineKartSelectionScreen::getInstance(); //FIXME : that was for tests
s->setMultiplayer(false);
s->setFromOverworld(false);
StateManager::get()->pushScreen( s );
}
else if (selection == "multiplayer")
{
KartSelectionScreen* s = OfflineKartSelectionScreen::getInstance();
s->setMultiplayer(true);
s->setFromOverworld(false);
StateManager::get()->pushScreen( s );
}
else if (selection == "options")
{
StateManager::get()->pushScreen( OptionsScreenVideo::getInstance() );
}
else if (selection == "quit")
{
StateManager::get()->popMenu();
return;
}
else if (selection == "about")
{
StateManager::get()->pushScreen(CreditsScreen::getInstance());
}
else if (selection == "help")
{
StateManager::get()->pushScreen(HelpScreen1::getInstance());
}
else if (selection == "startTutorial")
{
race_manager->setNumLocalPlayers(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->getDeviceList()->getKeyboard(0);
// Create player and associate player with keyboard
StateManager::get()->createActivePlayer(PlayerManager::get()->getCurrentPlayer(),
device, NULL);
if (kart_properties_manager->getKart(UserConfigParams::m_default_kart) == NULL)
{
fprintf(stderr, "[MainMenuScreen] WARNING: cannot find kart '%s', will revert to default\n",
UserConfigParams::m_default_kart.c_str());
UserConfigParams::m_default_kart.revertToDefaults();
}
race_manager->setLocalKartInfo(0, UserConfigParams::m_default_kart);
// ASSIGN should make sure that only input from assigned devices
// is read.
input_manager->getDeviceList()->setAssignMode(ASSIGN);
input_manager->getDeviceList()
->setSinglePlayer( StateManager::get()->getActivePlayer(0) );
StateManager::get()->enterGameState();
race_manager->setupPlayerKartInfo();
race_manager->startNew(false);
}
else if (selection == "story")
{
PlayerProfile *player = PlayerManager::get()->getCurrentPlayer();
if (player->isFirstTime())
{
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("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 "
"\"Allow STK to connect to the Internet\"."));
return;
}
if(CurrentUser::get()->getID())
StateManager::get()->pushScreen(OnlineScreen::getInstance());
else
StateManager::get()->pushScreen(LoginScreen::getInstance());
}
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 "
"\"Allow STK to connect to the Internet\"."));
return;
}
StateManager::get()->pushScreen(AddonsScreen::getInstance());
}
} // eventCallback
void ArenasScreen::eventCallback(Widget* widget, const std::string& name, const int playerID)
{
if (name == "tracks")
{
DynamicRibbonWidget* w2 = dynamic_cast<DynamicRibbonWidget*>(widget);
if (w2 == NULL) return;
const std::string selection = w2->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (UserConfigParams::logGUI())
std::cout << "Clicked on arena " << selection.c_str() << std::endl;
if (selection == "random_track")
{
RibbonWidget* tabs = this->getWidget<RibbonWidget>("trackgroups");
assert( tabs != NULL );
bool soccer_mode = race_manager->getMinorMode() == RaceManager::MINOR_MODE_SOCCER;
std::vector<int> curr_group;
if (tabs->getSelectionIDString(PLAYER_ID_GAME_MASTER) == ALL_ARENA_GROUPS_ID)
{
const std::vector<std::string>& groups = track_manager->getAllArenaGroups();
for (unsigned int i = 0; i < groups.size(); i++)
{
const std::vector<int>& tmp_group = track_manager->getArenasInGroup(groups[i], soccer_mode);
// Append to our main vector
curr_group.insert(curr_group.end(), tmp_group.begin(), tmp_group.end());
}
} // if on tab "all"
else
{
curr_group = track_manager->getArenasInGroup(
tabs->getSelectionIDString(PLAYER_ID_GAME_MASTER), soccer_mode );
}
RandomGenerator random;
const int randomID = random.get(curr_group.size());
Track* clickedTrack = track_manager->getTrack( curr_group[randomID] );
if (clickedTrack != NULL)
{
ITexture* screenshot = irr_driver->getTexture( clickedTrack->getScreenshotFile().c_str() );
new TrackInfoDialog(selection, clickedTrack->getIdent(), clickedTrack->getName(),
screenshot, 0.8f, 0.7f);
}
}
else if (selection == "locked")
{
unlock_manager->playLockSound();
}
else if (selection == RibbonWidget::NO_ITEM_ID)
{
}
else
{
Track* clickedTrack = track_manager->getTrack(selection);
if (clickedTrack != NULL)
{
ITexture* screenshot = irr_driver->getTexture( clickedTrack->getScreenshotFile().c_str() );
new TrackInfoDialog(selection, clickedTrack->getIdent(), clickedTrack->getName(),
screenshot, 0.8f, 0.7f);
} // clickedTrack != NULL
} // if random_track
}
else if (name == "trackgroups")
{
buildTrackList();
}
else if (name == "back")
{
StateManager::get()->escapePressed();
}
} // eventCallback
void ArenasScreen::buildTrackList()
{
DynamicRibbonWidget* w = this->getWidget<DynamicRibbonWidget>("tracks");
assert( w != NULL );
// Re-build track list everytime (accounts for locking changes, etc.)
w->clearItems();
RibbonWidget* tabs = this->getWidget<RibbonWidget>("trackgroups");
assert( tabs != NULL );
const std::string curr_group_name = tabs->getSelectionIDString(0);
bool soccer_mode = race_manager->getMinorMode() == RaceManager::MINOR_MODE_SOCCER;
if (curr_group_name == ALL_ARENA_GROUPS_ID)
{
const int trackAmount = track_manager->getNumberOfTracks();
for (int n=0; n<trackAmount; n++)
{
Track* curr = track_manager->getTrack(n);
if (soccer_mode)
{
if(!curr->isSoccer()) continue;
}
else
{
if(!curr->isArena()) continue;
}
if (PlayerManager::get()->getCurrentPlayer()->isLocked(curr->getIdent()))
{
w->addItem( _("Locked : solve active challenges to gain access to more!"),
"locked", curr->getScreenshotFile(), LOCKED_BADGE );
}
else
{
w->addItem( curr->getName(), curr->getIdent(), curr->getScreenshotFile(), 0,
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE );
}
}
}
else
{
const std::vector<int>& currArenas = track_manager->getArenasInGroup(curr_group_name, soccer_mode);
const int trackAmount = currArenas.size();
for (int n=0; n<trackAmount; n++)
{
Track* curr = track_manager->getTrack(currArenas[n]);
if (soccer_mode)
{
if(!curr->isSoccer()) continue;
}
else
{
if(!curr->isArena()) continue;
}
if (PlayerManager::get()->getCurrentPlayer()->isLocked(curr->getIdent()))
{
w->addItem( _("Locked : solve active challenges to gain access to more!"),
"locked", curr->getScreenshotFile(), LOCKED_BADGE );
}
else
{
w->addItem( curr->getName(), curr->getIdent(), curr->getScreenshotFile(), 0,
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE );
}
}
}
w->addItem(_("Random Arena"), "random_track", "/gui/track_random.png");
w->updateItemDisplay();
assert(w->getItems().size() > 0);
}
void TracksScreen::eventCallback(Widget* widget, const std::string& name,
const int playerID)
{
// -- track selection screen
if (name == "tracks")
{
DynamicRibbonWidget* w2 = dynamic_cast<DynamicRibbonWidget*>(widget);
if(!w2) return;
const std::string &selection =
w2->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (UserConfigParams::logGUI())
{
Log::info("TracksScreen", "Clicked on track '%s'.",
selection.c_str());
}
UserConfigParams::m_last_track = selection;
if (selection == "random_track")
{
RibbonWidget* tabs = getWidget<RibbonWidget>("trackgroups");
assert(tabs);
if (m_random_track_list.empty()) return;
std::string track = m_random_track_list.front();
m_random_track_list.pop_front();
m_random_track_list.push_back(track);
Track* clicked_track = track_manager->getTrack(track);
if (clicked_track)
{
ITexture* screenshot =
irr_driver->getTexture(clicked_track->getScreenshotFile(),
"While loading screenshot for track '%s':",
clicked_track->getFilename() );
new TrackInfoDialog(selection, clicked_track->getIdent(),
translations->fribidize(clicked_track->getName()),
screenshot, 0.8f, 0.7f);
} // if clicked_track
} // selection=="random_track"
else if (selection == "locked")
{
unlock_manager->playLockSound();
}
else if (selection == RibbonWidget::NO_ITEM_ID)
{
}
else
{
Track* clicked_track = track_manager->getTrack(selection);
if (clicked_track)
{
ITexture* screenshot =
irr_driver->getTexture(clicked_track->getScreenshotFile(),
"While loading screenshot for track '%s'",
clicked_track->getFilename());
new TrackInfoDialog(selection, clicked_track->getIdent(),
translations->fribidize(clicked_track->getName()),
screenshot, 0.8f, 0.7f);
}
}
} // name=="tracks"
else if (name == "gps")
{
DynamicRibbonWidget* gps_widget = dynamic_cast<DynamicRibbonWidget*>(widget);
const std::string &selection =
gps_widget->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (selection == "locked")
{
unlock_manager->playLockSound();
}
else
{
if (selection == "Random Grand Prix")
new RandomGPInfoDialog();
else
new GPInfoDialog(selection);
}
}
else if (name == "trackgroups")
{
RibbonWidget* tabs = this->getWidget<RibbonWidget>("trackgroups");
UserConfigParams::m_last_used_track_group = tabs->getSelectionIDString(0);
buildTrackList();
}
else if (name == "back")
{
StateManager::get()->escapePressed();
}
} // eventCallback
void KartSelectionScreen::allPlayersDone()
{
input_manager->setMasterPlayerOnly(true);
RibbonWidget* tabs = getWidget<RibbonWidget>("kartgroups");
assert(tabs != NULL);
std::string selected_kart_group =
tabs->getSelectionIDString(PLAYER_ID_GAME_MASTER);
UserConfigParams::m_last_used_kart_group = selected_kart_group;
DynamicRibbonWidget* w = getWidget<DynamicRibbonWidget>("karts");
assert( w != NULL );
const PtrVector< StateManager::ActivePlayer, HOLD >& players =
StateManager::get()->getActivePlayers();
// ---- Print selection (for debugging purposes)
if(UserConfigParams::logGUI())
{
Log::info("KartSelectionScreen", "players : %d",players.size());
for (unsigned int n=0; n<players.size(); n++)
{
Log::info("KartSelectionScreen", " Player %u is %s on %s",n,
core::stringc(
players[n].getConstProfile()->getName().c_str()).c_str(),
players[n].getDevice()->getName().c_str());
}
}
for (unsigned int n=0; n<players.size(); n++)
{
StateManager::get()->getActivePlayer(n)->getProfile()
->incrementUseFrequency();
}
// ---- Give player info to race manager
race_manager->setNumPlayers(players.size());
// ---- Manage 'random kart' selection(s)
RandomGenerator random;
std::vector<ItemDescription> items = w->getItems();
// remove the 'random' item itself
const int item_count = (int) items.size();
for (int n=0; n<item_count; n++)
{
if (items[n].m_code_name == RANDOM_KART_ID)
{
items[n].m_code_name = ID_DONT_USE;
break;
}
}
// pick random karts
const int kart_count = m_kart_widgets.size();
for (int n = 0; n < kart_count; n++)
{
std::string selected_kart = m_kart_widgets[n].m_kartInternalName;
if (selected_kart == RANDOM_KART_ID)
{
// don't select an already selected kart
int random_id;
// to prevent infinite loop in case they are all locked
int count = 0;
bool done = false;
do
{
random_id = random.get(item_count);
// valid kart if it can bt used, and is either not locked,
// or it's a multiplayer race.
if (items[random_id].m_code_name != ID_DONT_USE &&
(!StringUtils::startsWith(items[random_id].m_code_name, ID_LOCKED)
|| m_multiplayer) )
{
selected_kart = items[random_id].m_code_name;
done = true;
}
items[random_id].m_code_name = ID_DONT_USE;
count++;
if (count > 100) return;
}
while (!done);
}
else
{
// mark the item as taken
for (int i=0; i<item_count; i++)
{
if (items[i].m_code_name ==
m_kart_widgets[n].m_kartInternalName)
{
items[i].m_code_name = ID_DONT_USE;
break;
}
}
}
race_manager->setPlayerKart(n, selected_kart);
// Set per player difficulty if needed
if (m_multiplayer && UserConfigParams::m_per_player_difficulty &&
m_kart_widgets[n].isHandicapped())
race_manager->setPlayerDifficulty(n, PLAYER_DIFFICULTY_HANDICAP);
}
// ---- Switch to assign mode
input_manager->getDeviceManager()->setAssignMode(ASSIGN);
StateManager::ActivePlayer *ap = m_multiplayer
? NULL
: StateManager::get()->getActivePlayer(0);
input_manager->getDeviceManager()->setSinglePlayer(ap);
// ---- Go to next screen or return to overworld
if (m_from_overworld || m_go_to_overworld_next)
{
m_from_overworld = false; // valid once
m_go_to_overworld_next = false;
OverWorld::enterOverWorld();
}
else
{
RaceSetupScreen::getInstance()->push();
}
} // allPlayersDone
void ArenasScreen::buildTrackList()
{
DynamicRibbonWidget* w = this->getWidget<DynamicRibbonWidget>("tracks");
assert( w != NULL );
// Re-build track list everytime (accounts for locking changes, etc.)
w->clearItems();
RibbonWidget* tabs = this->getWidget<RibbonWidget>("trackgroups");
assert( tabs != NULL );
const std::string curr_group_name = tabs->getSelectionIDString(0);
bool soccer_mode = race_manager->getMinorMode() == RaceManager::MINOR_MODE_SOCCER;
bool arenas_have_navmesh = false;
if (curr_group_name == ALL_ARENA_GROUPS_ID)
{
const int track_amount = (int)track_manager->getNumberOfTracks();
for (int n=0; n<track_amount; n++)
{
Track* curr = track_manager->getTrack(n);
if (soccer_mode)
{
if(curr->isSoccer() && curr->hasNavMesh() && !arenas_have_navmesh)
arenas_have_navmesh = true;
if(!curr->isSoccer() ||
(!(curr->hasNavMesh() ||
race_manager->getNumLocalPlayers() > 1 ||
UserConfigParams::m_artist_debug_mode)))
{
if (curr->isSoccer())
m_unsupported_arena.insert(n);
continue;
}
}
else
{
if(curr->isArena() && curr->hasNavMesh() && !arenas_have_navmesh)
arenas_have_navmesh = true;
if(!curr->isArena() ||
(!(curr->hasNavMesh() ||
race_manager->getNumLocalPlayers() > 1 ||
UserConfigParams::m_artist_debug_mode)))
{
if (curr->isArena())
m_unsupported_arena.insert(n);
continue;
}
}
if (PlayerManager::getCurrentPlayer()->isLocked(curr->getIdent()))
{
w->addItem( _("Locked : solve active challenges to gain access to more!"),
"locked", curr->getScreenshotFile(), LOCKED_BADGE );
}
else
{
w->addItem( translations->fribidize(curr->getName()), curr->getIdent(), curr->getScreenshotFile(), 0,
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE );
}
}
}
else
{
const std::vector<int>& currArenas = track_manager->getArenasInGroup(curr_group_name, soccer_mode);
const int track_amount = (int)currArenas.size();
for (int n=0; n<track_amount; n++)
{
Track* curr = track_manager->getTrack(currArenas[n]);
if (soccer_mode)
{
if(curr->isSoccer() && curr->hasNavMesh() && !arenas_have_navmesh)
arenas_have_navmesh = true;
if(!curr->isSoccer() ||
(!(curr->hasNavMesh() ||
race_manager->getNumLocalPlayers() > 1 ||
UserConfigParams::m_artist_debug_mode)))
{
if (curr->isSoccer())
m_unsupported_arena.insert(currArenas[n]);
continue;
}
}
else
{
if(curr->isArena() && curr->hasNavMesh() && !arenas_have_navmesh)
arenas_have_navmesh = true;
if(!curr->isArena() ||
(!(curr->hasNavMesh() ||
race_manager->getNumLocalPlayers() > 1 ||
UserConfigParams::m_artist_debug_mode)))
{
if (curr->isArena())
m_unsupported_arena.insert(currArenas[n]);
continue;
}
}
if (PlayerManager::getCurrentPlayer()->isLocked(curr->getIdent()))
{
w->addItem( _("Locked : solve active challenges to gain access to more!"),
"locked", curr->getScreenshotFile(), LOCKED_BADGE );
}
else
{
w->addItem( translations->fribidize(curr->getName()), curr->getIdent(), curr->getScreenshotFile(), 0,
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE );
}
}
}
if (arenas_have_navmesh || race_manager->getNumLocalPlayers() > 1 ||
UserConfigParams::m_artist_debug_mode)
w->addItem(_("Random Arena"), "random_track", "/gui/icons/track_random.png");
w->updateItemDisplay();
if (m_unsupported_arena.size() > 0)
w->setText( _P("%d arena unavailable in single player.",
"%d arenas unavailable in single player.",
(int)m_unsupported_arena.size()) );
}
void KartSelectionScreen::setKartsFromCurrentGroup()
{
RibbonWidget* tabs = getWidget<RibbonWidget>("kartgroups");
assert(tabs != NULL);
std::string selected_kart_group =
tabs->getSelectionIDString(PLAYER_ID_GAME_MASTER);
UserConfigParams::m_last_used_kart_group = selected_kart_group;
// This can happen if addons are removed so that also the previously
// selected kart group is removed. In this case, select the
// 'standard' group
if (selected_kart_group != ALL_KART_GROUPS_ID &&
!kart_properties_manager->getKartsInGroup(selected_kart_group).size())
{
selected_kart_group = DEFAULT_GROUP_NAME;
}
DynamicRibbonWidget* w = getWidget<DynamicRibbonWidget>("karts");
w->clearItems();
int usable_kart_count = 0;
PtrVector<const KartProperties, REF> karts;
for(unsigned int i=0; i<kart_properties_manager->getNumberOfKarts(); i++)
{
const KartProperties* prop = kart_properties_manager->getKartById(i);
// Ignore karts that are not in the selected group
if(selected_kart_group != ALL_KART_GROUPS_ID &&
!prop->isInGroup(selected_kart_group))
continue;
karts.push_back(prop);
}
karts.insertionSort();
for(unsigned int i=0; i<karts.size(); i++)
{
const KartProperties* prop = karts.get(i);
if (PlayerManager::getCurrentPlayer()->isLocked(prop->getIdent()) &&
!m_multiplayer)
{
w->addItem(_("Locked : solve active challenges to gain access to more!"),
ID_LOCKED + prop->getIdent(),
prop->getAbsoluteIconFile(), LOCKED_BADGE,
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE);
}
else
{
w->addItem(translations->fribidize(prop->getName()),
prop->getIdent(),
prop->getAbsoluteIconFile(), 0,
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE);
usable_kart_count++;
}
}
// add random
if (usable_kart_count > 1)
{
w->addItem(_("Random Kart"), RANDOM_KART_ID, "/gui/random_kart.png");
}
w->updateItemDisplay();
}
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
// ----------------------------------------------------------------------------
// Return true if event was handled successfully
bool KartSelectionScreen::joinPlayer(InputDevice* device)
{
bool first_player = m_kart_widgets.size() == 0;
if (UserConfigParams::logGUI())
Log::info("KartSelectionScreen", "joinPlayer() invoked");
if (!m_multiplayer && !first_player) return false;
assert (m_dispatcher != NULL);
DynamicRibbonWidget* w = getWidget<DynamicRibbonWidget>("karts");
if (w == NULL)
{
Log::error("KartSelectionScreen", "joinPlayer(): Called outside of "
"kart selection screen.");
return false;
}
else if (device == NULL)
{
Log::error("KartSelectionScreen", "joinPlayer(): Received null "
"device pointer");
return false;
}
if (StateManager::get()->activePlayerCount() >= MAX_PLAYER_COUNT)
{
Log::error("KartSelectionScreen", "Maximum number of players "
"reached");
SFXManager::get()->quickSound( "anvil" );
return false;
}
// ---- Create new active player
PlayerProfile* profile_to_use = PlayerManager::getCurrentPlayer();
// Make sure enough guest character exists. At this stage this player has
// not been added, so the number of guests requested for the first player
// is 0 --> forcing at least one real player.
PlayerManager::get()->createGuestPlayers(
StateManager::get()->activePlayerCount());
if (!first_player)
{
// Give each player a different start profile
const int num_active_players = StateManager::get()->activePlayerCount();
profile_to_use = PlayerManager::get()->getPlayer(num_active_players);
removeMultiplayerMessage();
}
const int new_player_id =
StateManager::get()->createActivePlayer(profile_to_use, device);
StateManager::ActivePlayer* aplayer =
StateManager::get()->getActivePlayer(new_player_id);
RibbonWidget* tabs = getWidget<RibbonWidget>("kartgroups");
assert(tabs != NULL);
std::string selected_kart_group =
tabs->getSelectionIDString(PLAYER_ID_GAME_MASTER);
// ---- Get available area for karts
// make a copy of the area, ands move it to be outside the screen
Widget* kartsAreaWidget = getWidget("playerskarts");
// start at the rightmost of the screen
const int shift = irr_driver->getFrameSize().Width;
core::recti kartsArea(kartsAreaWidget->m_x + shift,
kartsAreaWidget->m_y,
kartsAreaWidget->m_x + shift + kartsAreaWidget->m_w,
kartsAreaWidget->m_y + kartsAreaWidget->m_h);
// ---- Create player/kart widget
PlayerKartWidget* newPlayerWidget =
new PlayerKartWidget(this, aplayer, NULL, kartsArea, m_kart_widgets.size(),
selected_kart_group);
manualAddWidget(newPlayerWidget);
m_kart_widgets.push_back(newPlayerWidget);
newPlayerWidget->add();
// ---- Divide screen space among all karts
const int amount = m_kart_widgets.size();
Widget* fullarea = getWidget("playerskarts");
// in this special case, leave room for a message on the right
if (m_multiplayer && first_player)
{
addMultiplayerMessage();
const int splitWidth = fullarea->m_w / 2;
m_kart_widgets[0].move( fullarea->m_x, fullarea->m_y, splitWidth,
fullarea->m_h );
}
else
{
const int splitWidth = fullarea->m_w / amount;
for (int n=0; n<amount; n++)
{
m_kart_widgets[n].move( fullarea->m_x + splitWidth * n,
fullarea->m_y, splitWidth, fullarea->m_h);
}
}
// select something (anything) in the ribbon; by default, only the
// game master has something selected. Thus, when a new player joins,
// we need to select something for them
w->setSelection(new_player_id, new_player_id, true);
newPlayerWidget->m_player_ident_spinner
->setFocusForPlayer(new_player_id);
if (!m_multiplayer)
{
input_manager->getDeviceManager()->setSinglePlayer(StateManager::get()
->getActivePlayer(0));
}
return true;
} // joinPlayer
void TracksScreen::eventCallback(Widget* widget, const std::string& name,
const int playerID)
{
// -- track selection screen
if (name == "tracks")
{
DynamicRibbonWidget* w2 = dynamic_cast<DynamicRibbonWidget*>(widget);
if(!w2) return;
const std::string &selection =
w2->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (UserConfigParams::logGUI())
{
Log::info("TracksScreen", "Clicked on track '%s'.",
selection.c_str());
}
UserConfigParams::m_last_track = selection;
if (selection == "random_track")
{
if (m_random_track_list.empty()) return;
std::string track = m_random_track_list.front();
m_random_track_list.pop_front();
m_random_track_list.push_back(track);
Track* clicked_track = track_manager->getTrack(track);
if (clicked_track)
{
TrackInfoScreen::getInstance()->setTrack(clicked_track);
TrackInfoScreen::getInstance()->push();
} // if clicked_track
} // selection=="random_track"
else if (selection == "locked")
{
unlock_manager->playLockSound();
}
else if (selection == RibbonWidget::NO_ITEM_ID)
{
}
else
{
Track* clicked_track = track_manager->getTrack(selection);
if (clicked_track)
{
TrackInfoScreen::getInstance()->setTrack(clicked_track);
TrackInfoScreen::getInstance()->push();
}
}
} // name=="tracks"
else if (name == "gps")
{
DynamicRibbonWidget* gps_widget = dynamic_cast<DynamicRibbonWidget*>(widget);
const std::string &selection =
gps_widget->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (selection == "locked")
{
unlock_manager->playLockSound();
}
else
{
GPInfoScreen *gpis = GPInfoScreen::getInstance();
gpis->setGP( selection == "Random Grand Prix" ? "random"
: selection);
gpis->push();
}
}
else if (name == "trackgroups")
{
RibbonWidget* tabs = this->getWidget<RibbonWidget>("trackgroups");
UserConfigParams::m_last_used_track_group = tabs->getSelectionIDString(0);
buildTrackList();
}
else if (name == "back")
{
StateManager::get()->escapePressed();
}
} // eventCallback
// -----------------------------------------------------------------------------
void GrandPrixEditorScreen::eventCallback(Widget* widget, const std::string& name, const int playerID)
{
DynamicRibbonWidget* gplist_widget = getWidget<DynamicRibbonWidget>("gplist");
assert (gplist_widget != NULL);
std::string selected = gplist_widget->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (!selected.empty())
setSelection (grand_prix_manager->getGrandPrix(selected));
if (name == "menu")
{
RibbonWidget* menu = getWidget<RibbonWidget>("menu");
assert(menu != NULL);
m_action = menu->getSelectionIDString(PLAYER_ID_GAME_MASTER);
if (m_action == "new" || m_action == "copy")
{
new EnterGPNameDialog(this, 0.5f, 0.4f);
}
else if (m_action == "edit")
{
if (m_selection->isEditable())
{
showEditScreen(m_selection);
}
else
{
new MessageDialog(
_("You can't edit the '%s' grand prix.\nYou might want to copy it first",
m_selection->getName().c_str()),
MessageDialog::MESSAGE_DIALOG_OK, NULL, false);
}
}
else if (m_action == "remove")
{
if (m_selection->isEditable())
{
new MessageDialog(
_("Are you sure you want to remove '%s'?", m_selection->getName().c_str()),
MessageDialog::MESSAGE_DIALOG_CONFIRM,
this, false);
}
else
{
new MessageDialog(
_("You can't remove '%s'.", m_selection->getName().c_str()),
MessageDialog::MESSAGE_DIALOG_OK, NULL, false);
}
}
else if (m_action == "rename")
{
if (m_selection->isEditable())
{
new EnterGPNameDialog(this, 0.5f, 0.4f);
}
else
{
new MessageDialog(
_("You can't rename '%s'.", m_selection->getName().c_str()),
MessageDialog::MESSAGE_DIALOG_OK, NULL, false);
}
}
}
else if (name == "back")
{
StateManager::get()->escapePressed();
}
}
