npc.h

Go to the documentation of this file.

/*
* npc.h
*
* Copyright (C) 2003 Atomic Blue (info@planeshift.it, 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.
*
*/

/* This file holds definitions for ALL global variables in the planeshift
* server, normally you should move global variables into the psServer class
*/
#ifndef __NPC_H__
#define __NPC_H__
//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/hash.h>

struct iMovable;

#include "util/psutil.h"
#include "util/gameevent.h"
#include "util/remotedebug.h"

//=============================================================================
// Local Includes
//=============================================================================
#include "tribe.h"
#include "gem.h"
#include "stat.h"

class  Behavior;
class  EventManager;
class  HateList;
class  LocationType;
class  NPCType;
class  NetworkManager;
class  Tribe;
class  Waypoint;
class  gemNPCActor;
class  gemNPCObject;
class  iResultRow;
class  psLinearMovement;
class  psNPCClient;
class  psNPCTick;
struct iCollideSystem;
struct HateListEntry;

#define NPC_BRAIN_TICK 200

// Define a variadic macro for debugging prints for NPCs.
// In this way only the check IsDebugging is executed for each NPC unless debugging
// is turned on. Using the Printf functions will cause all args to be
// resolved and that will result in a lot off spilled CPU.
#define NPCDebug(npc,debug,...) \
    { if (npc->IsDebugging()) { npc->Printf(debug, __VA_ARGS__); }}

class HateList
{
protected:
    csHash<HateListEntry*, EID> hatelist;

public:
    HateList(psNPCClient* npcclient, iEngine* engine, psWorld* world)
    {
        this->npcclient = npcclient;
        this->engine = engine;
        this->world = world;
    }
    ~HateList();

    void AddHate(EID entity_id, float delta);

    gemNPCActor* GetMostHated(NPC* npc, csVector3 &pos, iSector* sector, float range, LocationType* region,
                              bool includeOutsideRegion, bool includeInvisible, bool includeInvincible, float* hate);
    bool Remove(EID entity_id);
    void DumpHateList(csString &output, const csVector3 &myPos, iSector* mySector);
    void DumpHateList(NPC* npc, const csVector3 &myPos, iSector* mySector);
    void Clear();
    float GetHate(EID ent);

private:
    psNPCClient* npcclient;
    iEngine* engine;
    psWorld* world;
};

class NPC : private ScopedTimerCB, public iScriptableVar, public RemoteDebug
{
public:
    typedef struct
    {
        csVector3               pos;        
        iSector*                sector;     
        float                   angle;      
        Waypoint*               wp;         
        float                   radius;     
        csWeakRef<gemNPCObject> target;     
    } Locate;
    typedef csHash<Locate*,csString> LocateHash;

    enum
    {
        LOCATION_NONE = 0,
        LOCATION_POS = 1,
        LOCATION_SECTOR = 2,
        LOCATION_ANGLE = 4,
        LOCATION_WP = 8,
        LOCATION_RADIUS = 16,
        LOCATION_TARGET = 32,
        LOCATION_ALL = -1
    };

protected:

    typedef csHash<csString,csString> BufferHash;

    NPCType*           oldbrain;        
    NPCType*           brain;
    csString           origtype;        
    csString           type;
    PID                pid;
    csString           name;
    csTicks            last_update;
    gemNPCActor*       npcActor;
    iMovable*          movable;

    uint8_t            DRcounter;
    csVector3          lastDrPosition;
    iSector*           lastDrSector;
    csTicks            lastDrTime;
    bool               lastDrMoving;
    float              lastDrYRot;
    csVector3          lastDrVel;
    float              lastDrAngVel;

    Locate*            activeLocate;   
    LocateHash         storedLocates;  

    float              ang_vel,vel;
    float              walkVelocity;
    float              runVelocity;
    float              scale;                
    csString           region_name;          
    LocationType*      region;               
    bool               insideRegion;         
    Perception*        last_perception;
    bool               alive;
    EID                owner_id;
    EID                target_id;

    csArray<csString>  autoMemorizeTypes;    

    Tribe*             tribe;
    csString           tribeMemberType;      
    bool               insideTribeHome;      

    csVector3          spawnPosition;        
    iSector*           spawnSector;          

