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

Merge branch 'master' of https://github.com/supertuxkart/stk-code

Browse Source
This commit is contained in:
Marianne Gagnon 2014-04-09 18:55:22 -04:00
commit f42e4203cd
51 changed files with 409 additions and 285 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/challenges/unlock_manager.cpp
View File

@ -247,12 +247,12 @@ void UnlockManager::findWhatWasUnlocked(int points_before, int points_now,
{
if (c->getMode() == ChallengeData::CM_SINGLE_RACE && c->getTrackId() != "")
{
if (!PlayerManager::get()->getCurrentPlayer()->isLocked(c->getTrackId()))
if (!PlayerManager::getCurrentPlayer()->isLocked(c->getTrackId()))
tracks.push_back(c->getTrackId());
}
else if (c->getMode() == ChallengeData::CM_GRAND_PRIX && c->getGPId() != "")
{
if (!PlayerManager::get()->getCurrentPlayer()->isLocked(c->getGPId()))
if (!PlayerManager::getCurrentPlayer()->isLocked(c->getGPId()))
gps.push_back(c->getGPId());
}
}

30
src/config/player_manager.cpp
View File

@ -71,32 +71,48 @@ void PlayerManager::load()
{
std::string filename = file_manager->getUserConfigFile("players.xml");
const XMLNode *players = file_manager->createXMLTree(filename);
if(!players)
m_player_data = file_manager->createXMLTree(filename);
if(!m_player_data)
{
Log::info("player_manager", "A new players.xml file will be created.");
return;
}
else if(players->getName()!="players")
else if(m_player_data->getName()!="players")
{
Log::info("player_manager", "The players.xml file is invalid.");
return;
}
m_current_player = NULL;
for(unsigned int i=0; i<players->getNumNodes(); i++)
for(unsigned int i=0; i<m_player_data->getNumNodes(); i++)
{
const XMLNode *player_xml = players->getNode(i);
const XMLNode *player_xml = m_player_data->getNode(i);
PlayerProfile *player = new PlayerProfile(player_xml);
m_all_players.push_back(player);
if(player->isDefault())
m_current_player = player;
}
m_all_players.insertionSort(/*start*/0, /*desc*/true);
delete players;
} // load
// ----------------------------------------------------------------------------
/** The 2nd loading stage. During this stage achievements and story mode
* data is read for each player.
*/
void PlayerManager::loadRemainingData()
{
for (unsigned int i = 0; i<m_player_data->getNumNodes(); i++)
{
const XMLNode *player_xml = m_player_data->getNode(i);
m_all_players[i].loadRemainingData(player_xml);
}
delete m_player_data;
m_player_data = NULL;
// Sort player by frequency
m_all_players.insertionSort(/*start*/0, /*desc*/true);
} // loadRemainingData
// ----------------------------------------------------------------------------
/** Saves all player profiles to players.xml.
*/

12
src/config/player_manager.hpp
View File

@ -48,6 +48,10 @@ private:
/** A pointer to the current player. */
PlayerProfile* m_current_player;
/** Saves the XML tree from players.xml for use in the 2nd
* loading stage (loadRemainingData). */
const XMLNode *m_player_data;
void load();
PlayerManager();
~PlayerManager();
@ -72,6 +76,7 @@ public:
// ------------------------------------------------------------------------
void save();
void loadRemainingData();
unsigned int getUniqueId() const;
void addDefaultPlayer();
void addNewPlayer(const irr::core::stringw& name);
@ -81,7 +86,10 @@ public:
void enforceCurrentPlayer();
// ------------------------------------------------------------------------
/** Returns the current player. */
PlayerProfile* getCurrentPlayer() { return m_current_player; }
static PlayerProfile* getCurrentPlayer()
{
return get()->m_current_player;
} // getCurrentPlayer
// ------------------------------------------------------------------------
PlayerProfile *getPlayer(const irr::core::stringw &name);
// ------------------------------------------------------------------------
@ -100,7 +108,7 @@ public:
/** A handy shortcut funtion. */
static AchievementsStatus* getCurrentAchievementsStatus()
{
return get()->getCurrentPlayer()->getAchievementsStatus();
return PlayerManager::getCurrentPlayer()->getAchievementsStatus();
} // getCurrentAchievementsStatus
// ------------------------------------------------------------------------
/** A handy shortcut to increase points for an achievement key of the

71
src/config/player_profile.cpp
View File

@ -50,26 +50,52 @@ PlayerProfile::PlayerProfile(const core::stringw& name, bool is_guest)
} // PlayerProfile
//------------------------------------------------------------------------------
/** Constructor to deserialize a player that was saved to a XML file.
/** Constructor to deserialize player data that was saved to a XML file. The
* constructor will only load the main player data (like name, id, saved
* online data), but not the achievements and story mode data. Reason is
* that the achievement and story mode data depends on other data to be
* read first (challenges and achievement files), which in turn can only be
* created later in the startup process (they depend on e.g. all tracks to
* be known). On the other hand, automatic login needs to happen asap
* (i.e. as soon as the network thread is started), which needs the main
* player data (i.e. the default player, and saved session data). So the
* constructor only reads this data, the rest of the player data is handled
* in loadRemainingData later in the initialisation process.
* \param node The XML node representing this player.
*/
PlayerProfile::PlayerProfile(const XMLNode* node)
{
m_saved_session = false;
m_saved_token = "";
m_saved_user_id = 0;
m_story_mode_status = NULL;
m_achievements_status = NULL;
node->get("name", &m_name );
node->get("guest", &m_is_guest_account);
node->get("use-frequency", &m_use_frequency );
node->get("unique-id", &m_unique_id );
node->get("is-default", &m_is_default );
node->get("saved-session", &m_saved_session );
node->get("saved-user", &m_saved_user_id );
node->get("saved-token", &m_saved_token );
#ifdef DEBUG
m_magic_number = 0xABCD1234;
#endif
} // PlayerProfile
//------------------------------------------------------------------------------
/** This function loads the achievement and story mode data. This
*/
void PlayerProfile::loadRemainingData(const XMLNode *node)
{
const XMLNode *xml_story_mode = node->getNode("story-mode");
m_story_mode_status = unlock_manager->createStoryModeStatus(xml_story_mode);
const XMLNode *xml_achievements = node->getNode("achievements");
m_achievements_status = AchievementsManager::get()
->createAchievementsStatus(xml_achievements);
} // PlayerProfile
->createAchievementsStatus(xml_achievements);
} // loadRemainingData
//------------------------------------------------------------------------------
/** Writes the data for this player to the specified UTFWriter.
@ -79,9 +105,15 @@ void PlayerProfile::save(UTFWriter &out)
{
out << L" <player name=\"" << m_name
<< L"\" guest=\"" << m_is_guest_account
<< L"\" use-frequency=\"" << m_use_frequency
<< L"\" is-default=\"" << m_is_default
<< L"\" unique-id=\"" << m_unique_id << L"\">\n";
<< L"\" use-frequency=\"" << m_use_frequency << L"\"\n";
out << L" is-default=\"" << m_is_default
<< L"\" unique-id=\"" << m_unique_id
<< L"\" saved-session=\"" << m_saved_session << L"\"\n";
out << L" saved-user=\"" << m_saved_user_id
<< L"\" saved-token=\"" << m_saved_token << L"\">\n";
{
assert(m_story_mode_status);
m_story_mode_status->save(out);
@ -92,6 +124,31 @@ void PlayerProfile::save(UTFWriter &out)
out << L" </player>\n";
} // save
//------------------------------------------------------------------------------
// ------------------------------------------------------------------------
/** Saves the online data, so that it will automatically re-connect
* next time this profile is loaded.
* \param user_id Id of the online profile.
* \param token Token used for authentication.
*/
void PlayerProfile::saveSession(int user_id, const std::string &token)
{
m_saved_session = true;
m_saved_user_id = user_id;
m_saved_token = token;
PlayerManager::get()->save();
} // saveSession
// ------------------------------------------------------------------------
/** Unsets any saved session data. */
void PlayerProfile::clearSession()
{
m_saved_session = false;
m_saved_user_id = 0;
m_saved_token = "";
PlayerManager::get()->save();
} // clearSession
//------------------------------------------------------------------------------
/** Increments how often that account was used. Guest accounts are not counted.
*/

