client.h

Go to the documentation of this file.

/*
 * client.h - Author: Keith Fulton
 *
 * Copyright (C) 2001 Atomic Blue ([email protected], http://www.atomicblue.org)
 *
 *
 * 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 (version 2 of the License)
 * 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 __CLIENT_H__
#define __CLIENT_H__

//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/ref.h>
#include <csutil/csstring.h>
#include <csutil/weakreferenced.h>

//=============================================================================
// Project Space Includes
//=============================================================================
#include "net/netbase.h"
#include "util/psconst.h"
#include "bulkobjects/buffable.h"

//=============================================================================
// Local Includes
//=============================================================================

class Client;
class psCharacter;
class gemObject;
class gemActor;
class gemNPC;
class psPath;

class FloodBuffRow
{
public:
    FloodBuffRow(uint8_t chtType, csString txt, csString rcpt, unsigned int newticks);
    FloodBuffRow() : chatType(0), ticks(0) {}
    uint8_t chatType;
    csString text;
    csString recipient;
    unsigned int ticks;
};

class MuteBuffable : public ClampedPositiveBuffable<int>
{
public:
    void Initialize(Client* c)
    {
        cli = c;
    }

protected:
    Client* cli;
    virtual void OnChange();
};

enum TARGET_TYPES
{
    TARGET_NONE     = 0x01, /* Also Area */
    TARGET_ITEM     = 0x04,
    TARGET_SELF     = 0x08,
    TARGET_FRIEND   = 0x10,
    TARGET_FOE      = 0x20,
    TARGET_DEAD     = 0x40
};

enum CheatFlags // will have more of these as Paladin gets better
{
    NO_CHEAT   = 0x00,
    MOVE_CHEAT = 0x01
};

struct OrderedMessageChannel;

class Client : protected NetBase::Connection, public CS::Utility::WeakReferenced
{
public:
    Client();


    ~Client();

    bool Initialize(LPSOCKADDR_IN addr, uint32_t clientnum);
    bool Disconnect();

    void SetAllowedToDisconnect(bool allowed);

    bool AllowDisconnect();

    bool ZombieAllowDisconnect();

    void SetMute(bool flag)
    {
        mute.SetBase(flag ? 1 : 0);
    }
    bool IsMute()
    {
        return (mute.Current() > 0);
    }
    MuteBuffable &GetBuffableMute()
    {
        return mute;
    }

    void SetName(const char* n);

    const char* GetName();

    // Additional Entity information
    void SetActor(gemActor* myactor);
    gemActor* GetActor() const
    {
        return actor;
    }
    psCharacter* GetCharacterData();

    // Get / Set Familiar information;
    void SetFamiliar(gemActor* familiar);
    gemActor* GetFamiliar();

    // Get / Set Pet information;
    void AddPet(gemActor* pet);
    void RemovePet(size_t index);
    gemActor* GetPet(size_t index);
    size_t GetNumPets();

    bool IsMyPet(gemActor* other) const;

    bool IsAlive() const;

    bool ValidateDistanceToTarget(float range);

    // Target information
    void SetTargetObject(gemObject* object, bool updateClientGUI=false);
    gemObject* GetTargetObject() const;

    // Targeted mesh information - i.e. for adding action locations
    void SetMesh(csString nextMesh)
    {
        mesh = nextMesh;
    }
    csString GetMesh() const
    {
        return mesh;
    }

    int GetTargetClientID();

    uint32_t GetClientNum() const
    {
        return clientnum;
    }

    AccountID GetAccountID()
    {
        return accountID;
    }
    void SetAccountID(AccountID id)
    {
        accountID = id;
    }

    PID GetPID()
    {
        return playerID;
    }
    void SetPID(PID id)
    {
        playerID = id;
    }

    int GetExchangeID()
    {
        return exchangeID;
    }
    void SetExchangeID(int ID)
    {
        exchangeID = ID;
    }

    int GetSecurityLevel() const
    {
        return securityLevel;
    }
    void SetSecurityLevel(int level)
    {
        securityLevel=level;
    }

    bool IsGM() const;

    int GetGuildID();
    int GetAllianceID();

    void SetReady(bool rdy)
    {
        ready = rdy;
    }
    bool IsReady()
    {
        return ready;
    }

    static void GetTargetTypeName(int32_t targetType, csString &targetDesc);

    bool IsZombie()
    {
        return zombie;
    }

    void SetSuperClient(bool flag)
    {
        superclient = flag;
    }
    bool IsSuperClient()
    {
        return superclient;
    }
    bool IsPlayerClient()
    {
        return (!superclient);
    }

    void GetIPAddress(char* addrStr, socklen_t size);
    csString GetIPAddress();

    csString GetIPRange(int octets=3);

    static csString GetIPRange(const char* ipaddr, int octets=3);

    NetBase::Connection* GetConnection() const
    {
        return (NetBase::Connection*)this;
    }

    const SOCKADDR_IN &GetAddress() const
    {
        return addr;
    }

    csRef<NetPacketQueueRefCount> outqueue;

    unsigned int GetAccountTotalOnlineTime();

    void AddDuelClient(uint32_t clientnum);
    void RemoveDuelClient(Client* client);
    void ClearAllDuelClients();
    int GetDuelClientCount();
    int GetDuelClient(int id);
    bool IsDuelClient(uint32_t clientnum);
    void AnnounceToDuelClients(gemActor* attacker, const char* event);

