src/engine/ePlayer.h

Go to the documentation of this file.

/*
 
*************************************************************************
 
ArmageTron -- Just another Tron Lightcycle Game in 3D.
Copyright (C) 2000  Manuel Moos (manuel@moosnet.de)
 
**************************************************************************
 
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 2
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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  
***************************************************************************
 
*/

#ifndef ArmageTron_PLAYER_H
#define ArmageTron_PLAYER_H

#ifndef MAX_INSTANT_CHAT
#define MAX_INSTANT_CHAT 26
#endif

#define MAX_PLAYERS 4

#include "rSDL.h"

#include "uInput.h"
#include "tList.h"
#include "tString.h"
#include "eCamera.h"
#include "eNetGameObject.h"
#include "tCallbackString.h"
#include "nSpamProtection.h"

#include <set>

#define PLAYER_CONFITEMS (30+MAX_INSTANT_CHAT)

class tConfItemBase;
class uAction;
class tOutput;
class eTeam;
class eVoter;

class eCockpitPrototype : public tReferencable<eCockpitPrototype> {
public:
    virtual ~eCockpitPrototype(){};
};

class ePlayer: public uPlayerPrototype{
    friend class eMenuItemChat;
    static uActionPlayer s_chat;

    tConfItemBase *configuration[PLAYER_CONFITEMS];
    int            CurrentConfitem;
    void   StoreConfitem(tConfItemBase *c);
    void   DeleteConfitems();
public:
    tString    name;                 // the player's screen name
    tString    globalID;             // the global ID of the player in user@authority form
    // REAL        rubberstatus;
    tString     teamname;
    bool       centerIncamOnTurn;
    bool       wobbleIncam;
    bool       autoSwitchIncam;

    bool       spectate;              // shall this player always spectate?
    bool       stealth;               // does this player wish to hide his/her identity?
    bool       autoLogin;             // should the player always request authentication on servers?

    bool                nameTeamAfterMe; // player prefers to call his team after his name
    int                 favoriteNumberOfPlayersPerTeam;

    eCamMode startCamera;
    bool     allowCam[CAMERA_COUNT];
    int      startFOV;
    bool     smartCustomGlance; 

    tCHECKED_PTR(eCamera)           cam;
    tCONTROLLED_PTR(ePlayerNetID) netPlayer;
    tJUST_CONTROLLED_PTR<eCockpitPrototype>     cockpit;

    int rgb[3]; // our color

    tString instantChatString[MAX_INSTANT_CHAT];
    // instant chat macros

    static uActionPlayer *se_instantChatAction[MAX_INSTANT_CHAT];

    ePlayer();
    virtual ~ePlayer();

    virtual const char *Name() const{return name;}
    virtual const char *Teamname() const{return teamname;}

    virtual bool Act(uAction *act,REAL x);

    int ID() const {return id;};
#ifndef DEDICATED
    void Render();
#endif

    static ePlayer * PlayerConfig(int p);

    static bool PlayerIsInGame(int p);

    static rViewport * PlayerViewport(int p);

    static void LogIn();          
    static void SendAuthNames();  

    static void Init();
    static void Exit();
};

class eAccessLevelHolder
{
public:
    eAccessLevelHolder();

    tAccessLevel GetAccessLevel() const { return accessLevel; }
    void SetAccessLevel( tAccessLevel level );

private:
    tAccessLevel     accessLevel;    
};

// the class that identifies players across the network
class ePlayerNetID: public nNetObject, public eAccessLevelHolder{
    friend class ePlayer;
    friend class eTeam;
    friend class eNetGameObject;
    friend class tControlledPTR< ePlayerNetID >;
    // access level. lower numeric values are better.
public:
    typedef std::set< eTeam * > eTeamSet;
private:

    int listID;                          // ID in the list of all players
    int teamListID;                      // ID in the list of the team

    bool                                                        silenced_;              // flag indicating whether the player has been silenced
    int                             suspended_;     

    nTimeAbsolute                                       timeJoinedTeam; // the time the player joined the team he is in now
    tCONTROLLED_PTR(eTeam)                      nextTeam;               // the team we're in ( logically )
    tCONTROLLED_PTR(eTeam)                      currentTeam;    // the team we currently are spawned for
    eTeamSet                        invitations_;   // teams this player is invited to
    tCONTROLLED_PTR(eVoter)                     voter_;                 // voter assigned to this player

    tCHECKED_PTR(eNetGameObject) object; // the object this player is
    // controlling

    int score; // points made so far
    int lastScore_; // last saved score