35
src/config/player_profile.hpp
View File

@ -62,6 +62,15 @@ private:
/** True if this is the default (last used) player. */
bool m_is_default;
/** True if this user has a saved session. */
bool m_saved_session;
/** If a session was saved, this will be the online user id to use. */
int m_saved_user_id;
/** The token of the saved session. */
std::string m_saved_token;
/** The complete challenge state. */
StoryModeStatus *m_story_mode_status;
@ -69,15 +78,18 @@ private:
public:
PlayerProfile(const core::stringw& name, bool is_guest = false);
PlayerProfile(const core::stringw &name, bool is_guest = false);
PlayerProfile(const XMLNode* node);
PlayerProfile(const XMLNode *node);
void save(UTFWriter &out);
void loadRemainingData(const XMLNode *node);
void incrementUseFrequency();
bool operator<(const PlayerProfile &other);
bool operator>(const PlayerProfile &other);
void raceFinished();
void saveSession(int user_id, const std::string &token);
void clearSession();
// ------------------------------------------------------------------------
~PlayerProfile()
@ -190,7 +202,24 @@ public:
{
return m_achievements_status;
} // getAchievementsStatus
// ------------------------------------------------------------------------
/** Returns true if a session was saved for this player. */
bool hasSavedSession() const { return m_saved_session; }
// ------------------------------------------------------------------------
/** If a session was saved, return the id of the saved user. */
int getSavedUserId() const
{
assert(m_saved_session);
return m_saved_user_id;
} // getSavedUserId
// ------------------------------------------------------------------------
/** If a session was saved, return the token to use. */
const std::string& getSavedToken() const
{
assert(m_saved_session);
return m_saved_token;
} // getSavedToken
// ------------------------------------------------------------------------
}; // class PlayerProfile
#endif

19
src/config/user_config.hpp
View File

@ -669,25 +669,6 @@ namespace UserConfigParams
&m_online_group,
"The server used for online multiplayer."));
PARAM_PREFIX BoolUserConfigParam m_saved_session
PARAM_DEFAULT( BoolUserConfigParam( false,
"saved_session",
&m_online_group,
"Is there a saved session?") );
PARAM_PREFIX IntUserConfigParam m_saved_user
PARAM_DEFAULT( IntUserConfigParam( 0,
"saved_user",
&m_online_group,
"User ID of the saved session.") );
PARAM_PREFIX StringUserConfigParam m_saved_token
PARAM_DEFAULT( StringUserConfigParam( "",
"saved_token",
&m_online_group,
"Token of the saved session.") );
// ---- Addon server related entries
PARAM_PREFIX GroupUserConfigParam m_addon_group
PARAM_DEFAULT( GroupUserConfigParam("AddonAndNews",

2
src/items/powerup.cpp
View File

@ -176,7 +176,7 @@ void Powerup::use()
// The player gets an achievement point for using a powerup
StateManager::ActivePlayer * player = m_owner->getController()->getPlayer();
if (m_type != PowerupManager::POWERUP_NOTHING &&
player != NULL && player->getConstProfile() == PlayerManager::get()->getCurrentPlayer())
player != NULL && player->getConstProfile() == PlayerManager::getCurrentPlayer())
{
PlayerManager::increaseAchievement(AchievementInfo::ACHIEVE_POWERUP_LOVER, "poweruplover");
}

2
src/karts/kart.cpp
View File

@ -806,7 +806,7 @@ void Kart::finishedRace(float time)
m_controller));
if (m_controller->isPlayerController()) // if player is on this computer
{
PlayerProfile *player = PlayerManager::get()->getCurrentPlayer();
PlayerProfile *player = PlayerManager::getCurrentPlayer();
const ChallengeStatus *challenge = player->getCurrentChallengeStatus();
// In case of a GP challenge don't make the end animation depend
// on if the challenge is fulfilled

4
src/karts/kart_properties_manager.cpp
View File

@ -355,7 +355,7 @@ bool KartPropertiesManager::kartAvailable(int kartid)
if ( kartid == *it) return false;
}
const KartProperties *kartprop = getKartById(kartid);
if( PlayerManager::get()->getCurrentPlayer()->isLocked(kartprop->getIdent()) )
if( PlayerManager::getCurrentPlayer()->isLocked(kartprop->getIdent()) )
return false;
return true;
} // kartAvailable
@ -464,7 +464,7 @@ void KartPropertiesManager::getRandomKartList(int count,
const KartProperties &kp=m_karts_properties[karts_in_group[i]];
if (!used[karts_in_group[i]] &&
m_kart_available[karts_in_group[i]] &&
!PlayerManager::get()->getCurrentPlayer()->isLocked(kp.getIdent()) )
!PlayerManager::getCurrentPlayer()->isLocked(kp.getIdent()) )
{
random_kart_queue.push_back(kp.getIdent());
}

2
src/karts/skidding.cpp
View File

@ -416,7 +416,7 @@ void Skidding::update(float dt, bool is_on_ground,
/*fade-out-time*/ 1.0f);
StateManager::ActivePlayer *c = m_kart->getController()->getPlayer();
if (c && c->getConstProfile() == PlayerManager::get()->getCurrentPlayer())
if (c && c->getConstProfile() == PlayerManager::getCurrentPlayer())
{
PlayerManager::increaseAchievement(AchievementInfo::ACHIEVE_SKIDDING, "skidding");
}

19
src/main.cpp
View File