    void FloodControl(uint8_t chatType, const csString &newMessage, const csString &recipient);

    void SetAdvisorPoints(int p)
    {
        advisorPoints = p;
    }
    void IncrementAdvisorPoints(int n=1)
    {
        advisorPoints += n;
    }
    int GetAdvisorPoints()
    {
        return advisorPoints;
    }

    void SetAdvisor(bool advisor)
    {
        isAdvisor = advisor;
    }
    bool GetAdvisor()
    {
        return isAdvisor;
    }
    void SetAdvisorBan(bool ban);
    bool IsAdvisorBanned();

    csTicks accumulatedLag;

    // Invite flood control
    csTicks GetLastInviteTime()
    {
        return lastInviteTime;
    }
    void SetLastInviteTime(csTicks time)
    {
        lastInviteTime = time;
    }
    bool GetLastInviteResult()
    {
        return lastInviteResult;
    }
    void SetLastInviteResult(bool result)
    {
        lastInviteResult = result;
    }
    bool HasBeenWarned()
    {
        return hasBeenWarned;
    }
    void SetWarned()
    {
        hasBeenWarned = true;
    }
    bool HasBeenPenalized()
    {
        return hasBeenPenalized;
    }
    void SetPenalized(bool value)
    {
        hasBeenPenalized = value;
    }
    int GetSpamPoints()
    {
        return spamPoints;
    }
    void SetSpamPoints(int points)
    {
        spamPoints = points;    // For setting on account load
    }
    void IncrementSpamPoints()
    {
        if(spamPoints<4) spamPoints++;
    }
    void DecrementSpamPoints()
    {
        if(spamPoints>0) spamPoints--;
    }

    void WaypointSetPath(csString &path, int index)
    {
        waypointPathName = path;
        waypointPathIndex = index;
    }
    csString &WaypointGetPathName()
    {
        return waypointPathName;
    }
    int WaypointGetPathIndex()
    {
        return waypointPathIndex;
    }
    int WaypointGetNewPathIndex()
    {
        return waypointPathIndex++;
    }

    psPath* PathGetPath()
    {
        return pathPath;
    }
    void PathSetPath(psPath* path)
    {
        pathPath = path;
    }

    void PathSetIsDisplaying(iSector* sector);
    void PathClearDisplaying();
    csList<iSector*>::Iterator GetPathDisplaying();
    bool PathIsDisplaying();

    // Online edit of waypoints
    void WaypointSetIsDisplaying(iSector* sector);
    void WaypointClearDisplaying();
    csList<iSector*>::Iterator GetWaypointDisplaying();
    bool WaypointIsDisplaying();


    void LocationSetIsDisplaying(iSector* sector);
    void LocationClearDisplaying();
    csList<iSector*>::Iterator GetLocationDisplaying();
    bool LocationIsDisplaying();

    void SetSelectedLocationID(int id)
    {
        selectedLocationID = id;
    }
    int GetSelectedLocationID()
    {
        return selectedLocationID;
    }


    void CountDetectedCheat()
    {
        if(detectedCheatCount < 10000) detectedCheatCount++;
    }
    unsigned int GetDetectedCheatCount()
    {
        return detectedCheatCount;
    }
    void SetCheatMask(CheatFlags mask,bool flag);
    bool GetCheatMask(CheatFlags mask)
    {
        return (cheatMask & mask) != 0;
    }

    OrderedMessageChannel* GetOrderedMessageChannel(msgtype mtype);

    // FIXME: Ugly hack here as a temporary workaround for client-side issue that causes the server
    // to be flooded with inventory/glyph requests. Remove after all clients have been updated
    // to stop flooding.
    csTicks lastInventorySend;
    csTicks lastGlyphSend;

    void SetBuddyListHide(bool hide)
    {
        isBuddyListHiding = hide;
    }
    bool GetBuddyListHide()
    {
        return isBuddyListHiding;
    }

protected:

    bool zombie;
    csTicks zombietimeout;

    bool allowedToDisconnect;

    int exchangeID;

    gemActor* actor;

    csArray<PID> pets;
    csString mesh;
    bool ready;

    csHash<OrderedMessageChannel*> orderedMessages;

    bool isAdvisor;         

    MuteBuffable mute;

    AccountID accountID;
    PID playerID;
    int  securityLevel;
    bool superclient;
    csArray<gemNPC*> listeningNpc;
    csString name;

    csArray<uint32_t> duel_clients;

    // Flood control
    static const int floodWarn = 3;                     
    static const int floodMax  = 5;                     
    static const unsigned int floodForgiveTime = 10000; 
    FloodBuffRow floodHistory[floodMax];
    int nextFloodHistoryIndex;

    int spamPoints;
    int advisorPoints;

    void SaveAccountData();

    // Invite flood
    csTicks lastInviteTime;
    bool lastInviteResult;
    bool hasBeenWarned;
    bool hasBeenPenalized;

    // Path edit global vars for client
    csString waypointPathName;
    int waypointPathIndex;

    psPath* pathPath;

    int selectedLocationID;

    csList<iSector*> waypointDisplaySectors;
    csList<iSector*> pathDisplaySectors;
    csList<iSector*> locationDisplaySectors;

private:
    unsigned int detectedCheatCount;

    int cheatMask;

    bool isBuddyListHiding;
};

#endif