npcmanager.h

Go to the documentation of this file.

/*
* npcmanager.h by Keith Fulton <[email protected]>
*
* Copyright (C) 2003 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 __NPCMANAGER_H_
#define __NPCMANAGER_H_
//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/ref.h>

//=============================================================================
// Project Includes
//=============================================================================
#include "net/netbase.h"                // PublishVector class
#include "net/npcmessages.h"

#include "bulkobjects/psskills.h"
#include "cachemanager.h"

//=============================================================================
// Local Includes
//=============================================================================
#include "msgmanager.h"   // Subscriber class

#define OWNER_ALL 0xFFFFFFFF


class Client;
class psDatabase;
class psNPCCommandsMessage;
class ClientConnectionSet;
class EntityManager;
class EventManager;
class gemObject;
class gemActor;
class gemNPC;
class PetOwnerSession;
class psPathPoint;
class Waypoint;
class psPath;
class Location;
class LocationType;

class NPCManager : public MessageManager<NPCManager>
{
public:
    NPCManager(ClientConnectionSet* pCCS,
               psDatabase* db,
               EventManager* evtmgr,
               GEMSupervisor* gemsupervisor,
               CacheManager* cachemanager,
               EntityManager* entitymanager);

    virtual ~NPCManager();

    bool Initialize();

    void SendNPCList(Client* client);

    void SendAllNPCStats(Client* client);

    void Disconnect(Client* client);

    void AddEntity(gemObject* obj);

    void RemoveEntity(MsgEntry* me);

    void UpdateWorldPositions();

    void QueueAssessPerception(EID entityEID, EID targetEID, const csString &physicalAssessmentPerception,
                               const csString &physicalAssessmentDifferencePerception,
                               const csString &magicalAssessmentPerception,
                               const csString &magicalAssessmentDifferencePerception,
                               const csString &overallAssessmentPerception,
                               const csString &overallAssessmentDifferencePerception);


    void QueueTalkPerception(gemActor* speaker, gemNPC* target);

    void QueueAttackPerception(gemActor* attacker,gemNPC* target);

    void QueueDamagePerception(gemActor* attacker,gemNPC* target,float dmg);

    void QueueDeathPerception(gemObject* who);

    void QueueSpellPerception(gemActor* caster, gemObject* target,const char* spell_cat, uint32_t spell_category, float severity);

    void QueueStatDR(gemActor* actor, unsigned int statsDirtyFlags);

    void QueueEnemyPerception(psNPCCommandsMessage::PerceptionType type, gemActor* npc, gemActor* player, float relative_faction);

    void QueueOwnerCmdPerception(gemActor* owner, gemNPC* pet, psPETCommandMessage::PetCommand_t command);

    void QueueInventoryPerception(gemActor* owner, psItem* itemdata, bool inserted);

    void QueueFlagPerception(gemActor* owner);

    void QueueNPCCmdPerception(gemActor* owner, const csString &cmd);

    void QueueTransferPerception(gemActor* owner, psItem* itemdata, csString target);

    void QueueSpawnedPerception(gemNPC* spawned, gemNPC* spawner, const csString &tribeMemberType);

    void QueueTeleportPerception(gemNPC* npc, csVector3 &pos, float yrot, iSector* sector, InstanceID instance);

    void QueueInfoRequestPerception(gemNPC* npc, Client* client, const char* infoRequestSubCmd);

    void QueueFailedToAttackPerception(gemNPC* attacker, gemObject* target);

    void QueuePerceptPerception(gemNPC* npc, csString perception, csString type);

    void QueueSpokenToPerception(gemNPC* npc, bool spokenTo);

    void QueueChangeOwnerPerception(gemNPC* npc, EID owner);

    void ChangeNPCBrain(gemNPC* npc, Client* client, const char* brainName);

    void DebugNPC(gemNPC* npc, Client* client, uint8_t debugLevel);

    void DebugTribe(gemNPC* npc, Client* client, uint8_t debugLevel);

    void SendAllCommands(bool createNewTick);

    csArray<PublishDestination> &GetSuperClients()
    {
        return superclients;
    }

    void WorkDoneNotify(EID npcEID, csString reward, csString nick);

    void NewNPCNotify(PID player_id, PID master_id, PID owner_id);

    void DeletedNPCNotify(PID player_id);

    void ControlNPC(gemNPC* npc);

    void CheckWorkLocation(gemNPC* npc, Location* location);

    PetOwnerSession* CreatePetOwnerSession(gemActor*, psCharacter*);

    void DismissPet(gemNPC* pet, Client* owner);

    void RemovePetOwnerSession(PetOwnerSession* session);

    void UpdatePetTime();

    PSSKILL GetPetSkill()
    {
        return (PSSKILL)petSkill->getValueAsInt();
    }

    void LocationAdjusted(Location* location);

    void LocationCreated(Location* location);

    void LocationInserted(Location* location);

    void LocationRadius(Location* location);

    void LocationTypeAdd(LocationType* locationType);

    void LocationTypeRemove(const csString &locationTypeName);

    void WaypointAdjusted(Waypoint* wp);

    void PathPointAdjusted(psPathPoint* point);

    void WaypointAddAlias(const Waypoint* wp, const WaypointAlias* alias);

    void WaypointAliasRotation(const Waypoint* wp, const WaypointAlias* alias);

    void WaypointRemoveAlias(const Waypoint* wp, const csString &alias);

    void WaypointSetFlag(const Waypoint* wp, const csString &flag, bool enable);

    void PathSetFlag(const psPath* path, const csString &flag, bool enable);

    void WaypointRadius(const Waypoint* waypoint);

    void WaypointRename(const Waypoint* waypoint);

    void PathRename(const psPath* path);

    void WaypointCreate(const Waypoint* waypoint);

    void PathCreate(const psPath* path);

    void AddPoint(const psPath* path, const psPathPoint* point);

    void RemovePoint(const psPath* path, int pointId);

    MathScript* GetPetDepletedLockoutTime() { return petDepletedLockoutTime; }
    MathScript* GetPetDismissLockoutTime() { return petDismissLockoutTime; }
    MathScript* GetMaxPetTime() { return maxPetTime; }
    MathScript* GetPetDeathLockoutTime() { return petDeathLockoutTime; }
    MathScript* GetPetTrainingLockoutTime() { return petTrainingLockoutTime; }

protected:

    void HandleAuthentRequest(MsgEntry* me,Client* client);

    void HandleCommandList(MsgEntry* me,Client* client);

    void HandleDamageEvent(MsgEntry* me,Client* client);

    void HandleDeathEvent(MsgEntry* me,Client* client);

    void HandleNPCReady(MsgEntry* me,Client* client);

    void HandleSimpleRenderMesh(MsgEntry* me, Client* client);

    void SendMapList(Client* client);

    void SendRaces(Client* client);

    bool CanPetHearYou(int clientnum, Client* owner, gemNPC* pet, const char* type);

    bool WillPetReact(int clientnum, Client* owner, gemNPC* pet, const char* type, int level);

    void HandlePetCommand(MsgEntry* me, Client* client);

    void HandlePetSkill(MsgEntry* me, Client* client);
    void SendPetSkillList(Client* client, bool forceOpen = true, PSSKILL focus = PSSKILL_NONE);

public:
    void PetHasBeenKilled(gemNPC*  pet);

    void PetInfo(Client* client, psCharacter* pet);

protected:
    void HandleConsoleCommand(MsgEntry* me,Client* client);

    void PrepareMessage();

    void CheckSendPerceptionQueue(size_t expectedAddSize);

    csArray<PublishDestination> superclients;

    psDatabase*  database;
    EventManager* eventmanager;
    GEMSupervisor* gemSupervisor;
    CacheManager* cacheManager;
    EntityManager* entityManager;
    ClientConnectionSet* clients;
    psNPCCommandsMessage* outbound;
    int cmd_count;
    optionEntry* petSkill;

    csHash<PetOwnerSession*, PID> OwnerPetList;

    MathScript* petRangeScript;

    MathScript* petReactScript;

    MathScript* petDepletedLockoutTime;
    MathScript* petDismissLockoutTime;
    MathScript* maxPetTime;
    MathScript* petDeathLockoutTime;
    MathScript* petTrainingLockoutTime;
};

#endif