    int favoriteNumberOfPlayersPerTeam;         // join team if number of players on it is less than this; create new team otherwise
    bool nameTeamAfterMe;                                       // player prefers to call his team after his name
    bool greeted;                                               // did the server already greet him?
    bool disconnected;                                          // did he disconnect from the game?

    static void SwapPlayersNo(int a,int b); // swaps the players a and b

    ePlayerNetID& operator= (const ePlayerNetID&); // forbid copy constructor

    bool                        spectating_; 
    bool                        stealth_; 
    bool                        chatting_;   
    int                         chatFlags_;  
    bool                        allowTeamChange_; 

    //For improved remoteadmin
    tAccessLevel     lastAccessLevel;

    nMachine *      registeredMachine_; 
    void RegisterWithMachine();         
    void UnregisterWithMachine();       
public:
    enum                        ChatFlags
    {
        ChatFlags_Chat = 1,
        ChatFlags_Away = 2,
        ChatFlags_Menu = 4,
        ChatFlags_Console = 4
    };

    int    pID;
    tString teamname;
    // REAL     rubberstatus;
    tArray<tString> lastSaid;
    tArray<nTimeRolling> lastSaidTimes;
    //  void SetLastSaid(tString ls);
    unsigned short r,g,b; // our color

    unsigned short pingCharity; // max ping you are willing to take over

    REAL ping;

    double lastSync;         
    double lastActivity_;    

    bool loginWanted;        

    nSpamProtection chatSpam_;

    ePlayerNetID(int p=-1);
    ePlayerNetID(nMessage &m);
    virtual ~ePlayerNetID();

    virtual bool ActionOnQuit();
    virtual void ActionOnDelete();

    // chatting
    bool IsChatting() const { return chatting_; }
    void SetChatting ( ChatFlags flag, bool chatting );

    // spectating
    bool IsSpectating() const { return spectating_; }

    bool StealthMode() const { return stealth_; }

    // team management
    bool TeamChangeAllowed( bool informPlayer = false ) const; 
    void SetTeamChangeAllowed(bool allowed) {allowTeamChange_ = allowed;} 

    eTeam* NextTeam()    const { return nextTeam; }             // return the team I will be next round
    eTeam* CurrentTeam() const { return currentTeam; }  // return the team I am in
    int  TeamListID() const { return teamListID; }              // return my position in the team
    eTeam* FindDefaultTeam();                                   // find a good default team for us
    void SetDefaultTeam();                                              // register me in a good default team
    void SetTeamForce(eTeam* team );            // register me in the given team without checks
    void SetTeam(eTeam* team);                          // register me in the given team (callable on the server)
    void SetTeamWish(eTeam* team);                              // express the wish to be part of the given team (always callable)
    void SetTeamname(const char *);                             // set teamname to be used for my own team
    void UpdateTeamForce();                                             // update team membership without checks
    void UpdateTeam();                                                  // update team membership

    eTeamSet const & GetInvitations() const ;   

    void CreateNewTeam();                                       // create a new team and join it (on the server)
    void CreateNewTeamWish();                                   // express the wish to create a new team and join it
    virtual void ReceiveControlNet(nMessage &m);// receive the team control wish

    static bool Enemies( ePlayerNetID const * a, ePlayerNetID const * b ); 

    // print out an understandable name in to s
    virtual void                        PrintName(tString &s) const;

    virtual bool                        AcceptClientSync() const;
    virtual void                        WriteSync(nMessage &m);
    virtual void                        ReadSync(nMessage &m);
    virtual nDescriptor&        CreatorDescriptor() const;
    virtual void                        InitAfterCreation();
    virtual bool                        ClearToTransmit(int user) const;

    virtual void                        NewObject(){}                                   // called when we control a new object
    virtual void                        RightBeforeDeath(int triesLeft){}       // is called right before the vehicle gets destroyed.


    void RemoveFromGame();
    virtual void ControlObject(eNetGameObject *c);
    virtual void ClearObject();

    void Greet();

    // suspend the player from playing, forcing him to spectate
    void Suspend( int rounds = 5 );
#ifdef KRAWALL_SERVER
    void Authenticate( tString const & authName, 
                       tAccessLevel accessLevel = tAccessLevel_Authenticated,
                       ePlayerNetID const * admin = 0 );    
    void DeAuthenticate( ePlayerNetID const * admin = 0 );  
    bool IsAuthenticated() const;                     
#endif

    static void RequestScheduledLogins();  

    bool IsActive() const { return !disconnected; }

    bool IsSilenced( void ) const { return silenced_; }
    void SetSilenced( bool silenced ) { silenced_ = silenced; }
    bool& AccessSilenced( void ) { return silenced_; }