@ -694,7 +694,7 @@ int handleCmdLine()
if(CommandLine::has("--kart", &s))
{
const PlayerProfile *player = PlayerManager::get()->getCurrentPlayer();
const PlayerProfile *player = PlayerManager::getCurrentPlayer();
if(player && !player->isLocked(s))
{
@ -766,7 +766,7 @@ int handleCmdLine()
if(CommandLine::has("--track", &s) || CommandLine::has("-t", &s))
{
const PlayerProfile *player = PlayerManager::get()->getCurrentPlayer();
const PlayerProfile *player = PlayerManager::getCurrentPlayer();
if (player && !player->isLocked(s))
{
race_manager->setTrack(s);
@ -1030,6 +1030,11 @@ void initRest()
addons_manager = new AddonsManager();
Online::ProfileManager::create();
// The request manager will start the login process in case of a saved
// session, so we need to read the main data from the players.xml file.
// The rest will be read later (since the rest needs the unlock- and
// achievement managers to be created, which can only be created later).
PlayerManager::create();
Online::RequestManager::get()->startNetworkThread();
NewsManager::get(); // this will create the news manager
@ -1165,13 +1170,15 @@ int main(int argc, char *argv[] )
handleXmasMode();
// Needs the kart and track directories to load potential challenges
// in those dirs.
// in those dirs, so it can only be created after reading tracks
// and karts.
unlock_manager = new UnlockManager();
AchievementsManager::create();
// Needs the unlock manager to initialise the game slots of all players
// and the AchievementsManager to initialise the AchievementsStatus.
PlayerManager::create();
// Reading the rest of the player data needs the unlock manager to
// initialise the game slots of all players and the AchievementsManager
// to initialise the AchievementsStatus, so it is done only now.
PlayerManager::get()->loadRemainingData();
GUIEngine::addLoadingIcon( irr_driver->getTexture(FileManager::GUI,
"gui_lock.png" ) );

2
src/modes/cutscene_world.cpp
View File

@ -380,7 +380,7 @@ void CutsceneWorld::enterRaceOverState()
else if (race_manager->getTrackName() == "introcutscene" ||
race_manager->getTrackName() == "introcutscene2")
{
PlayerProfile *player = PlayerManager::get()->getCurrentPlayer();
PlayerProfile *player = PlayerManager::getCurrentPlayer();
if (player->isFirstTime())
{
race_manager->exitRace();

2
src/modes/linear_world.cpp
View File

@ -240,7 +240,7 @@ void LinearWorld::newLap(unsigned int kart_index)
// Reset reset-after-lap achievements
StateManager::ActivePlayer *c = kart->getController()->getPlayer();
PlayerProfile *p = PlayerManager::get()->getCurrentPlayer();
PlayerProfile *p = PlayerManager::getCurrentPlayer();
if (c && c->getConstProfile() == p)
{
p->getAchievementsStatus()->onLapEnd();

2
src/modes/overworld.cpp
View File

@ -66,7 +66,7 @@ void OverWorld::enterOverWorld()
InputDevice* device = input_manager->getDeviceList()->getKeyboard(0);
// Create player and associate player with keyboard
StateManager::get()->createActivePlayer(PlayerManager::get()->getCurrentPlayer(),
StateManager::get()->createActivePlayer(PlayerManager::getCurrentPlayer(),
device, NULL);
if (!kart_properties_manager->getKart(UserConfigParams::m_default_kart))

8
src/modes/world.cpp
View File

@ -469,7 +469,7 @@ void World::terminateRace()
{
// Retrieve the current player
StateManager::ActivePlayer* p = m_karts[i]->getController()->getPlayer();
if (p && p->getConstProfile() == PlayerManager::get()->getCurrentPlayer())
if (p && p->getConstProfile() == PlayerManager::getCurrentPlayer())
{
// Check if the player has won
if (m_karts[i]->getPosition() == winner_position && kart_amount > opponents )
@ -494,7 +494,7 @@ void World::terminateRace()
{
// Retrieve the current player
StateManager::ActivePlayer* p = m_karts[i]->getController()->getPlayer();
if (p && p->getConstProfile() == PlayerManager::get()->getCurrentPlayer())
if (p && p->getConstProfile() == PlayerManager::getCurrentPlayer())
{
// Check if the player has won
if (m_karts[i]->getPosition() == 1 )
@ -511,7 +511,7 @@ void World::terminateRace()
}
}
}
PlayerManager::get()->getCurrentPlayer()->raceFinished();
PlayerManager::getCurrentPlayer()->raceFinished();
if (m_race_gui) m_race_gui->clearAllMessages();
// we can't delete the race gui here, since it is needed in case of
@ -815,7 +815,7 @@ void World::updateWorld(float dt)
InputDevice* device = input_manager->getDeviceList()->getKeyboard(0);
// Create player and associate player with keyboard
StateManager::get()->createActivePlayer(PlayerManager::get()->getCurrentPlayer(),
StateManager::get()->createActivePlayer(PlayerManager::getCurrentPlayer(),
device, NULL);
if (!kart_properties_manager->getKart(UserConfigParams::m_default_kart))

56
src/network/protocols/request_connection.cpp
View File

@ -19,38 +19,63 @@
#include "network/protocols/request_connection.hpp"
#include "network/protocol_manager.hpp"
#include "online/request_manager.hpp"
#include "online/servers_manager.hpp"
#include "online/current_user.hpp"
#include "config/user_config.hpp"
RequestConnection::RequestConnection(uint32_t server_id) : Protocol(NULL, PROTOCOL_SILENT)
using namespace Online;
/** Constructor. Stores the server id.
* \param server_id Id of the server.
*/
RequestConnection::RequestConnection(uint32_t server_id)
: Protocol(NULL, PROTOCOL_SILENT)
{
m_server_id = server_id;
}
} // RequestConnection
// ----------------------------------------------------------------------------
RequestConnection::~RequestConnection()
{
}
} // ~RequestConnection
// ----------------------------------------------------------------------------
/** Setup of this request, sets state to none.
*/
void RequestConnection::setup()
{
m_state = NONE;
}
} // setup
// ----------------------------------------------------------------------------
/** The callback for the server join request. It informs the server manager
* of a successful join request.
*/
void RequestConnection::ServerJoinRequest::callback()
{
if (isSuccess())
{
uint32_t server_id;
getXMLData()->get("serverid", &server_id);
ServersManager::get()->setJoinedServer(server_id);
}
} // ServerJoinRequest::callback
// ----------------------------------------------------------------------------
/** This implements a finite state machine to monitor the server join
* request asynchronously.
*/
void RequestConnection::asynchronousUpdate()
{
switch (m_state)
{
case NONE:
{
m_request = new Online::CurrentUser::ServerJoinRequest();
m_request = new ServerJoinRequest();
CurrentUser::setUserDetails(m_request, "request-connection");
m_request->setServerURL("address-management.php");
m_request->addParameter("id",Online::CurrentUser::get()->getID());
m_request->addParameter("token",Online::CurrentUser::get()->getToken());
m_request->addParameter("server_id",m_server_id);
m_request->addParameter("action","request-connection");
Online::RequestManager::get()->addRequest(m_request);
m_request->queue();
m_state = REQUEST_PENDING;
break;
}
@ -65,11 +90,14 @@ void RequestConnection::asynchronousUpdate()
{
if (rec_success == "yes")
{
Log::debug("RequestConnection", "Connection Request made successfully.");
Log::debug("RequestConnection",
"Connection Request made successfully.");
}
else
{
Log::error("RequestConnection", "Fail to make a request to connecto to server %d", m_server_id);
Log::error("RequestConnection",
"Fail to make a request to connecto to server %d",
m_server_id);
}
}
else
@ -89,5 +117,5 @@ void RequestConnection::asynchronousUpdate()
case EXITING:
break;
}
}
} // asynchronousUpdate

61
src/network/protocols/request_connection.hpp
View File

@ -1,33 +1,52 @@
#ifndef REQUEST_CONNECTION_HPP
#define REQUEST_CONNECTION_HPP
#ifndef HEADER_REQUEST_CONNECTION_HPP
#define HEADER_REQUEST_CONNECTION_HPP
#include "network/protocol.hpp"
#include "online/current_user.hpp"
#include "online/xml_request.hpp"
class RequestConnection : public Protocol
{
protected:
/** Id of the server to join. */
uint32_t m_server_id;
/** The request to join a server. */
Online::XMLRequest *m_request;
enum STATE
{
NONE,
REQUEST_PENDING,
DONE,
EXITING
};
/** State of this connection. */
STATE m_state;
public:
// --------------------------------------------------------------------
/** A simple request class to ask to join a server.
*/
class ServerJoinRequest : public Online::XMLRequest
{
virtual void callback();
public:
RequestConnection(uint32_t server_id);
virtual ~RequestConnection();
ServerJoinRequest() : Online::XMLRequest() {}
}; // ServerJoinRequest
// --------------------------------------------------------------------
virtual bool notifyEvent(Event* event) { return true; }
virtual bool notifyEventAsynchronous(Event* event) { return true; }
virtual void setup();
virtual void update() {}
virtual void asynchronousUpdate();
protected:
uint32_t m_server_id;
Online::CurrentUser::ServerJoinRequest* m_request;
enum STATE
{
NONE,
REQUEST_PENDING,
DONE,
EXITING
};
STATE m_state;
RequestConnection(uint32_t server_id);
virtual ~RequestConnection();
};
virtual bool notifyEvent(Event* event) { return true; }
virtual bool notifyEventAsynchronous(Event* event) { return true; }
virtual void setup();
virtual void update() {}
virtual void asynchronousUpdate();
}; // RequestConnection
#endif // REQUEST_CONNECTION_HPP

2
src/network/protocols/start_game_protocol.cpp
View File

@ -115,7 +115,7 @@ void StartGameProtocol::update()
rki.setGlobalPlayerId(profile->race_id);
rki.setLocalPlayerId(is_me?0:1);
rki.setHostId(profile->race_id);
PlayerProfile* profile_to_use = PlayerManager::get()->getCurrentPlayer();
PlayerProfile* profile_to_use = PlayerManager::getCurrentPlayer();
assert(profile_to_use);
InputDevice* device = input_manager->getDeviceList()->getLatestUsedDevice();
int new_player_id = 0;

46
src/online/current_user.cpp
View File

@ -97,14 +97,14 @@ namespace Online
void CurrentUser::requestSavedSession()
{
SignInRequest * request = NULL;
if(m_state == US_SIGNED_OUT && UserConfigParams::m_saved_session)
const PlayerProfile *cp = PlayerManager::getCurrentPlayer();
if (m_state == US_SIGNED_OUT && cp->hasSavedSession() )
{
request = new SignInRequest(true);
request->setServerURL("client-user.php");
request->addParameter("action","saved-session");
request->addParameter("userid", UserConfigParams::m_saved_user);
request->addParameter("token",
UserConfigParams::m_saved_token.c_str());
request->addParameter("userid", cp->getSavedUserId());
request->addParameter("token", cp->getSavedToken());
request->queue();
m_state = US_SIGNING_IN;
}
@ -179,9 +179,8 @@ namespace Online
m_state = US_SIGNED_IN;
if(saveSession())
{
UserConfigParams::m_saved_user = getID();
UserConfigParams::m_saved_token = getToken();
UserConfigParams::m_saved_session = true;
PlayerManager::getCurrentPlayer()->saveSession(getID(),
getToken() );
}
ProfileManager::get()->addPersistent(m_profile);
std::string achieved_string("");
@ -231,40 +230,9 @@ namespace Online
ProfileManager::get()->clearPersistent();
m_profile = NULL;
m_state = US_SIGNED_OUT;
UserConfigParams::m_saved_user = 0;
UserConfigParams::m_saved_token = "";
UserConfigParams::m_saved_session = false;
PlayerManager::getCurrentPlayer()->clearSession();
} // signOut
// ------------------------------------------------------------------------
CurrentUser::ServerJoinRequest*
CurrentUser::requestServerJoin(uint32_t server_id,
bool request_now)
{
assert(m_state == US_SIGNED_IN || m_state == US_GUEST);
ServerJoinRequest * request = new ServerJoinRequest();
request->setServerURL("address-management.php");
request->addParameter("action","request-connection");
request->addParameter("token", getToken());
request->addParameter("id", getID());
request->addParameter("server_id", server_id);
if (request_now)
request->queue();
return request;
} // requestServerJoin
// ------------------------------------------------------------------------
void CurrentUser::ServerJoinRequest::callback()
{
if(isSuccess())
{
uint32_t server_id;
getXMLData()->get("serverid", &server_id);
ServersManager::get()->setJoinedServer(server_id);
}
//FIXME needs changes for actual valid joining
} // ServerJoinRequest::callback
// ------------------------------------------------------------------------
/** Sends a request to the server to see if any new information is
* available. (online friends, notifications, etc.).

9
src/online/current_user.hpp
View File

@ -72,14 +72,6 @@ namespace Online
SignOutRequest() : XMLRequest(true,/*priority*/10) {}
}; // SignOutRequest
// ----------------------------------------------------------------
class ServerJoinRequest : public XMLRequest {
virtual void callback ();
public:
ServerJoinRequest() : XMLRequest() {}
}; // ServerJoinRequest
// ----------------------------------------------------------------
class PollRequest : public XMLRequest {
virtual void callback ();
@ -113,7 +105,6 @@ namespace Online
bool save_session,
bool request_now = true);
void requestSignOut();
ServerJoinRequest * requestServerJoin(uint32_t server_id, bool request_now = true);
void requestFriendRequest(const uint32_t friend_id) const;
void onSTKQuit() const;

11
src/online/messages.cpp
View File

@ -46,12 +46,6 @@ namespace Online
}
// ------------------------------------------------------------------------
irr::core::stringw signedInAs(const irr::core::stringw & name)
{
return irr::core::stringw(_("Signed in as : ")) + name + ".";
}
// ------------------------------------------------------------------------
irr::core::stringw joiningServer()
{
return irr::core::stringw(_("Joining server")) + loadingDots();
@ -94,13 +88,12 @@ namespace Online
// ------------------------------------------------------------------------
/**
* Shows a increasing number of dots.
* \param spaces Flag if unshowed dots should be replaced by spaces
* \param interval A float representing the time it takes to add a new dot
* \param max_dots The number of dots used. Defaults to 3.
*/
irr::core::stringw loadingDots(bool spaces, float interval, int max_dots)
irr::core::stringw loadingDots(float interval, int max_dots)
{
int nr_dots = int(floor(StkTime::getRealTime() * (1 / interval))) % (max_dots+1);
int nr_dots = int(floor(StkTime::getRealTime() / interval)) % (max_dots+1);
return irr::core::stringw((std::string(nr_dots,'.') + std::string(max_dots-nr_dots,' ')).c_str());
}
} // namespace messages

3
src/online/messages.hpp
View File

@ -30,7 +30,7 @@ namespace Online
*/
namespace Messages
{
irr::core::stringw loadingDots (bool spaces = true, float interval = 0.5f, int max_dots = 3);
irr::core::stringw loadingDots (float interval = 0.5f, int max_dots = 3);
irr::core::stringw signingIn ();
irr::core::stringw signingOut ();
irr::core::stringw validatingInfo ();
@ -41,7 +41,6 @@ namespace Online
irr::core::stringw fetchingFriends ();
irr::core::stringw fetchingAchievements ();
irr::core::stringw processing ();
irr::core::stringw signedInAs (const irr::core::stringw & name);
} // namespace Messages
}// namespace Online
#endif

3
src/online/request_manager.cpp
View File

@ -102,6 +102,9 @@ namespace Online
* variable has not been assigned at that stage, and the thread might
* use network_http - a very subtle race condition. So the thread can
* only be started after the assignment (in main) has been done.
* \pre PlayerManager was created and has read the main data for each
* player so that all data for automatic login is
* availale.
*/
void RequestManager::startNetworkThread()
{

2
src/physics/physics.cpp
View File

@ -271,7 +271,7 @@ void Physics::update(float dt)
// to the kart, and it's the current player. At this stage
// only the current player can get achievements.
if (target_kart != kart && c &&
c->getPlayer()->getConstProfile() == PlayerManager::get()->getCurrentPlayer())
c->getPlayer()->getConstProfile() == PlayerManager::getCurrentPlayer())
{
PlayerManager::increaseAchievement(AchievementInfo::ACHIEVE_ARCH_ENEMY,
target_kart->getIdent(), 1);

2
src/race/grand_prix_data.cpp
View File

@ -223,7 +223,7 @@ bool GrandPrixData::checkConsistency(bool chatty) const
bool GrandPrixData::isTrackAvailable(const std::string &id) const
{
return id!="fortmagma" ||
!PlayerManager::get()->getCurrentPlayer()->isLocked("fortmagma");
!PlayerManager::getCurrentPlayer()->isLocked("fortmagma");
} // isTrackAvailable
// ----------------------------------------------------------------------------

2
src/race/race_manager.cpp
View File

@ -632,7 +632,7 @@ void RaceManager::exitRace(bool delete_world)
// were finished, and not when a race is aborted.
if (m_major_mode==MAJOR_MODE_GRAND_PRIX && m_track_number==(int)m_tracks.size())
{
PlayerManager::get()->getCurrentPlayer()->grandPrixFinished();
PlayerManager::getCurrentPlayer()->grandPrixFinished();
if(m_major_mode==MAJOR_MODE_GRAND_PRIX&& !NetworkWorld::getInstance()->isRunning())
{
//Delete saved GP

4
src/states_screens/arenas_screen.cpp
View File

@ -236,7 +236,7 @@ void ArenasScreen::buildTrackList()
if(!curr->isArena()) continue;
}
if (PlayerManager::get()->getCurrentPlayer()->isLocked(curr->getIdent()))
if (PlayerManager::getCurrentPlayer()->isLocked(curr->getIdent()))
{
w->addItem( _("Locked : solve active challenges to gain access to more!"),
"locked", curr->getScreenshotFile(), LOCKED_BADGE );
@ -266,7 +266,7 @@ void ArenasScreen::buildTrackList()
if(!curr->isArena()) continue;
}
if (PlayerManager::get()->getCurrentPlayer()->isLocked(curr->getIdent()))
if (PlayerManager::getCurrentPlayer()->isLocked(curr->getIdent()))
{
w->addItem( _("Locked : solve active challenges to gain access to more!"),
"locked", curr->getScreenshotFile(), LOCKED_BADGE );

2
src/states_screens/dialogs/gp_info_dialog.cpp
View File

@ -221,7 +221,7 @@ void GPInfoDialog::onEnterPressedInternal()
std::string gp_id = m_gp_ident;
ModalDialog::dismiss();
// Disable accidentally unlocking of a challenge
PlayerManager::get()->getCurrentPlayer()->setCurrentChallenge("");
PlayerManager::getCurrentPlayer()->setCurrentChallenge("");
race_manager->startGP(grand_prix_manager->getGrandPrix(gp_id), false, false);
}

58
src/states_screens/dialogs/player_info_dialog.cpp
View File

@ -39,29 +39,38 @@ using namespace irr::gui;
using namespace irr::core;
// -----------------------------------------------------------------------------
PlayerInfoDialog::PlayerInfoDialog(PlayerProfile* player, const float w, const float h) : ModalDialog(w, h)
/** Creates a modal dialog with given percentage of screen width and height.
*/
PlayerInfoDialog::PlayerInfoDialog(PlayerProfile* player, const float w,
const float h)
: ModalDialog(w, h)
{
m_player = player;
doInit();
showRegularDialog();
}
} // PlayerInfoDialog
// -----------------------------------------------------------------------------
/** When the dialog is finished, select the just edited player again in the
* option screen.
*/
PlayerInfoDialog::~PlayerInfoDialog()
{
if (m_player != NULL)
{
OptionsScreenPlayers::getInstance()->selectPlayer( translations->fribidize(m_player->getName()) );
OptionsScreenPlayers::getInstance()->selectPlayer(
translations->fribidize(m_player->getName()) );
}
}
} // ~PlayerInfoDialog
// -----------------------------------------------------------------------------
/** Show the current data of this player.
*/
void PlayerInfoDialog::showRegularDialog()
{
clearWindow();
if (m_irrlicht_window)
clearWindow();
const int y1 = m_area.getHeight()/6;
const int y2 = m_area.getHeight()*2/6;
@ -92,7 +101,8 @@ void PlayerInfoDialog::showRegularDialog()
//I18N: In the player info dialog
widget->setText( _("Rename") );
const int textWidth = font->getDimension( widget->getText().c_str() ).Width + 40;
const int textWidth =
font->getDimension( widget->getText().c_str() ).Width + 40;
widget->m_x = m_area.getWidth()/2 - textWidth/2;
widget->m_y = y2;
@ -139,10 +149,11 @@ void PlayerInfoDialog::showRegularDialog()
}
textCtrl->setFocusForPlayer( PLAYER_ID_GAME_MASTER );
}
} // showRegularDialog
// -----------------------------------------------------------------------------
/** Changes this dialog to confirm the changes.
*/
void PlayerInfoDialog::showConfirmDialog()
{
clearWindow();
@ -156,9 +167,10 @@ void PlayerInfoDialog::showConfirmDialog()
_("Do you really want to delete player '%s' ?", m_player->getName());
if (PlayerManager::get()->getCurrentPlayer() == m_player)
if (PlayerManager::getCurrentPlayer() == m_player)
{
message = _("You cannot delete this player because it is currently in use.");
message = _("You cannot delete this player "
"because it is currently in use.");
}
core::rect< s32 > area_left(5, 0, m_area.getWidth()-5, m_area.getHeight()/2);
@ -167,11 +179,12 @@ void PlayerInfoDialog::showConfirmDialog()
// we can add irrlicht labels directly
// (more complicated uses require the use of our widget set)
IGUIStaticText* a = GUIEngine::getGUIEnv()->addStaticText( message.c_str(),
area_left, false /* border */, true /* word wrap */,
area_left, false /* border */,
true /* word wrap */,
m_irrlicht_window);
a->setTextAlignment(EGUIA_CENTER, EGUIA_CENTER);
if (PlayerManager::get()->getCurrentPlayer() != m_player)
if (PlayerManager::getCurrentPlayer() != m_player)
{
ButtonWidget* widget = new ButtonWidget();
widget->m_properties[PROP_ID] = "confirmremove";
@ -212,22 +225,23 @@ void PlayerInfoDialog::showConfirmDialog()
widget->setFocusForPlayer( PLAYER_ID_GAME_MASTER );
}
}
} // showConfirmDialog
// -----------------------------------------------------------------------------
void PlayerInfoDialog::onEnterPressedInternal()
{
}
} // onEnterPressedInternal
// -----------------------------------------------------------------------------
GUIEngine::EventPropagation PlayerInfoDialog::processEvent(const std::string& eventSource)
GUIEngine::EventPropagation
PlayerInfoDialog::processEvent(const std::string& eventSource)
{
if (eventSource == "renameplayer")
{
// accept entered name
stringw playerName = textCtrl->getText().trim();
stringw player_name = textCtrl->getText().trim();
const int player_amount = PlayerManager::get()->getNumPlayers();
for(int n=0; n<player_amount; n++)
@ -235,7 +249,7 @@ GUIEngine::EventPropagation PlayerInfoDialog::processEvent(const std::string& ev
const PlayerProfile *player = PlayerManager::get()->getPlayer(n);
if (player == m_player) continue;
if (player->getName() == playerName)
if (player->getName() == player_name)
{
ButtonWidget* label = getWidget<ButtonWidget>("renameplayer");
label->setBadge(BAD_BADGE);
@ -244,9 +258,9 @@ GUIEngine::EventPropagation PlayerInfoDialog::processEvent(const std::string& ev
}
}
if (playerName.size() <= 0) return GUIEngine::EVENT_BLOCK;
if (player_name.size() <= 0) return GUIEngine::EVENT_BLOCK;
OptionsScreenPlayers::getInstance()->renamePlayer( playerName, m_player );
OptionsScreenPlayers::getInstance()->renamePlayer(player_name,m_player);
// irrLicht is too stupid to remove focus from deleted widgets
// so do it by hand
@ -292,7 +306,7 @@ GUIEngine::EventPropagation PlayerInfoDialog::processEvent(const std::string& ev
return GUIEngine::EVENT_BLOCK;
}
return GUIEngine::EVENT_LET;
}
} // processEvent
// -----------------------------------------------------------------------------

3
src/states_screens/dialogs/player_info_dialog.hpp
View File

@ -40,9 +40,6 @@ class PlayerInfoDialog : public GUIEngine::ModalDialog
void showRegularDialog();
void showConfirmDialog();
public:
/**
* Creates a modal dialog with given percentage of screen width and height
*/
PlayerInfoDialog(PlayerProfile* PlayerInfoDialog,
const float percentWidth, const float percentHeight);

4
src/states_screens/dialogs/select_challenge.cpp
View File

@ -95,7 +95,7 @@ SelectChallengeDialog::SelectChallengeDialog(const float percentWidth,
break;
}
const ChallengeStatus* c = PlayerManager::get()->getCurrentPlayer()
const ChallengeStatus* c = PlayerManager::getCurrentPlayer()
->getChallengeStatus(challenge_id);
if (c->isSolved(RaceManager::DIFFICULTY_EASY))
@ -173,7 +173,7 @@ GUIEngine::EventPropagation SelectChallengeDialog::processEvent(const std::strin
return GUIEngine::EVENT_LET;
}
PlayerManager::get()->getCurrentPlayer()->setCurrentChallenge(m_challenge_id);
PlayerManager::getCurrentPlayer()->setCurrentChallenge(m_challenge_id);
ModalDialog::dismiss();

13
src/states_screens/dialogs/server_info_dialog.cpp
View File

@ -17,22 +17,20 @@
#include "states_screens/dialogs/server_info_dialog.hpp"
#include <IGUIEnvironment.h>
#include "audio/sfx_manager.hpp"
#include "guiengine/engine.hpp"
#include "states_screens/state_manager.hpp"
#include "utils/translation.hpp"
#include "utils/string_utils.hpp"
#include "network/protocol_manager.hpp"
#include "network/protocols/connect_to_server.hpp"
#include "online/current_user.hpp"
#include "online/servers_manager.hpp"
#include "online/messages.hpp"
#include "online/servers_manager.hpp"
#include "states_screens/dialogs/registration_dialog.hpp"
#include "states_screens/networking_lobby.hpp"
#include "states_screens/state_manager.hpp"
#include "utils/string_utils.hpp"
#include "utils/translation.hpp"
#include <IGUIEnvironment.h>
using namespace GUIEngine;
using namespace irr;
@ -80,6 +78,7 @@ ServerInfoDialog::~ServerInfoDialog()
// -----------------------------------------------------------------------------
void ServerInfoDialog::requestJoin()
{
// FIXME - without this next line, it appears that m_server_join is completely unused.
//m_server_join_request = Online::CurrentUser::get()->requestServerJoin(m_server_id);
Online::ServersManager::get()->setJoinedServer(m_server_id);
ProtocolManager::getInstance()->requestStart(new ConnectToServer(m_server_id, m_host_id));

5
src/states_screens/dialogs/server_info_dialog.hpp
View File

@ -25,8 +25,9 @@
#include "guiengine/widgets/icon_button_widget.hpp"
#include "guiengine/widgets/ribbon_widget.hpp"
#include "guiengine/widgets/label_widget.hpp"
#include "online/server.hpp"
#include "network/protocols/request_connection.hpp"
#include "online/current_user.hpp"
#include "online/server.hpp"
#include "utils/types.hpp"
@ -42,7 +43,7 @@ private:
bool m_self_destroy;
bool m_enter_lobby;
bool m_from_server_creation;
const Online::CurrentUser::ServerJoinRequest * m_server_join_request;
const RequestConnection::ServerJoinRequest * m_server_join_request;
const uint32_t m_server_id;
uint32_t m_host_id;

2
src/states_screens/dialogs/track_info_dialog.cpp
View File

@ -252,7 +252,7 @@ void TrackInfoDialog::onEnterPressedInternal()
race_manager->setReverseTrack(reverse_track);
std::string track_ident = m_track_ident;
// Disable accidentally unlocking of a challenge
PlayerManager::get()->getCurrentPlayer()->setCurrentChallenge("");
PlayerManager::getCurrentPlayer()->setCurrentChallenge("");
ModalDialog::dismiss();
race_manager->startSingleRace(track_ident, num_laps, false);

4
src/states_screens/easter_egg_screen.cpp
View File

@ -236,7 +236,7 @@ void EasterEggScreen::buildTrackList()
if (curr->isArena() || curr->isSoccer()) continue;
if (curr->isInternal()) continue;
if (PlayerManager::get()->getCurrentPlayer()->isLocked(curr->getIdent()))
if (PlayerManager::getCurrentPlayer()->isLocked(curr->getIdent()))
{
tracks_widget->addItem( _("Locked : solve active challenges to gain access to more!"),
"locked", curr->getScreenshotFile(), LOCKED_BADGE,
@ -267,7 +267,7 @@ void EasterEggScreen::buildTrackList()
if (curr->isSoccer()) continue;
if (curr->isInternal()) continue;
if (PlayerManager::get()->getCurrentPlayer()->isLocked(curr->getIdent()))
if (PlayerManager::getCurrentPlayer()->isLocked(curr->getIdent()))
{
tracks_widget->addItem( _("Locked : solve active challenges to gain access to more!"),
"locked", curr->getScreenshotFile(), LOCKED_BADGE,

4
src/states_screens/feature_unlocked.cpp
View File

@ -144,7 +144,7 @@ void FeatureUnlockedCutScene::loadedFromFile()
void FeatureUnlockedCutScene::findWhatWasUnlocked(RaceManager::Difficulty difficulty)
{
PlayerProfile *player = PlayerManager::get()->getCurrentPlayer();
PlayerProfile *player = PlayerManager::getCurrentPlayer();
int points_before = player->getPoints();
int points_now = points_before + CHALLENGE_POINTS[difficulty];
@ -410,7 +410,7 @@ void FeatureUnlockedCutScene::tearDown()
m_all_kart_models.clearAndDeleteAll();
// update point count and the list of locked/unlocked stuff
PlayerManager::get()->getCurrentPlayer()->computeActive();
PlayerManager::getCurrentPlayer()->computeActive();
} // tearDown
// ----------------------------------------------------------------------------

4
src/states_screens/grand_prix_lose.cpp
View File

@ -278,7 +278,7 @@ void GrandPrixLose::eventCallback(GUIEngine::Widget* widget,
race_manager->setMajorMode (RaceManager::MAJOR_MODE_SINGLE);
std::vector<const ChallengeData*> unlocked =
PlayerManager::get()->getCurrentPlayer()->getRecentlyCompletedChallenges();
PlayerManager::getCurrentPlayer()->getRecentlyCompletedChallenges();
if (unlocked.size() > 0)
{
@ -289,7 +289,7 @@ void GrandPrixLose::eventCallback(GUIEngine::Widget* widget,
scene->findWhatWasUnlocked(race_manager->getDifficulty());
StateManager::get()->replaceTopMostScreen(scene);
PlayerManager::get()->getCurrentPlayer()->clearUnlocked();
PlayerManager::getCurrentPlayer()->clearUnlocked();
}
else
{

10
src/states_screens/grand_prix_win.cpp
View File

@ -98,7 +98,7 @@ void GrandPrixWin::loadedFromFile()
void GrandPrixWin::init()
{
Screen::init();
if (PlayerManager::get()->getCurrentPlayer()->getRecentlyCompletedChallenges().size() > 0)
if (PlayerManager::getCurrentPlayer()->getRecentlyCompletedChallenges().size() > 0)
{
const core::dimension2d<u32>& frame_size = GUIEngine::getDriver()->getCurrentRenderTargetSize();
@ -406,12 +406,12 @@ void GrandPrixWin::eventCallback(GUIEngine::Widget* widget,
// un-set the GP mode so that after unlocking, it doesn't try to continue the GP
race_manager->setMajorMode (RaceManager::MAJOR_MODE_SINGLE);
if (PlayerManager::get()->getCurrentPlayer()
->getRecentlyCompletedChallenges().size() > 0)
if (PlayerManager::getCurrentPlayer()
->getRecentlyCompletedChallenges().size() > 0)
{
std::vector<const ChallengeData*> unlocked =
PlayerManager::get()->getCurrentPlayer()->getRecentlyCompletedChallenges();
PlayerManager::get()->getCurrentPlayer()->clearUnlocked();
PlayerManager::getCurrentPlayer()->getRecentlyCompletedChallenges();
PlayerManager::getCurrentPlayer()->clearUnlocked();
FeatureUnlockedCutScene* scene =
FeatureUnlockedCutScene::getInstance();

2
src/states_screens/help_screen_1.cpp
View File

@ -66,7 +66,7 @@ void HelpScreen1::eventCallback(Widget* widget, const std::string& name, const i
InputDevice* device = input_manager->getDeviceList()->getKeyboard(0);
// Create player and associate player with keyboard
StateManager::get()->createActivePlayer(PlayerManager::get()->getCurrentPlayer(),
StateManager::get()->createActivePlayer(PlayerManager::getCurrentPlayer(),
device, NULL);
if (kart_properties_manager->getKart(UserConfigParams::m_default_kart) == NULL)

6
src/states_screens/kart_selection.cpp
View File

@ -1104,7 +1104,7 @@ bool KartSelectionScreen::playerJoin(InputDevice* device, bool firstPlayer)
kartsAreaWidget->m_y + kartsAreaWidget->m_h);
// ---- Create new active player
PlayerProfile* profile_to_use = PlayerManager::get()->getCurrentPlayer();
PlayerProfile* profile_to_use = PlayerManager::getCurrentPlayer();
if (!firstPlayer)
{
@ -2013,7 +2013,7 @@ void KartSelectionScreen::setKartsFromCurrentGroup()
{
const KartProperties* prop =
kart_properties_manager->getKartById(n);
if (PlayerManager::get()->getCurrentPlayer()->isLocked(prop->getIdent()))
if (PlayerManager::getCurrentPlayer()->isLocked(prop->getIdent()))
{
w->addItem(
_("Locked : solve active challenges to gain access "
@ -2045,7 +2045,7 @@ void KartSelectionScreen::setKartsFromCurrentGroup()
kart_properties_manager->getKartById(group[n]);
const std::string &icon_path = prop->getAbsoluteIconFile();
if (PlayerManager::get()->getCurrentPlayer()->isLocked(prop->getIdent()))
if (PlayerManager::getCurrentPlayer()->isLocked(prop->getIdent()))
{
w->addItem(
_("Locked : solve active challenges to gain access "

4
src/states_screens/main_menu_screen.cpp
View File

@ -341,7 +341,7 @@ void MainMenuScreen::eventCallback(Widget* widget, const std::string& name,
InputDevice* device = input_manager->getDeviceList()->getKeyboard(0);
// Create player and associate player with keyboard
StateManager::get()->createActivePlayer(PlayerManager::get()->getCurrentPlayer(),
StateManager::get()->createActivePlayer(PlayerManager::getCurrentPlayer(),
device, NULL);
if (kart_properties_manager->getKart(UserConfigParams::m_default_kart) == NULL)
@ -364,7 +364,7 @@ void MainMenuScreen::eventCallback(Widget* widget, const std::string& name,
}
else if (selection == "story")
{
PlayerProfile *player = PlayerManager::get()->getCurrentPlayer();
PlayerProfile *player = PlayerManager::getCurrentPlayer();
if (player->isFirstTime())
{
StateManager::get()->enterGameState();

2
src/states_screens/online_profile_achievements.cpp
View File

@ -97,7 +97,7 @@ void OnlineProfileAchievements::init()
m_waiting_for_achievements = false;
m_achievements_list_widget->clear();
const std::map<uint32_t, Achievement *> & all_achievements =
PlayerManager::get()->getCurrentPlayer()->getAchievementsStatus()
PlayerManager::getCurrentPlayer()->getAchievementsStatus()
->getAllAchievements();
std::map<uint32_t, Achievement *>::const_iterator it;
for (it = all_achievements.begin(); it != all_achievements.end(); ++it)

119
src/states_screens/online_screen.cpp
View File

@ -29,24 +29,21 @@
#include "input/input_manager.hpp"
#include "io/file_manager.hpp"
#include "main_loop.hpp"
#include "modes/demo_world.hpp"
#include "network/protocol_manager.hpp"
#include "network/protocol_manager.hpp"
#include "network/protocols/connect_to_server.hpp"
#include "network/protocols/request_connection.hpp"
#include "online/messages.hpp"
#include "online/profile_manager.hpp"
#include "online/request.hpp"
#include "online/servers_manager.hpp"
#include "states_screens/state_manager.hpp"
#include "states_screens/dialogs/message_dialog.hpp"
#include "states_screens/networking_lobby.hpp"
#include "states_screens/server_selection.hpp"
#include "states_screens/create_server_screen.hpp"
#include "states_screens/online_profile_overview.hpp"
#include "online/servers_manager.hpp"
#include "online/messages.hpp"
#include "online/profile_manager.hpp"
#include "online/request.hpp"
#include "modes/demo_world.hpp"
#include "network/protocol_manager.hpp"
#include "network/protocols/connect_to_server.hpp"
#include "network/protocol_manager.hpp"
#include "network/protocols/connect_to_server.hpp"
using namespace GUIEngine;
using namespace Online;
@ -95,6 +92,8 @@ void OnlineScreen::loadedFromFile()
} // loadedFromFile
// ----------------------------------------------------------------------------
/** Checks if the recorded state differs from the actual state and sets it.
*/
bool OnlineScreen::hasStateChanged()
{
CurrentUser::UserState previous_state = m_recorded_state;
@ -102,7 +101,7 @@ bool OnlineScreen::hasStateChanged()
if (previous_state != m_recorded_state)
return true;
return false;
}
} // hasStateChanged
// ----------------------------------------------------------------------------
void OnlineScreen::beforeAddingWidget()
@ -130,15 +129,14 @@ void OnlineScreen::beforeAddingWidget()
} // beforeAddingWidget
// ----------------------------------------------------------------------------
void OnlineScreen::init()
{
Screen::init();
setInitialFocus();
DemoWorld::resetIdleTime();
m_online_status_widget->setText(Messages::signedInAs(CurrentUser::get()->getUserName()), false);
core::stringw m = _("Signed in as: %s.",CurrentUser::get()->getUserName());
m_online_status_widget->setText(m, false);
} // init
// ----------------------------------------------------------------------------
@ -161,8 +159,57 @@ void OnlineScreen::onUpdate(float delta)
} // onUpdate
// ----------------------------------------------------------------------------
/** Executes the quick play selection. Atm this is all blocking.
*/
void OnlineScreen::doQuickPlay()
{
// Refresh server list.
HTTPRequest* request = ServersManager::get()->refreshRequest(false);
if (request != NULL) // consider request done
{
request->executeNow();
delete request;
}
else
{
Log::error("OnlineScreen", "Could not get the server list.");
return;
}
// select first one
const Server * server = ServersManager::get()->getQuickPlay();
void OnlineScreen::eventCallback(Widget* widget, const std::string& name, const int playerID)
XMLRequest *request2 = new RequestConnection::ServerJoinRequest();
if (!request2)
{
sfx_manager->quickSound("anvil");
return;
}
CurrentUser::setUserDetails(request2, "request-connection");
request2->setServerURL("address-management.php");
request2->addParameter("server_id", server->getServerId());
request2->executeNow();
if (request2->isSuccess())
{
delete request2;
StateManager::get()->pushScreen(NetworkingLobby::getInstance());
ConnectToServer *cts = new ConnectToServer(server->getServerId(),
server->getHostId());
ProtocolManager::getInstance()->requestStart(cts);
}
else
{
sfx_manager->quickSound("anvil");
}
} // doQuickPlay
// ----------------------------------------------------------------------------
void OnlineScreen::eventCallback(Widget* widget, const std::string& name,
const int playerID)
{
if (name == m_back_widget->m_properties[PROP_ID])
{
@ -194,41 +241,7 @@ void OnlineScreen::eventCallback(Widget* widget, const std::string& name, const
}
else if (selection == m_quick_play_widget->m_properties[PROP_ID])
{
//FIXME temporary and the request join + join sequence should be placed in one method somewhere
// refresh server list
Online::ServersManager::RefreshRequest* request = ServersManager::get()->refreshRequest(false);
if (request != NULL) // consider request done
{
request->executeNow();
delete request;
}
else
{
Log::error("OnlineScreen", "Could not get the server list.");
return;
}
// select first one
const Server * server = ServersManager::get()->getQuickPlay();
Online::CurrentUser::ServerJoinRequest* request2 = Online::CurrentUser::get()->requestServerJoin( server->getServerId(), false);
if (request2)
{
request2->executeNow();
if (request2->isSuccess())
{
delete request2;
StateManager::get()->pushScreen(NetworkingLobby::getInstance());
ProtocolManager::getInstance()->requestStart(new ConnectToServer(server->getServerId(), server->getHostId()));
}
else
{
sfx_manager->quickSound( "anvil" );
}
}
else
{
sfx_manager->quickSound( "anvil" );
}
doQuickPlay();
}
} // eventCallback
@ -239,6 +252,8 @@ void OnlineScreen::tearDown()
}
// ----------------------------------------------------------------------------
/** Sets which widget has to be focused. Depends on the user state.
*/
void OnlineScreen::setInitialFocus()
{
if(m_recorded_state == CurrentUser::US_SIGNED_IN)

3
src/states_screens/online_screen.hpp
View File

@ -56,11 +56,10 @@ private:
Online::CurrentUser::UserState m_recorded_state;
/** \brief Checks if the recorded state differs from the actual state and sets it. */
bool hasStateChanged();
/** \brief Sets which widget has to be focused. Depends on the user state. */
void setInitialFocus();
void doQuickPlay();
public:
virtual void onUpdate(float delta) OVERRIDE;

2
src/states_screens/options_screen_players.cpp
View File

@ -80,7 +80,7 @@ void OptionsScreenPlayers::init()
refreshPlayerList();
ButtonWidget* you = getWidget<ButtonWidget>("playername");
unsigned int playerID = PlayerManager::get()->getCurrentPlayer()->getUniqueID();
unsigned int playerID = PlayerManager::getCurrentPlayer()->getUniqueID();
core::stringw player_name = L"-";
const PlayerProfile* curr = PlayerManager::get()->getPlayerById(playerID);
if(curr)

4
src/states_screens/race_gui_overworld.cpp
View File

@ -207,7 +207,7 @@ void RaceGUIOverworld::renderPlayerView(const Camera *camera, float dt)
*/
void RaceGUIOverworld::drawTrophyPoints()
{
PlayerProfile *player = PlayerManager::get()->getCurrentPlayer();
PlayerProfile *player = PlayerManager::getCurrentPlayer();
const int points = player->getPoints();
std::string s = StringUtils::toString(points);
core::stringw sw(s.c_str());
@ -398,7 +398,7 @@ void RaceGUIOverworld::drawGlobalMiniMap()
// bool locked = (m_locked_challenges.find(c) != m_locked_challenges.end());
int state = (challenges[n].getForceField().m_is_locked ? LOCKED : OPEN);
const ChallengeStatus* c = PlayerManager::get()->getCurrentPlayer()
const ChallengeStatus* c = PlayerManager::getCurrentPlayer()
->getChallengeStatus(challenges[n].m_challenge_id);
if (c->isSolved(RaceManager::DIFFICULTY_HARD)) state = COMPLETED_HARD;
else if (c->isSolved(RaceManager::DIFFICULTY_MEDIUM)) state = COMPLETED_MEDIUM;

8
src/states_screens/race_result_gui.cpp
View File

@ -157,7 +157,7 @@ void RaceResultGUI::enableAllButtons()
// If something was unlocked
// -------------------------
int n = PlayerManager::get()->getCurrentPlayer()->getRecentlyCompletedChallenges().size();
int n = PlayerManager::getCurrentPlayer()->getRecentlyCompletedChallenges().size();
if(n>0)
{
top->setText(n==1 ? _("You completed a challenge!")
@ -226,7 +226,7 @@ void RaceResultGUI::eventCallback(GUIEngine::Widget* widget,
// If something was unlocked, the 'continue' button was
// actually used to display "Show unlocked feature(s)" text.
// ---------------------------------------------------------
int n = PlayerManager::get()->getCurrentPlayer()
int n = PlayerManager::getCurrentPlayer()
->getRecentlyCompletedChallenges().size();
if(n>0)
{
@ -238,7 +238,7 @@ void RaceResultGUI::eventCallback(GUIEngine::Widget* widget,
}
std::vector<const ChallengeData*> unlocked =
PlayerManager::get()->getCurrentPlayer()->getRecentlyCompletedChallenges();
PlayerManager::getCurrentPlayer()->getRecentlyCompletedChallenges();
bool gameCompleted = false;
for (unsigned int n = 0; n < unlocked.size(); n++)
@ -250,7 +250,7 @@ void RaceResultGUI::eventCallback(GUIEngine::Widget* widget,
}
}
PlayerManager::get()->getCurrentPlayer()->clearUnlocked();
PlayerManager::getCurrentPlayer()->clearUnlocked();
if (gameCompleted)
{

8
src/states_screens/race_setup_screen.cpp
View File

@ -180,7 +180,7 @@ void RaceSetupScreen::assignDifficulty()
}
else if (difficultySelection == "best")
{
if (PlayerManager::get()->getCurrentPlayer()->isLocked("difficulty_best"))
if (PlayerManager::getCurrentPlayer()->isLocked("difficulty_best"))
{
unlock_manager->playLockSound();
UserConfigParams::m_difficulty = RaceManager::DIFFICULTY_HARD;
@ -231,7 +231,7 @@ void RaceSetupScreen::init()
assert( w != NULL );
if (UserConfigParams::m_difficulty == RaceManager::DIFFICULTY_BEST &&
PlayerManager::get()->getCurrentPlayer()->isLocked("difficulty_best"))
PlayerManager::getCurrentPlayer()->isLocked("difficulty_best"))
{
w->setSelection(RaceManager::DIFFICULTY_HARD, PLAYER_ID_GAME_MASTER);
}
@ -269,7 +269,7 @@ void RaceSetupScreen::init()
name2 += _("Contains no powerups, so only your driving skills matter!");
w2->addItem( name2, IDENT_TTRIAL, RaceManager::getIconOf(RaceManager::MINOR_MODE_TIME_TRIAL));
if (PlayerManager::get()->getCurrentPlayer()->isLocked(IDENT_FTL))
if (PlayerManager::getCurrentPlayer()->isLocked(IDENT_FTL))
{
w2->addItem( _("Locked : solve active challenges to gain access to more!"),
"locked", RaceManager::getIconOf(RaceManager::MINOR_MODE_FOLLOW_LEADER), true);
@ -345,7 +345,7 @@ void RaceSetupScreen::init()
w2->registerHoverListener(m_mode_listener);
if (PlayerManager::get()->getCurrentPlayer()->isLocked("difficulty_best"))
if (PlayerManager::getCurrentPlayer()->isLocked("difficulty_best"))
{
RibbonWidget* w = getWidget<RibbonWidget>("difficulty");
assert(w != NULL);

2
src/states_screens/story_mode_lobby.cpp
View File

@ -55,7 +55,7 @@ void StoryModeLobbyScreen::init()
ListWidget* list = getWidget<ListWidget>("gameslots");
list->clear();
PlayerProfile *player = PlayerManager::get()->getCurrentPlayer();
PlayerProfile *player = PlayerManager::getCurrentPlayer();
if(player)
{
StateManager::get()->resetAndGoToScreen(MainMenuScreen::getInstance());

6
src/states_screens/tracks_screen.cpp
View File

@ -238,7 +238,7 @@ void TracksScreen::init()
sshot_files.push_back("gui/main_help.png");
}
if (PlayerManager::get()->getCurrentPlayer()->isLocked(gp->getId()))
if (PlayerManager::getCurrentPlayer()->isLocked(gp->getId()))
{
gps_widget->addAnimatedItem(_("Locked!"),
"locked", sshot_files, 1.5f, LOCKED_BADGE | TROPHY_BADGE,
@ -303,7 +303,7 @@ void TracksScreen::buildTrackList()
if (curr->isArena() || curr->isSoccer()) continue;
if (curr->isInternal()) continue;
if(PlayerManager::get()->getCurrentPlayer()->isLocked(curr->getIdent()))
if(PlayerManager::getCurrentPlayer()->isLocked(curr->getIdent()))
{
tracks_widget->addItem( _("Locked : solve active challenges to gain access to more!"),
"locked", curr->getScreenshotFile(), LOCKED_BADGE,
@ -334,7 +334,7 @@ void TracksScreen::buildTrackList()
if (curr->isSoccer()) continue;
if (curr->isInternal()) continue;
if (PlayerManager::get()->getCurrentPlayer()->isLocked(curr->getIdent()))
if (PlayerManager::getCurrentPlayer()->isLocked(curr->getIdent()))
{
tracks_widget->addItem( _("Locked : solve active challenges to gain access to more!"),
"locked", curr->getScreenshotFile(), LOCKED_BADGE,

4
src/tracks/track.cpp
View File

@ -156,7 +156,7 @@ Track::~Track()
unsigned int Track::getNumOfCompletedChallenges()
{
unsigned int unlocked_challenges = 0;
PlayerProfile *player = PlayerManager::get()->getCurrentPlayer();
PlayerProfile *player = PlayerManager::getCurrentPlayer();
for (unsigned int i=0; i<m_challenges.size(); i++)
{
if (m_challenges[i].m_challenge_id == "tutorial")
@ -975,7 +975,7 @@ bool Track::loadMainTrack(const XMLNode &root)
}
const unsigned int val = challenge->getNumTrophies();
bool shown = (PlayerManager::get()->getCurrentPlayer()->getPoints() < val);
bool shown = (PlayerManager::getCurrentPlayer()->getPoints() < val);
m_force_fields.push_back(OverworldForceField(xyz, shown, val));
m_challenges[closest_challenge_id].setForceField(