void NetworkKartSelectionScreen::playerConfirm(const int playerID)
{
DynamicRibbonWidget* w = getWidget<DynamicRibbonWidget>("karts");
assert(w != NULL);
const std::string selection = w->getSelectionIDString(playerID);
if (StringUtils::startsWith(selection, ID_LOCKED))
{
unlock_manager->playLockSound();
return;
}
if (playerID == PLAYER_ID_GAME_MASTER)
{
UserConfigParams::m_default_kart = selection;
}
if (m_kart_widgets[playerID].getKartInternalName().size() == 0)
{
SFXManager::get()->quickSound( "anvil" );
return;
}
if(playerID == PLAYER_ID_GAME_MASTER) // self
{
ClientLobbyRoomProtocol* protocol = static_cast<ClientLobbyRoomProtocol*>(
ProtocolManager::getInstance()->getProtocol(PROTOCOL_LOBBY_ROOM));
protocol->requestKartSelection(selection);
}
}
void ArenasScreen::setFocusOnTrack(const std::string& trackName)
{
DynamicRibbonWidget* w = this->getWidget<DynamicRibbonWidget>("tracks");
assert( w != NULL );
w->setSelection(trackName, PLAYER_ID_GAME_MASTER, true);
} // setFOxuOnTrack
void ArenasScreen::init()
{
Screen::init();
buildTrackList();
DynamicRibbonWidget* w = this->getWidget<DynamicRibbonWidget>("tracks");
// select something by default for the game master
assert( w != NULL );
w->setSelection(w->getItems()[0].m_code_name, PLAYER_ID_GAME_MASTER, true);
} // init
void KartSelectionScreen::renumberKarts()
{
DynamicRibbonWidget* w = getWidget<DynamicRibbonWidget>("karts");
assert( w != NULL );
Widget* fullarea = getWidget("playerskarts");
int splitWidth = fullarea->m_w / m_kart_widgets.size();
if (m_kart_widgets.size() == 1)
splitWidth /= 2;
for (unsigned int n=0; n < m_kart_widgets.size(); n++)
{
m_kart_widgets[n].setPlayerID(n);
m_kart_widgets[n].move( fullarea->m_x + splitWidth*n, fullarea->m_y,
splitWidth, fullarea->m_h );
}
w->updateItemDisplay();
} // renumberKarts
// -----------------------------------------------------------------------------
void EditTrackScreen::selectTrack(const std::string& id)
{
DynamicRibbonWidget* tracks = getWidget<DynamicRibbonWidget>("tracks");
assert(tracks != NULL);
LabelWidget* selected_track = getWidget<LabelWidget>("selected_track");
assert(selected_track != NULL);
SpinnerWidget* laps = getWidget<SpinnerWidget>("laps");
assert(laps != NULL);
LabelWidget* label_reverse = getWidget<LabelWidget>("reverse_label");
assert(label_reverse != NULL);
CheckBoxWidget* reverse = getWidget<CheckBoxWidget>("reverse");
assert(reverse != NULL);
ButtonWidget* ok_button = getWidget<ButtonWidget>("ok");
assert(ok_button != NULL);
m_track = track_manager->getTrack(id);
if (m_track != NULL)
{
tracks->setSelection(m_track->getIdent(), PLAYER_ID_GAME_MASTER, true);
selected_track->setText(m_track->getName(), true);
laps->setValue(m_laps);
reverse->setVisible(m_track->reverseAvailable());
label_reverse->setVisible(m_track->reverseAvailable());
ok_button->setActivated();
}
else
{
tracks->setSelection("", PLAYER_ID_GAME_MASTER, true);
selected_track->setText(_("Select a track"), true);
// We can't set a better default for number of laps. On the other
// hand, if a track is selected, the number of laps will be updated.
laps->setValue(3);
reverse->setVisible(true);
reverse->setState(false);
ok_button->setDeactivated();
}
}
void KartSelectionScreen::beforeAddingWidget()
{
// Dynamically add tabs
RibbonWidget* tabs = getWidget<RibbonWidget>("kartgroups");
assert( tabs != NULL );
m_last_widget = tabs;
tabs->clearAllChildren();
const std::vector<std::string>& groups =
kart_properties_manager->getAllGroups();
const int group_amount = (int)groups.size();
// add all group first
if (group_amount > 1)
{
//I18N: name of the tab that will show tracks from all groups
tabs->addTextChild( _("All") , ALL_KART_GROUPS_ID);
}
// Make group names being picked up by gettext
#define FOR_GETTEXT_ONLY(x)
//I18N: kart group name
FOR_GETTEXT_ONLY( _("standard") )
//I18N: kart group name
FOR_GETTEXT_ONLY( _("Add-Ons") )
// add others after
for (int n=0; n<group_amount; n++)
{
// try to translate group names
tabs->addTextChild( _(groups[n].c_str()) , groups[n]);
} // for n<group_amount
DynamicRibbonWidget* w = getWidget<DynamicRibbonWidget>("karts");
assert( w != NULL );
w->setItemCountHint( kart_properties_manager->getNumberOfKarts() );
} // beforeAddingWidget
// -----------------------------------------------------------------------------
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 KartHoverListener::onSelectionChanged(DynamicRibbonWidget* theWidget,
const std::string& selectionID,
const irr::core::stringw& selectionText,
const int player_id)
{
assert(m_magic_number == 0xCAFEC001);
// Check if this player has a kart
if (m_parent->m_kart_widgets.size() <= unsigned(player_id))
{
GUIEngine::focusNothingForPlayer(player_id);
return;
}
// Don't allow changing the selection after confirming it
if (m_parent->m_kart_widgets[player_id].isReady())
{
// discard events sent when putting back to the right kart
if (selectionID ==
m_parent->m_kart_widgets[player_id].m_kartInternalName) return;
DynamicRibbonWidget* w =
m_parent->getWidget<DynamicRibbonWidget>("karts");
assert(w != NULL);
w->setSelection(m_parent->m_kart_widgets[player_id]
.m_kartInternalName, player_id, true);
return;
}
if (m_parent->m_kart_widgets[player_id].getKartInternalName() == selectionID)
return; // already selected
m_parent->updateKartWidgetModel(player_id, selectionID, selectionText);
m_parent->m_kart_widgets[player_id].setKartInternalName(selectionID);
m_parent->updateKartStats(player_id, selectionID);
m_parent->validateKartChoices();
} // onSelectionChanged
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 OptionsScreenVideo::init()
{
Screen::init();
RibbonWidget* ribbon = getWidget<RibbonWidget>("options_choice");
if (ribbon != NULL) ribbon->select( "tab_video", PLAYER_ID_GAME_MASTER );
ribbon->getRibbonChildren()[1].setTooltip( _("Audio") );
ribbon->getRibbonChildren()[2].setTooltip( _("User Interface") );
ribbon->getRibbonChildren()[3].setTooltip( _("Players") );
ribbon->getRibbonChildren()[4].setTooltip( _("Controls") );
GUIEngine::ButtonWidget* applyBtn =
getWidget<GUIEngine::ButtonWidget>("apply_resolution");
assert( applyBtn != NULL );
GUIEngine::SpinnerWidget* gfx =
getWidget<GUIEngine::SpinnerWidget>("gfx_level");
assert( gfx != NULL );
GUIEngine::CheckBoxWidget* vsync =
getWidget<GUIEngine::CheckBoxWidget>("vsync");
assert( vsync != NULL );
vsync->setState( UserConfigParams::m_vsync );
// ---- video modes
DynamicRibbonWidget* res = getWidget<DynamicRibbonWidget>("resolutions");
assert( res != NULL );
CheckBoxWidget* full = getWidget<CheckBoxWidget>("fullscreen");
assert( full != NULL );
full->setState( UserConfigParams::m_fullscreen );
CheckBoxWidget* rememberWinpos = getWidget<CheckBoxWidget>("rememberWinpos");
rememberWinpos->setState(UserConfigParams::m_remember_window_location);
if (UserConfigParams::m_fullscreen) rememberWinpos->setDeactivated();
else rememberWinpos->setActivated();
// --- get resolution list from irrlicht the first time
if (!m_inited)
{
res->clearItems();
const std::vector<IrrDriver::VideoMode>& modes =
irr_driver->getVideoModes();
const int amount = (int)modes.size();
bool found_config_res = false;
// for some odd reason, irrlicht sometimes fails to report the good
// old standard resolutions
// those are always useful for windowed mode
// allow 800x600 only for debug mode
#ifdef DEBUG
bool found_800_600 = false;
#endif
bool found_1024_640 = false;
bool found_1024_768 = false;
for (int n=0; n<amount; n++)
{
const int w = modes[n].getWidth();
const int h = modes[n].getHeight();
const float ratio = (float)w / h;
if (w == UserConfigParams::m_width &&
h == UserConfigParams::m_height)
{
found_config_res = true;
}
if (w == 800 && h == 600)
{
#ifdef DEBUG
found_800_600 = true;
#else
continue;
#endif
}
else if (w == 1024 && h == 640)
{
found_1024_640 = true;
}
else if (w == 1024 && h == 768)
{
found_1024_768 = true;
}
char name[32];
sprintf( name, "%ix%i", w, h );
core::stringw label;
label += w;
label += L"\u00D7";
label += h;
#define ABOUT_EQUAL(a , b) (fabsf( a - b ) < 0.01)
if (ABOUT_EQUAL( ratio, (5.0f/4.0f) ))
res->addItem(label, name, "/gui/screen54.png");
else if (ABOUT_EQUAL( ratio, (4.0f/3.0f) ))
res->addItem(label, name, "/gui/screen43.png");
else if (ABOUT_EQUAL( ratio, (16.0f/10.0f)))
res->addItem(label, name, "/gui/screen1610.png");
else if (ABOUT_EQUAL( ratio, (5.0f/3.0f) ))
res->addItem(label, name, "/gui/screen53.png");
else if (ABOUT_EQUAL( ratio, (3.0f/2.0f) ))
res->addItem(label, name, "/gui/screen32.png");
else if (ABOUT_EQUAL( ratio, (16.0f/9.0f) ))
res->addItem(label, name, "/gui/screen169.png");
else
res->addItem(label, name, "/gui/screen_other.png");
#undef ABOUT_EQUAL
} // next resolution
if (!found_config_res)
{
const int w = UserConfigParams::m_width;
const int h = UserConfigParams::m_height;
const float ratio = (float)w / h;
if (w == 800 && h == 600)
{
#ifdef DEBUG
found_800_600 = true;
#endif
}
else if (w == 1024 && h == 640)
{
found_1024_640 = true;
}
else if (w == 1024 && h == 768)
{
found_1024_768 = true;
}
char name[32];
sprintf( name, "%ix%i", w, h );
core::stringw label;
label += w;
label += L"\u00D7";
label += h;
#define ABOUT_EQUAL(a , b) (fabsf( a - b ) < 0.01)
if (ABOUT_EQUAL( ratio, (5.0f/4.0f) ))
res->addItem(label, name, "/gui/screen54.png");
else if (ABOUT_EQUAL( ratio, (4.0f/3.0f) ))
res->addItem(label, name, "/gui/screen43.png");
else if (ABOUT_EQUAL( ratio, (16.0f/10.0f) ))
res->addItem(label, name, "/gui/screen1610.png");
else if (ABOUT_EQUAL( ratio, (5.0f/3.0f) ))
res->addItem(label, name, "/gui/screen53.png");
else if (ABOUT_EQUAL( ratio, (3.0f/2.0f) ))
res->addItem(label, name, "/gui/screen32.png");
else if (ABOUT_EQUAL( ratio, (16.0f/9.0f) ))
res->addItem(label, name, "/gui/screen169.png");
else
res->addItem(label, name, "/gui/screen_other.png");
#undef ABOUT_EQUAL
}
#ifdef DEBUG
if (!found_800_600)
{
res->addItem(L"800\u00D7600", "800x600", "/gui/screen43.png");
}
#endif
if (!found_1024_640)
{
res->addItem(L"1024\u00D7640", "1024x640", "/gui/screen1610.png");
}
if (!found_1024_768)
{
res->addItem(L"1024\u00D7768", "1024x768", "/gui/screen43.png");
}
} // end if not inited
res->updateItemDisplay();
// ---- select current resolution every time
char searching_for[32];
snprintf(searching_for, 32, "%ix%i", (int)UserConfigParams::m_width,
(int)UserConfigParams::m_height);
if (!res->setSelection(searching_for, PLAYER_ID_GAME_MASTER,
false /* focus it */, true /* even if deactivated*/))
{
Log::error("OptionsScreenVideo", "Cannot find resolution %s", searching_for);
}
// --- set gfx settings values
updateGfxSlider();
// ---- forbid changing resolution or animation settings from in-game
// (we need to disable them last because some items can't be edited when
// disabled)
if (StateManager::get()->getGameState() == GUIEngine::INGAME_MENU)
{
res->setDeactivated();
full->setDeactivated();
applyBtn->setDeactivated();
gfx->setDeactivated();
getWidget<ButtonWidget>("custom")->setDeactivated();
}
else
{
// Enable back widgets if they were visited in-game previously
res->setActivated();
full->setActivated();
applyBtn->setActivated();
gfx->setActivated();
getWidget<ButtonWidget>("custom")->setActivated();
}
} // init
/**
* 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
bool KartSelectionScreen::playerQuit(StateManager::ActivePlayer* player)
{
int player_id = -1;
DynamicRibbonWidget* w = getWidget<DynamicRibbonWidget>("karts");
if (w == NULL)
{
Log::error("KartSelectionScreen", "playerQuit() called "
"outside of kart selection screen, "
"or the XML file for this screen was changed without "
"adapting the code accordingly");
return false;
}
// If last player quits, return to main menu
if (m_kart_widgets.size() <= 1)
{
StateManager::get()->escapePressed();
return true;
}
std::map<PlayerKartWidget*, std::string> selections;
// Find the player ID associated to this player
for (unsigned int n=0; n<m_kart_widgets.size(); n++)
{
if (m_kart_widgets[n].getAssociatedPlayer() == player)
{
// Check that this player has not already confirmed,
// then they can't back out
if (m_kart_widgets[n].isReady())
{
SFXManager::get()->quickSound( "anvil" );
return true;
}
player_id = n;
}
else
{
selections[m_kart_widgets.get(n)] =
m_kart_widgets[n].getKartInternalName();
}
}
if (player_id == -1)
{
Log::warn("KartSelectionScreen", "playerQuit cannot find "
"passed player");
return false;
}
if(UserConfigParams::logGUI())
Log::info("KartSelectionScreen", "playerQuit(%d)", player_id);
// Just a cheap way to check if there is any discrepancy
// between m_kart_widgets and the active player array
assert( m_kart_widgets.size() == StateManager::get()->activePlayerCount());
// unset selection of this player
GUIEngine::focusNothingForPlayer(player_id);
// delete a previous removed widget that didn't have time to fully shrink
// yet.
// TODO: handle multiple shrinking widgets gracefully?
if (m_removed_widget != NULL)
{
manualRemoveWidget(m_removed_widget);
delete m_removed_widget;
m_removed_widget = NULL;
}
// keep the removed kart a while, for the 'disappear' animation
// to take place
m_removed_widget = m_kart_widgets.remove(player_id);
// Tell the StateManager to remove this player
StateManager::get()->removeActivePlayer(player_id);
addMultiplayerMessage();
// Karts count changed, maybe order too, so renumber them.
renumberKarts();
// Tell the removed widget to perform the shrinking animation (which will
// be updated in onUpdate, and will stop when the widget has disappeared)
Widget* fullarea = getWidget("playerskarts");
m_removed_widget->move(m_removed_widget->m_x + m_removed_widget->m_w/2,
fullarea->m_y + fullarea->m_h, 0, 0);
// update selections
const unsigned int amount = m_kart_widgets.size();
for (unsigned int n=0; n<amount; n++)
{
const std::string& selectedKart = selections[m_kart_widgets.get(n)];
if (selectedKart.size() > 0)
{
//std::cout << m_kart_widgets[n].getAssociatedPlayer()
// ->getProfile()->getName() << " selected "
// << selectedKart.c_str() << "\n";
const bool success = w->setSelection(selectedKart, n, true);
if (!success)
{
Log::warn("KartSelectionScreen", "Failed to select kart %s"
" for player %u, what's going on??", selectedKart.c_str(),n);
}
}
}
// check if all players are ready
bool allPlayersReady = true;
for (unsigned int n=0; n<amount; n++)
{
if (!m_kart_widgets[n].isReady())
{
allPlayersReady = false;
break;
}
}
if (allPlayersReady && (!m_multiplayer || amount > 1)) allPlayersDone();
return true;
} // playerQuit
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 OptionsScreenVideo::init()
{
Screen::init();
RibbonWidget* ribbon = getWidget<RibbonWidget>("options_choice");
assert(ribbon != NULL);
ribbon->select( "tab_video", PLAYER_ID_GAME_MASTER );
ribbon->getRibbonChildren()[1].setTooltip( _("Audio") );
ribbon->getRibbonChildren()[2].setTooltip( _("User Interface") );
ribbon->getRibbonChildren()[3].setTooltip( _("Players") );
ribbon->getRibbonChildren()[4].setTooltip( _("Controls") );
GUIEngine::ButtonWidget* applyBtn =
getWidget<GUIEngine::ButtonWidget>("apply_resolution");
assert( applyBtn != NULL );
GUIEngine::SpinnerWidget* gfx =
getWidget<GUIEngine::SpinnerWidget>("gfx_level");
assert( gfx != NULL );
GUIEngine::CheckBoxWidget* vsync =
getWidget<GUIEngine::CheckBoxWidget>("vsync");
assert( vsync != NULL );
vsync->setState( UserConfigParams::m_vsync );
// ---- video modes
DynamicRibbonWidget* res = getWidget<DynamicRibbonWidget>("resolutions");
assert( res != NULL );
CheckBoxWidget* full = getWidget<CheckBoxWidget>("fullscreen");
assert( full != NULL );
full->setState( UserConfigParams::m_fullscreen );
CheckBoxWidget* rememberWinpos = getWidget<CheckBoxWidget>("rememberWinpos");
rememberWinpos->setState(UserConfigParams::m_remember_window_location);
rememberWinpos->setActive(UserConfigParams::m_fullscreen);
// --- get resolution list from irrlicht the first time
if (!m_inited)
{
res->clearItems();
const std::vector<IrrDriver::VideoMode>& modes =
irr_driver->getVideoModes();
const int amount = (int)modes.size();
std::vector<Resolution> resolutions;
Resolution r;
bool found_config_res = false;
// for some odd reason, irrlicht sometimes fails to report the good
// old standard resolutions
// those are always useful for windowed mode
bool found_1024_768 = false;
for (int n=0; n<amount; n++)
{
r.width = modes[n].getWidth();
r.height = modes[n].getHeight();
resolutions.push_back(r);
if (r.width == UserConfigParams::m_width &&
r.height == UserConfigParams::m_height)
{
found_config_res = true;
}
if (r.width == 1024 && r.height == 768)
{
found_1024_768 = true;
}
}
if (!found_config_res)
{
r.width = UserConfigParams::m_width;
r.height = UserConfigParams::m_height;
resolutions.push_back(r);
if (r.width == 1024 && r.height == 768)
{
found_1024_768 = true;
}
} // next found resolution
// Add default resolutions that were not found by irrlicht
if (!found_1024_768)
{
r.width = 1024;
r.height = 768;
resolutions.push_back(r);
}
// Sort resolutions by size
std::sort(resolutions.begin(), resolutions.end());
// Add resolutions list
for(std::vector<Resolution>::iterator it = resolutions.begin();
it != resolutions.end(); it++)
{
const float ratio = it->getRatio();
char name[32];
sprintf(name, "%ix%i", it->width, it->height);
core::stringw label;
label += it->width;
label += L"\u00D7";
label += it->height;
#define ABOUT_EQUAL(a , b) (fabsf( a - b ) < 0.01)
if (ABOUT_EQUAL( ratio, (5.0f/4.0f) ))
res->addItem(label, name, "/gui/screen54.png");
else if (ABOUT_EQUAL( ratio, (4.0f/3.0f) ))
res->addItem(label, name, "/gui/screen43.png");
else if (ABOUT_EQUAL( ratio, (16.0f/10.0f)))
res->addItem(label, name, "/gui/screen1610.png");
else if (ABOUT_EQUAL( ratio, (5.0f/3.0f) ))
res->addItem(label, name, "/gui/screen53.png");
else if (ABOUT_EQUAL( ratio, (3.0f/2.0f) ))
res->addItem(label, name, "/gui/screen32.png");
else if (ABOUT_EQUAL( ratio, (16.0f/9.0f) ))
res->addItem(label, name, "/gui/screen169.png");
else
res->addItem(label, name, "/gui/screen_other.png");
#undef ABOUT_EQUAL
} // add next resolution
} // end if not inited
res->updateItemDisplay();
// ---- select current resolution every time
char searching_for[32];
snprintf(searching_for, 32, "%ix%i", (int)UserConfigParams::m_width,
(int)UserConfigParams::m_height);
if (!res->setSelection(searching_for, PLAYER_ID_GAME_MASTER,
false /* focus it */, true /* even if deactivated*/))
{
Log::error("OptionsScreenVideo", "Cannot find resolution %s", searching_for);
}
// --- set gfx settings values
updateGfxSlider();
// ---- forbid changing resolution or animation settings from in-game
// (we need to disable them last because some items can't be edited when
// disabled)
bool in_game = StateManager::get()->getGameState() == GUIEngine::INGAME_MENU;
res->setActive(!in_game);
full->setActive(!in_game);
applyBtn->setActive(!in_game);
gfx->setActive(!in_game);
getWidget<ButtonWidget>("custom")->setActive(!in_game);
} // init
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 KartSelectionScreen::init()
{
m_instance_ptr = this;
Screen::init();
m_must_delete_on_back = false;
RibbonWidget* tabs = getWidget<RibbonWidget>("kartgroups");
assert( tabs != NULL );
tabs->select(UserConfigParams::m_last_used_kart_group,
PLAYER_ID_GAME_MASTER);
Widget* placeholder = getWidget("playerskarts");
assert(placeholder != NULL);
// FIXME : The reserved id value is -1 when we switch from KSS to NKSS and vice-versa
m_dispatcher->setRootID(placeholder->m_reserved_id);
g_root_id = placeholder->m_reserved_id;
if (!m_widgets.contains(m_dispatcher))
{
m_widgets.push_back(m_dispatcher);
// this is only needed if the dispatcher wasn't already in
// the list of widgets. If it already was, it was added along
// other widgets.
m_dispatcher->add();
}
m_game_master_confirmed = false;
tabs->setActive(true);
m_kart_widgets.clearAndDeleteAll();
StateManager::get()->resetActivePlayers();
input_manager->getDeviceManager()->setAssignMode(DETECT_NEW);
DynamicRibbonWidget* w = getWidget<DynamicRibbonWidget>("karts");
assert( w != NULL );
KartHoverListener* karthoverListener = new KartHoverListener(this);
w->registerHoverListener(karthoverListener);
// Build kart list (it is built everytime, to account for .g. locking)
setKartsFromCurrentGroup();
/*
TODO: Ultimately, it'd be nice to *not* clear m_kart_widgets so that
when players return to the kart selection screen, it will appear as
it did when they left (at least when returning from the track menu).
Rebuilding the screen is a little tricky.
*/
/*
if (m_kart_widgets.size() > 0)
{
// trying to rebuild the screen
for (int n = 0; n < m_kart_widgets.size(); n++)
{
PlayerKartWidget *pkw;
pkw = m_kart_widgets.get(n);
manualAddWidget(pkw);
pkw->add();
}
}
else */
// For now this is what will happen
if (!m_multiplayer)
{
joinPlayer(input_manager->getDeviceManager()->getLatestUsedDevice());
w->updateItemDisplay();
// Player 0 select default kart
if (!w->setSelection(UserConfigParams::m_default_kart, 0, true))
{
// if kart from config not found, select the first instead
w->setSelection(0, 0, true);
}
} else
// Add multiplayer message
addMultiplayerMessage();
// This flag will cause that a 'fire' event will be mapped to 'select' (if
// 'fire' is not assigned to a GUI event). This is done to support the old
// way of player joining by pressing 'fire' instead of 'select'.
input_manager->getDeviceManager()->mapFireToSelect(true);
} // init
// ----------------------------------------------------------------------------
// 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 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 KartSelectionScreen::playerConfirm(const int player_id)
{
DynamicRibbonWidget* w = getWidget<DynamicRibbonWidget>("karts");
assert(w != NULL);
const std::string selection = w->getSelectionIDString(player_id);
if (StringUtils::startsWith(selection, ID_LOCKED) && !m_multiplayer)
{
unlock_manager->playLockSound();
return;
}
if (player_id == PLAYER_ID_GAME_MASTER)
{
UserConfigParams::m_default_kart = selection;
}
if (m_kart_widgets[player_id].getKartInternalName().size() == 0 ||
m_kart_widgets[player_id].getKartInternalName() == RibbonWidget::NO_ITEM_ID)
{
SFXManager::get()->quickSound( "anvil" );
return;
}
const int amount = m_kart_widgets.size();
// Check if we have enough karts for everybody. If there are more players
// than karts then just allow duplicates
const int available_kart_count = (int) w->getItems().size();
const bool will_need_duplicates = (amount > available_kart_count);
// make sure no other player selected the same identity or kart
for (int n=0; n<amount; n++)
{
if (n == player_id) continue; // don't check a kart against itself
const bool player_ready = m_kart_widgets[n].isReady();
const bool ident_conflict =
!m_kart_widgets[n].getAssociatedPlayer()->getProfile()
->isGuestAccount() &&
m_kart_widgets[n].getAssociatedPlayer()->getProfile() ==
m_kart_widgets[player_id].getAssociatedPlayer()->getProfile();
const bool kart_conflict = sameKart(m_kart_widgets[n],
m_kart_widgets[player_id]);
if (player_ready && (ident_conflict || kart_conflict) &&
!will_need_duplicates)
{
if (UserConfigParams::logGUI())
Log::warn("KartSelectionScreen", "You can't select this identity "
"or kart, someone already took it!!");
SFXManager::get()->quickSound( "anvil" );
return;
}
// If two PlayerKart entries are associated to the same ActivePlayer,
// something went wrong
assert(m_kart_widgets[n].getAssociatedPlayer() !=
m_kart_widgets[player_id].getAssociatedPlayer());
}
// Mark this player as ready to start
m_kart_widgets[player_id].markAsReady();
if (player_id == PLAYER_ID_GAME_MASTER)
{
m_game_master_confirmed = true;
RibbonWidget* tabs = getWidget<RibbonWidget>("kartgroups");
assert( tabs != NULL );
tabs->setActive(false);
}
// validate choices to notify player of duplicates
const bool names_ok = validateIdentChoices();
const bool karts_ok = validateKartChoices();
if (!names_ok || !karts_ok) return;
// check if all players are ready
bool allPlayersReady = true;
for (int n=0; n<amount; n++)
{
if (!m_kart_widgets[n].isReady())
{
allPlayersReady = false;
break;
}
}
if (allPlayersReady && (!m_multiplayer || amount > 1)) allPlayersDone();
} // playerConfirm
bool KartSelectionScreen::validateKartChoices()
{
bool ok = true;
const unsigned int amount = m_kart_widgets.size();
// reset all marks, we'll re-add them next if errors are still there
for (unsigned int n=0; n<amount; n++)
{
m_kart_widgets[n].m_model_view->unsetBadge(BAD_BADGE);
}
// Check if we have enough karts for everybody. If there are more
// players than karts then just allow duplicates
DynamicRibbonWidget* w = getWidget<DynamicRibbonWidget>("karts");
assert( w != NULL );
const unsigned int availableKartCount = (unsigned int)w->getItems().size();
if (amount > availableKartCount) return true;
// Check everyone for duplicates
for (unsigned int n=0; n<amount; n++)
{
for (unsigned int m=n+1; m<amount; m++)
{
// check if 2 players took the same name
if (sameKart(m_kart_widgets[n], m_kart_widgets[m]))
{
if (UserConfigParams::logGUI())
{
Log::warn("KartSelectionScreen", "Kart conflict!!");
Log::warn("KartSelectionScreen", " Player %u chose %s",n,
m_kart_widgets[n].getKartInternalName().c_str());
Log::warn("KartSelectionScreen", " Player %u chose %s",m,
m_kart_widgets[m].getKartInternalName().c_str());
}
// two players took the same kart. check if one is ready
if (!m_kart_widgets[n].isReady() &&
m_kart_widgets[m].isReady())
{
if (UserConfigParams::logGUI())
Log::info("KartSelectionScreen", " --> Setting red badge on player %u", n);
// player m is ready, so player n should not choose
// this name
m_kart_widgets[n].m_model_view->setBadge(BAD_BADGE);
}
else if (m_kart_widgets[n].isReady() &&
!m_kart_widgets[m].isReady())
{
if (UserConfigParams::logGUI())
Log::info("KartSelectionScreen", " --> Setting red badge on player %u",m);
// player n is ready, so player m should not
// choose this name
m_kart_widgets[m].m_model_view->setBadge(BAD_BADGE);
}
else if (m_kart_widgets[n].isReady() &&
m_kart_widgets[m].isReady())
{
// it should be impossible for two players to confirm
// they're ready with the same kart
assert(false);
}
// we know it's not ok (but don't stop right now, all bad
// ones need red badges)
ok = false;
}
} // end for
}
return ok;
} // validateKartChoices
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 RaceSetupScreen::eventCallback(Widget* widget, const std::string& name,
const int playerID)
{
if (name == "difficulty")
{
assignDifficulty();
}
else if (name == "gamemode")
{
assignDifficulty();
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;
TracksAndGPScreen::getInstance()->push();
}
else if (selectedMode == IDENT_TTRIAL)
{
race_manager->setMinorMode(RaceManager::MINOR_MODE_TIME_TRIAL);
UserConfigParams::m_game_mode = CONFIG_CODE_TIMETRIAL;
TracksAndGPScreen::getInstance()->push();
}
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;
TracksAndGPScreen::getInstance()->push();
}
else if (selectedMode == IDENT_STRIKES)
{
race_manager->setMinorMode(RaceManager::MINOR_MODE_3_STRIKES);
UserConfigParams::m_game_mode = CONFIG_CODE_3STRIKES;
ArenasScreen::getInstance()->push();
}
else if (selectedMode == IDENT_EASTER)
{
race_manager->setMinorMode(RaceManager::MINOR_MODE_EASTER_EGG);
UserConfigParams::m_game_mode = CONFIG_CODE_EASTER;
race_manager->setNumKarts( race_manager->getNumLocalPlayers() ); // no AI karts;
EasterEggScreen::getInstance()->push();
}
else if (selectedMode == IDENT_SOCCER)
{
race_manager->setMinorMode(RaceManager::MINOR_MODE_SOCCER);
UserConfigParams::m_game_mode = CONFIG_CODE_SOCCER;
SoccerSetupScreen::getInstance()->push();
}
else if (selectedMode == IDENT_GHOST)
{
race_manager->setMinorMode(RaceManager::MINOR_MODE_TIME_TRIAL);
UserConfigParams::m_game_mode = CONFIG_CODE_GHOST;
GhostReplaySelection::getInstance()->push();
}
else if (selectedMode == "locked")
{
unlock_manager->playLockSound();
}
}
else if (name == "back")
{
StateManager::get()->escapePressed();
}
} // eventCallback