    eVoter * GetVoter() const {return voter_;}     // returns our voter
    void CreateVoter();                                         // create our voter or find it
    static void SilenceMenu();                          // menu where you can silence players
    static void PoliceMenu();                           // menu where you can silence and kick players

    virtual bool IsHuman() const { return true; }

    void Activity(); // call it if this player just showed some activity.
    REAL LastActivity() const; 

    eNetGameObject *Object() const;

    // void SetRubber(REAL rubber2);
    void AddScore(int points, const tOutput& reasonwin, const tOutput& reasonlose);
    int Score()const {return score;}
    int TotalScore() const;
    static void ResetScoreDifferences(); //<! Resets the last stored score so ScoreDifferences takes this as a reference time
    static void LogScoreDifferences();   //<! Logs accumulated scores of all players since the last call to ResetScoreDifferences() to ladderlog.txt
    void LogScoreDifference();           //<! Logs accumulated scores since the last call to ResetScoreDifferences() to ladderlog.txt

    static void SortByScore(); // brings the players into the right order
    static tString Ranking( int MAX=12, bool cut = true );     // returns a ranking list

    static float RankingGraph( float y, int MAX );     // prints a ranking list

    static void RankingLadderLog();     // writes a small ranking list to ladderlog

    static void  ResetScore();  // resets the ranking list

    static void DisplayScores(); // display scores on the screen

    void GreetHighscores(tString &s); // tell him his positions in the
    // highscore lists (defined in game.cpp)

    static void Update();           // creates ePlayerNetIDs for new players
    // and destroys those of players that have left

#ifdef KRAWALL_SERVER
    static tAccessLevel AccessLevelRequiredToPlay(); // is authentication required to play on this server?
#endif

    static bool WaitToLeaveChat(); 

    static void RemoveChatbots(); 

    static void CompleteRebuild(); // same as above, but rebuilds every ePlayerNetID.
    static void ClearAll(); // deletes all ePlayerNetIDs.
    static void SpectateAll( bool spectate=true ); // puts all players into spectator mode.

    static void ThrowOutDisconnected(); // get rid of everyone that disconnected from the game

    void GetScoreFromDisconnectedCopy(); // get the player's data from the previous login

    void Chat(const tString &s);

    virtual void Color( REAL&r, REAL&g, REAL&b ) const;
    virtual void TrailColor( REAL&r, REAL&g, REAL&b ) const;

    //Remote Admin add-ins...
    bool IsLoggedIn() const { return GetAccessLevel() < tAccessLevel_Moderator; }
    void BeLoggedIn() { SetAccessLevel( tAccessLevel_Admin ); }
    void BeNotLoggedIn() { SetAccessLevel( tAccessLevel_Program ); }
    tAccessLevel GetLastAccessLevel() const { return lastAccessLevel; }

    static ePlayerNetID * FindPlayerByName( tString const & name, ePlayerNetID * requester = 0 ); 

    void UpdateName();                                           
    static void FilterName( tString const & in, tString & out ); 
    static tString FilterName( tString const & in );             
private:
    tColoredString  nameFromClient_;        
    tColoredString  nameFromServer_;        
    tColoredString  coloredName_;           
    tString         name_;                  
    tString         userName_;              

#ifdef KRAWALL_SERVER
    tString         rawAuthenticatedName_;  
#endif

    REAL            wait_;                  

    void                        MyInitAfterCreation();

protected:
    virtual nMachine & DoGetMachine() const;  

    // private:
    //  virtual void AddRef();
    //  virtual void Release();

    // accessors
public:
    inline tColoredString const & GetNameFromClient( void ) const;      
    inline ePlayerNetID const & GetNameFromClient( tColoredString & nameFromClient ) const;     
    inline tColoredString const & GetColoredName( void ) const; 
    inline ePlayerNetID const & GetColoredName( tColoredString & coloredName ) const;   
    inline tString const & GetName( void ) const;       
    inline ePlayerNetID const & GetName( tString & name ) const;        

    inline tString const & GetUserName( void ) const;   
    inline ePlayerNetID const & GetUserName( tString & userName ) const;        

    tString const & GetLogName( void ) const{ return GetUserName(); }   
    tString GetFilteredAuthenticatedName( void ) const; 
#ifdef KRAWALL_SERVER
    tString const & GetRawAuthenticatedName( void ) const{ return rawAuthenticatedName_; }      
    void SetRawAuthenticatedName( tString const & name ){ if ( !IsAuthenticated()) rawAuthenticatedName_ = name; }      
#endif

