292 lines
11 KiB
C++
292 lines
11 KiB
C++
//
|
|
// SuperTuxKart - a fun racing game with go-kart
|
|
// Copyright (C) 2010-2013 SuperTuxKart-Team
|
|
//
|
|
// This program is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU General Public License
|
|
// as published by the Free Software Foundation; either version 3
|
|
// of the License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program; if not, write to the Free Software
|
|
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
#ifndef HEADER_PLAYER_PROFILE_HPP
|
|
#define HEADER_PLAYER_PROFILE_HPP
|
|
|
|
#include "challenges/story_mode_status.hpp"
|
|
#include "utils/leak_check.hpp"
|
|
#include "utils/no_copy.hpp"
|
|
#include "utils/types.hpp"
|
|
|
|
#include <irrString.h>
|
|
using namespace irr;
|
|
|
|
#include <string>
|
|
|
|
class AchievementsStatus;
|
|
namespace Online
|
|
{
|
|
class CurrentUser;
|
|
class HTTPRequest;
|
|
class OnlineProfile;
|
|
class XMLRequest;
|
|
}
|
|
class UTFWriter;
|
|
|
|
/** Class for managing player profiles (name, usage frequency,
|
|
* etc.). All PlayerProfiles are managed by the PlayerManager.
|
|
* A PlayerProfile keeps track of the story mode progress using an instance
|
|
* of StoryModeStatus, and achievements with AchievementsStatus. All data
|
|
* is saved in the players.xml file.
|
|
* This class also defines the interface for handling online data. All of
|
|
* the online handling is done in the derived class OnlinePlayerProfile,
|
|
* where the interface is fully implemented.
|
|
* \ingroup config
|
|
*/
|
|
class PlayerProfile : public NoCopy
|
|
{
|
|
public:
|
|
/** The online state a player can be in. */
|
|
enum OnlineState
|
|
{
|
|
OS_SIGNED_OUT = 0,
|
|
OS_SIGNED_IN,
|
|
OS_GUEST,
|
|
OS_SIGNING_IN,
|
|
OS_SIGNING_OUT
|
|
};
|
|
|
|
|
|
private:
|
|
LEAK_CHECK()
|
|
|
|
/** The name of the player (wide string, so it can be in native
|
|
* language). */
|
|
core::stringw m_local_name;
|
|
|
|
/** True if this account is a guest account. */
|
|
bool m_is_guest_account;
|
|
|
|
#ifdef DEBUG
|
|
unsigned int m_magic_number;
|
|
#endif
|
|
|
|
/** Counts how often this player was used (always -1 for guests). */
|
|
int m_use_frequency;
|
|
|
|
/** A unique number for this player, used to link it to challenges etc. */
|
|
unsigned int m_unique_id;
|
|
|
|
/** Absolute path of the icon file for this player. */
|
|
std::string m_icon_filename;
|
|
|
|
/** 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 online user name used last (empty if not used online). */
|
|
core::stringw m_last_online_name;
|
|
|
|
/** True if the last time this player was used as online. */
|
|
bool m_last_was_online;
|
|
|
|
/** True if the login data are saved. */
|
|
bool m_remember_password;
|
|
|
|
/** The complete challenge state. */
|
|
StoryModeStatus *m_story_mode_status;
|
|
|
|
AchievementsStatus *m_achievements_status;
|
|
|
|
public:
|
|
|
|
PlayerProfile(const core::stringw &name, bool is_guest = false);
|
|
PlayerProfile(const XMLNode *node);
|
|
virtual ~PlayerProfile();
|
|
void save(UTFWriter &out);
|
|
void loadRemainingData(const XMLNode *node);
|
|
void initRemainingData();
|
|
void incrementUseFrequency();
|
|
bool operator<(const PlayerProfile &other);
|
|
void raceFinished();
|
|
void saveSession(int user_id, const std::string &token);
|
|
void clearSession();
|
|
void addIcon();
|
|
|
|
/** Abstract virtual classes, to be implemented by the OnlinePlayer. */
|
|
virtual void setUserDetails(Online::HTTPRequest *request,
|
|
const std::string &action,
|
|
const std::string &url_path = "") const = 0;
|
|
virtual uint32_t getOnlineId() const = 0;
|
|
virtual PlayerProfile::OnlineState getOnlineState() const = 0;
|
|
virtual Online::OnlineProfile* getProfile() const = 0;
|
|
virtual void requestPoll() const = 0;
|
|
virtual void requestSavedSession() = 0;
|
|
virtual Online::XMLRequest* requestSignIn(const irr::core::stringw &username,
|
|
const irr::core::stringw &password) = 0;
|
|
virtual void signIn(bool success, const XMLNode * input) = 0;
|
|
virtual void signOut(bool success, const XMLNode * input,
|
|
const irr::core::stringw &info) = 0;
|
|
virtual void requestSignOut() = 0;
|
|
virtual bool isLoggedIn() const { return false; }
|
|
const std::string getIconFilename() const;
|
|
// ------------------------------------------------------------------------
|
|
/** Sets the name of this player. */
|
|
void setName(const core::stringw& name)
|
|
{
|
|
#ifdef DEBUG
|
|
assert(m_magic_number == 0xABCD1234);
|
|
#endif
|
|
m_local_name = name;
|
|
} // setName
|
|
|
|
// ------------------------------------------------------------------------
|
|
/** Returns the name of this player. */
|
|
core::stringw getName() const
|
|
{
|
|
assert(m_magic_number == 0xABCD1234);
|
|
return m_local_name.c_str();
|
|
} // getName
|
|
|
|
// ------------------------------------------------------------------------
|
|
/** Returns true if this player is a guest account. */
|
|
bool isGuestAccount() const
|
|
{
|
|
#ifdef DEBUG
|
|
assert(m_magic_number == 0xABCD1234);
|
|
#endif
|
|
return m_is_guest_account;
|
|
} // isGuestAccount
|
|
// ------------------------------------------------------------------------
|
|
/** Returns the last used online name. */
|
|
const core::stringw& getLastOnlineName() const
|
|
{
|
|
return m_last_online_name;
|
|
} // getLastOnlineName
|
|
// ------------------------------------------------------------------------
|
|
/** Sets the last used online name. */
|
|
void setLastOnlineName(const core::stringw &name)
|
|
{
|
|
m_last_online_name = name;
|
|
} // setLastOnlineName
|
|
// ------------------------------------------------------------------------
|
|
/** Returns the unique id of this player. */
|
|
unsigned int getUniqueID() const { return m_unique_id; }
|
|
// ------------------------------------------------------------------------
|
|
/** Returnes if the feature (kart, track) is locked. */
|
|
bool isLocked(const std::string &feature) const
|
|
{
|
|
return m_story_mode_status->isLocked(feature);
|
|
} // isLocked
|
|
// ------------------------------------------------------------------------
|
|
/** Returns all active challenges. */
|
|
void computeActive() { m_story_mode_status->computeActive(); }
|
|
// ------------------------------------------------------------------------
|
|
/** Returns the list of recently completed challenges. */
|
|
std::vector<const ChallengeData*> getRecentlyCompletedChallenges()
|
|
{
|
|
return m_story_mode_status->getRecentlyCompletedChallenges();
|
|
} // getRecently Completed Challenges
|
|
// ------------------------------------------------------------------------
|
|
/** Sets the currently active challenge. */
|
|
void setCurrentChallenge(const std::string &name)
|
|
{
|
|
m_story_mode_status->setCurrentChallenge(name);
|
|
} // setCurrentChallenge
|
|
// ------------------------------------------------------------------------
|
|
/** Callback when a GP is finished (to test if a challenge was
|
|
* fulfilled). */
|
|
void grandPrixFinished() { m_story_mode_status->grandPrixFinished(); }
|
|
// ------------------------------------------------------------------------
|
|
unsigned int getPoints() const { return m_story_mode_status->getPoints(); }
|
|
// ------------------------------------------------------------------------
|
|
void setFirstTime(bool b) { m_story_mode_status->setFirstTime(b); }
|
|
// ------------------------------------------------------------------------
|
|
bool isFirstTime() const { return m_story_mode_status->isFirstTime(); }
|
|
// ------------------------------------------------------------------------
|
|
void clearUnlocked()
|
|
{
|
|
m_story_mode_status->clearUnlocked();
|
|
}
|
|
// ------------------------------------------------------------------------
|
|
/** Returns the current challenge for this player. */
|
|
const ChallengeStatus* getCurrentChallengeStatus() const
|
|
{
|
|
return m_story_mode_status->getCurrentChallengeStatus();
|
|
} // getCurrentChallengeStatus
|
|
// ------------------------------------------------------------------------
|
|
const ChallengeStatus* getChallengeStatus(const std::string &id)
|
|
{
|
|
return m_story_mode_status->getChallengeStatus(id);
|
|
} // getChallengeStatus
|
|
// ------------------------------------------------------------------------
|
|
unsigned int getNumEasyTrophies() const
|
|
{
|
|
return m_story_mode_status->getNumEasyTrophies();
|
|
} // getNumEasyTrophies
|
|
// ------------------------------------------------------------------------
|
|
unsigned int getNumMediumTrophies() const
|
|
{
|
|
return m_story_mode_status->getNumMediumTrophies();
|
|
} // getNumEasyTrophies
|
|
// -----------------------------------------------------------------------
|
|
unsigned int getNumHardTrophies() const
|
|
{
|
|
return m_story_mode_status->getNumHardTrophies();
|
|
} // getNumHardTropies
|
|
// ------------------------------------------------------------------------
|
|
AchievementsStatus* getAchievementsStatus()
|
|
{
|
|
return m_achievements_status;
|
|
} // getAchievementsStatus
|
|
// ------------------------------------------------------------------------
|
|
/** Returns true if a session was saved for this player. */
|
|
bool hasSavedSession() const { return m_saved_session; }
|
|
// ------------------------------------------------------------------------
|
|
StoryModeStatus* getStoryModeStatus() { return m_story_mode_status; }
|
|
// ------------------------------------------------------------------------
|
|
/** 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
|
|
// ------------------------------------------------------------------------
|
|
/** Returns if the last time this player was used it was used online or
|
|
* offline. */
|
|
bool wasOnlineLastTime() const { return m_last_was_online; }
|
|
// ------------------------------------------------------------------------
|
|
/** Sets if this player was logged in last time it was used. */
|
|
void setWasOnlineLastTime(bool b) { m_last_was_online = b; }
|
|
// ------------------------------------------------------------------------
|
|
/** Returns if the last time this player was used it was used online or
|
|
* offline. */
|
|
bool rememberPassword() const { return m_remember_password; }
|
|
// ------------------------------------------------------------------------
|
|
/** Sets if this player was logged in last time it was used. */
|
|
void setRememberPassword(bool b) { m_remember_password = b; }
|
|
// ------------------------------------------------------------------------
|
|
}; // class PlayerProfile
|
|
|
|
#endif
|
|
|
|
/*EOF*/
|