Account.h

#ifndef ERIS_PLAYER_H
#define ERIS_PLAYER_H

#include <vector>
#include <map>
#include <memory>

#include <Eris/Types.h>
#include <Eris/Timeout.h>
#include <sigc++/trackable.h>
#include <Atlas/Objects/ObjectsFwd.h>

namespace Eris
{

class Connection;
class Avatar;
class AccountRouter;

typedef std::map<std::string, Atlas::Objects::Entity::RootEntity> CharacterMap;

typedef std::map<std::string, Avatar*> ActiveCharacterMap;


class Account : virtual public sigc::trackable
{
public:

    Account(Connection *con);

     ~Account();


    Result login(const std::string &uname, const std::string &pwd);

    /* Create a new account on the server, if possible.
    Server-side failures, such as an account already existing with the specified
    username, will cause the 'LoginFailure' signal to be emitted with an error message
    and a code. As for 'login', LoginSuccess wil be emitted if everything goes as plan.

    @param uname The desired username of the account (eg 'ajr')
    @param fullName The real name of the user (e.g 'Al Riddoch')
    @param pwd The plaintext password for the new account
    */

    Result createAccount(const std::string &uname,
        const std::string &fullName,
        const std::string &pwd);


    Result logout();


    bool isLoggedIn() const;

    const std::vector< std::string > & getCharacterTypes(void) const;


    const CharacterMap& getCharacters();

    Result refreshCharacterInfo();


    Result takeCharacter(const std::string &id);

    Result createCharacter(const Atlas::Objects::Entity::RootEntity &character);

    //void createCharacter();

    bool canCreateCharacter() {return false;}

    const ActiveCharacterMap& getActiveCharacters() const
    { return m_activeCharacters; }

    Result deactivateCharacter(Avatar* av);

    const std::string& getId() const
    {
        return m_accountId;
    }

    const std::string& getUsername() const
    { return m_username; }

    Connection* getConnection() const
    {
        return m_con;
    }

// signals
    sigc::signal<void, const Atlas::Objects::Entity::RootEntity&> GotCharacterInfo;

    sigc::signal<void> GotAllCharacters;


    sigc::signal<void, const std::string &> LoginFailure;

    sigc::signal<void> LoginSuccess;


    sigc::signal<void, bool> LogoutComplete;

    sigc::signal<void, Avatar*> AvatarSuccess;

    sigc::signal<void, const std::string &> AvatarFailure;

    sigc::signal<void, Avatar*> AvatarDeactivated;
protected:
    friend class AccountRouter;
    friend class Avatar; // so avatar can call deactivateCharacter

    void sightCharacter(const Atlas::Objects::Operation::RootOperation& op);

    void loginComplete(const Atlas::Objects::Entity::Account &p);
    void loginError(const Atlas::Objects::Operation::Error& err);

    Result internalLogin(const std::string &unm, const std::string &pwd);
    void internalLogout(bool clean);

    void netConnected();

    bool netDisconnecting();
    void netFailure(const std::string& msg);

    void loginResponse(const Atlas::Objects::Operation::RootOperation& op);
    void logoutResponse(const Atlas::Objects::Operation::RootOperation& op);
    void avatarResponse(const Atlas::Objects::Operation::RootOperation& op);
    void avatarLogoutResponse(const Atlas::Objects::Operation::RootOperation& op);

    void handleLogoutTimeout();
//  void recvRemoteLogout(const Atlas::Objects::Operation::Logout &lo);

    void handleLoginTimeout();

    typedef enum
    {
        DISCONNECTED = 0,   
        LOGGING_IN,         
        LOGGED_IN,          
        LOGGING_OUT,         

        TAKING_CHAR,        
        CREATING_CHAR       
    } Status;

    void internalDeactivateCharacter(Avatar* av);
    void updateFromObject(const Atlas::Objects::Entity::Account &p);

    Connection* m_con;  
    Status m_status;    
    AccountRouter* m_router;

    std::string m_accountId;    
    std::string m_username; 
    std::string m_pass;

    std::vector< std::string > m_characterTypes;
    CharacterMap _characters;   
    StringSet m_characterIds;
    bool m_doingCharacterRefresh; 

    ActiveCharacterMap m_activeCharacters;
    std::auto_ptr<Timeout> m_timeout;
};

} // of namespace Eris

#endif

---