    ePlayerNetID & SetName( tString const & name ); 
    ePlayerNetID & SetName( char    const * name ); 
    inline ePlayerNetID & SetUserName( tString const & userName );  
private:
    inline ePlayerNetID & SetNameFromClient( tColoredString const & nameFromClient );   
    inline ePlayerNetID & SetColoredName( tColoredString const & coloredName ); 

    int & AccessSuspended();

    int GetSuspended() const;
};

extern tList<ePlayerNetID> se_PlayerNetIDs;
extern int    sr_viewportBelongsToPlayer[MAX_VIEWPORTS];
extern bool se_assignTeamAutomatically;

void se_ChatState( ePlayerNetID::ChatFlags flag, bool cs);

void se_SaveToScoreFile( tOutput const & out );  
void se_SaveToLadderLog( tOutput const & out );  

tColoredString & operator << (tColoredString &s,const ePlayer &p);
tColoredString & operator << (tColoredString &s,const ePlayerNetID &p);

extern int pingCharity;

void se_AutoShowScores(); // show scores based on automated decision
void se_UserShowScores(bool show); // show scores based on user input
void se_SetShowScoresAuto(bool a); // disable/enable auto show scores

//Password stuff
void se_DeletePasswords();
extern int se_PasswordStorageMode; // 0: store in memory, -1: don't store, 1: store on file

tOutput& operator << (tOutput& o, const ePlayerNetID& p);

// greeting callback
class eCallbackGreeting: public tCallbackString
{
    static tCallbackString *anchor;
    static ePlayerNetID* greeted;

public:
    static tString Greet(ePlayerNetID* player);
    static ePlayerNetID* Greeted(){return greeted;}

    eCallbackGreeting(STRINGRETFUNC* f);
};

extern int se_SpamMaxLen;       // maximal length of chat message


// ******************************************************************************************
// *
// *    GetNameFromClient
// *
// ******************************************************************************************
// ******************************************************************************************

tColoredString const & ePlayerNetID::GetNameFromClient( void ) const
{
    return this->nameFromClient_;
}

// ******************************************************************************************
// *
// *    GetNameFromClient
// *
// ******************************************************************************************
// ******************************************************************************************

ePlayerNetID const & ePlayerNetID::GetNameFromClient( tColoredString & nameFromClient ) const
{
    nameFromClient = this->nameFromClient_;
    return *this;
}

// ******************************************************************************************
// *
// *    SetNameFromClient
// *
// ******************************************************************************************
// ******************************************************************************************

ePlayerNetID & ePlayerNetID::SetNameFromClient( tColoredString const & nameFromClient )
{
    this->nameFromClient_ = nameFromClient;
    return *this;
}

// ******************************************************************************************
// *
// *    GetColoredName
// *
// ******************************************************************************************
// ******************************************************************************************

tColoredString const & ePlayerNetID::GetColoredName( void ) const
{
    return this->coloredName_;
}

// ******************************************************************************************
// *
// *    GetColoredName
// *
// ******************************************************************************************
// ******************************************************************************************

ePlayerNetID const & ePlayerNetID::GetColoredName( tColoredString & coloredName ) const
{
    coloredName = this->coloredName_;
    return *this;
}

// ******************************************************************************************
// *
// *    SetColoredName
// *
// ******************************************************************************************
// ******************************************************************************************

ePlayerNetID & ePlayerNetID::SetColoredName( tColoredString const & coloredName )
{
    this->coloredName_ = coloredName;
    return *this;
}

// ******************************************************************************************
// *
// *    GetName
// *
// ******************************************************************************************
// ******************************************************************************************

tString const & ePlayerNetID::GetName( void ) const
{
    return this->name_;
}

// ******************************************************************************************
// *
// *    GetName
// *
// ******************************************************************************************
// ******************************************************************************************

ePlayerNetID const & ePlayerNetID::GetName( tString & name ) const
{
    name = this->name_;
    return *this;
}

// ******************************************************************************************
// *
// *    GetUserName
// *
// ******************************************************************************************
// ******************************************************************************************

tString const & ePlayerNetID::GetUserName( void ) const
{
    return this->userName_;
}

// ******************************************************************************************
// *
// *    GetUserName
// *
// ******************************************************************************************
// ******************************************************************************************

ePlayerNetID const & ePlayerNetID::GetUserName( tString & userName ) const
{
    userName = this->userName_;
    return *this;
}

// ******************************************************************************************
// *
// *    SetUserName
// *
// ******************************************************************************************
// ******************************************************************************************

ePlayerNetID & ePlayerNetID::SetUserName( tString const & userName )
{
    this->userName_ = userName;
    return *this;
}

#endif

---