    psNPCRaceListMessage::NPCRaceInfo_t*        raceInfo;

    // Stats
    Stat               hp;
    Stat               mana;
    Stat               pysStamina;
    Stat               menStamina;

    csArray< csWeakRef<gemNPCActor> > controlledActors; 

    // Initial position checks
    csVector3          checkedPos;
    iSector*           checkedSector;
    bool               checked;
    bool               checkedResult;
    bool               disabled;

    int                fallCounter; // Incremented if the NPC fall off the map

    void Advance(csTicks when);

    void TickPostProcess(csTicks when);

    HateList           hatelist;

public:

    NPC(psNPCClient* npcclient, NetworkManager* networkmanager, psWorld* world, iEngine* engine, iCollideSystem* cdsys);
    virtual ~NPC();


    void Tick();

    PID                   GetPID()
    {
        return pid;
    }
    EID                   GetEID();
    iMovable*             GetMovable()
    {
        return movable;
    }
    psLinearMovement*     GetLinMove();

    uint8_t               GetDRCounter(csTicks when, const csVector3 &pos, float yRot, iSector* sector,
                                       const csVector3 &vel, float angVel)
    {
        lastDrTime = when;
        lastDrPosition = pos;
        lastDrSector = sector;
        lastDrYRot = yRot;
        lastDrVel = vel;
        lastDrAngVel = angVel;
        return ++DRcounter;
    }
    void                  SetDRCounter(uint8_t counter)
    {
        DRcounter = counter;
    }

    bool Load(iResultRow &row,csHash<NPCType*, const char*> &npctypes, EventManager* eventmanager, PID usePID);

    void Load(const char* name, PID pid, NPCType* type, const char* region_name, int debugging, bool disabled, EventManager* eventmanager);

    bool InsertCopy(PID use_char_id, PID ownerPID);

    bool Delete();

    void SetActor(gemNPCActor* actor);
    gemNPCActor* GetActor()
    {
        return npcActor;
    }
    const char* GetName()
    {
        return name.GetDataSafe();
    }
    void SetAlive(bool a);
    bool IsAlive() const
    {
        return alive;
    }
    void Disable(bool disable = true);
    bool IsDisabled()
    {
        return disabled;
    }

    Behavior* GetCurrentBehavior();
    NPCType*  GetBrain();
    const char* GetOrigBrainType()
    {
        return origtype;
    }

    void SetBrain(NPCType* type);

    void ScopedTimerCallback(const ScopedTimer* timer);

    csString Info(const csString &infoRequestSubCmd);

    void Dump();

    void DumpState(csString &output);

    void DumpBehaviorList(csString &output);

    void DumpReactionList(csString &output);

    void DumpHateList(csString &output);

    void DumpHateList(NPC* npc);

    void DumpDebugLog(csString &output);

    void DumpMemory(csString &output);

    void DumpControlled(csString &output);

    void ClearState();

    void TriggerEvent(Perception* pcpt, float maxRange=-1.0,
                      csVector3* basePos=NULL, iSector* baseSector=NULL,
                      bool sameSector=false);

    void TriggerEvent(const char* pcpt);

    void SetLastPerception(Perception* pcpt);
    Perception* GetLastPerception()
    {
        return last_perception;
    }

    gemNPCActor* GetMostHated(float range, bool includeOutsideRegion, bool includeInvisible,
                              bool includeInvincible, float* hate=NULL);

    gemNPCActor* GetMostHated(csVector3 &pos, iSector* sector, float range, LocationType* region, bool includeOutsideRegion,
                              bool includeInvisible, bool includeInvincible, float* hate);


    float GetEntityHate(gemNPCActor* entity);

    void AddToHateList(gemNPCActor* attacker,float delta);

    void RemoveFromHateList(EID who);

    void SetLocate(const csString &destination, const NPC::Locate &locate);

    void GetActiveLocate(csVector3 &pos, iSector* &sector, float &rot);

    void GetActiveLocate(Waypoint* &wp);

    float GetActiveLocateRadius() const;

    bool CopyLocate(csString source, csString destination, unsigned int flags);

    void ReplaceLocations(csString &result);

    float GetAngularVelocity();

    float GetVelocity();

    float GetWalkVelocity();

