Account.h

#ifndef ERIS_PLAYER_H
#define ERIS_PLAYER_H

#include <vector>
#include <map>

#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);
private:
    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

---