    float GetRunVelocity();

    csString &GetRegionName()
    {
        return region_name;
    }
    LocationType* GetRegion();

    bool IsInsideRegion()
    {
        return insideRegion;
    }

    void SetInsideRegion(bool inside)
    {
        insideRegion = inside;
    }


    gemNPCActor* GetNearestActor(float range, csVector3 &destPosition, iSector* &destSector, float &destRange);

    gemNPCActor* GetNearestNPC(float range, csVector3 &destPosition, iSector* &destSector, float &destRange);

    gemNPCActor* GetNearestPlayer(float range, csVector3 &destPosition, iSector* &destSector, float &destRange);

    gemNPCActor* GetNearestVisibleFriend(float range);

    gemNPCActor* GetNearestDeadActor(float range);

    void AddAutoMemorize(csString types);

    void RemoveAutoMemorize(csString types);

    bool HasAutoMemorizeTypes() const
    {
        return !autoMemorizeTypes.IsEmpty();
    }

    bool ContainAutoMemorizeType(const csString &type);

private:
    virtual void LocalDebugReport(const csString &debugString);

    virtual void RemoteDebugReport(uint32_t clientNum, const csString &debugString);

public:
    gemNPCObject* GetTarget();
    void SetTarget(gemNPCObject* t);

    gemNPCObject* GetOwner();
    const char* GetOwnerName();

    void SetOwner(EID owner_EID);

    void SetTribe(Tribe* new_tribe);

    Tribe* GetTribe();

    void SetTribeMemberType(const char* tribeMemberType);

    const csString &GetTribeMemberType() const;

    bool IsInsideTribeHome()
    {
        return insideTribeHome;
    }

    void SetInsideTribeHome(bool inside)
    {
        insideTribeHome = inside;
    }

    psNPCRaceListMessage::NPCRaceInfo_t* GetRaceInfo();


    float GetHP();

    float GetMaxHP() const;

    float GetHPRate() const;

    float GetMana();

    float GetMaxMana() const;

    float GetManaRate() const;

    float GetPysStamina();

    float GetMaxPysStamina() const;

    float GetPysStaminaRate() const;

    float GetMenStamina();

    float GetMaxMenStamina() const;

    float GetMenStaminaRate() const;

    void TakeControl(gemNPCActor* actor);

    void ReleaseControl(gemNPCActor* actor);

    void UpdateControlled();

    void CheckPosition();

    void StoreSpawnPosition();

    const csVector3 &GetSpawnPosition() const;

    iSector* GetSpawnSector() const;


    void IncrementFallCounter()
    {
        ++fallCounter;
    }

    int GetFallCounter()
    {
        return fallCounter;
    }

    csString GetBuffer(const csString &bufferName);

    void SetBuffer(const csString &bufferName, const csString &value);

    void ReplaceBuffers(csString &result);

    Tribe::Memory* GetBufferMemory()
    {
        return bufferMemory;
    }

    void SetBufferMemory(Tribe::Memory* memory);

    void SetBuildingSpot(Tribe::Asset* buildingSpot);

    Tribe::Asset* GetBuildingSpot();

private:
    virtual double GetProperty(MathEnvironment* env, const char* ptr);
    virtual double CalcFunction(MathEnvironment* env, const char* functionName, const double* params);
    virtual const char* ToString();

private:
    psNPCTick*        tick;
    psNPCClient*      npcclient;
    NetworkManager*   networkmanager;
    psWorld*          world;
    iCollideSystem*   cdsys;

    BufferHash        npcBuffer;        
    Tribe::Memory*    bufferMemory;     
    Tribe::Asset*     buildingSpot;     

    friend class psNPCTick;

};

class psNPCTick : public psGameEvent
{
protected:
    NPC* npc;

public:
    psNPCTick(int offsetticks, NPC* npc): psGameEvent(0,offsetticks,"psNPCTick"), npc(npc) {};

    virtual void Trigger()
    {
        if(npc)
        {
            npc->tick = NULL;
            npc->Tick();
        }
    }

    void Remove()
    {
        npc = NULL;
    }


    virtual csString ToString() const
    {
        return "psNPCTick";
    }
};

struct HateListEntry
{
    EID   entity_id;
    float hate_amount;
};

#endif