npcclient.h

Go to the documentation of this file.

/*
 * npcclient.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.
 *
 */
#ifndef __NPCCLIENT_H__
#define __NPCCLIENT_H__
//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/csstring.h>
#include <csutil/hash.h>
#include <csutil/ref.h>
#include <csutil/list.h>
#include <iutil/vfs.h>

struct iObjectRegistry;
struct iDocumentNode;
struct iConfigManager;
struct iCollideSystem;

//=============================================================================
// Library Includes
//=============================================================================
#include "net/pstypes.h"
#include "net/npcmessages.h"

#include "util/psconst.h"
#include "util/serverconsole.h"
#include "util/pspath.h"
#include "util/pspathnetwork.h"
#include "util/mathscript.h"

#include "tools/celhpf.h"

class  psDatabase;
class  MsgHandler;
class  psNetConnection;
class  EventManager;
class  RecipeManager;
class  NetworkManager;
class  NPCType;
class  NPC;
class  gemNPCActor;
class  gemNPCObject;
class  gemNPCItem;
struct iVFS;
class  Perception;
class  Reaction;
class  psWorld;
class  Location;
class  LocationType;
class  LocationManager;
class  Waypoint;
//class  psPFMaps;
class  Tribe;
class  psPath;
class  psPathNetwork;
struct iCelHNavStruct;

class psNPCClient : public iCommandCatcher, public iScriptableVar
{
public:

    struct DeferredNPC
    {
        PID      id;
        csString name;
    };


    psNPCClient();

    ~psNPCClient();

    bool Initialize(iObjectRegistry* object_reg, const char* host, const char* user, const char* pass, int port);

    iObjectRegistry* GetObjectReg()
    {
        return objreg;
    }

    Tribe* GetTribe(int id);

    void MainLoop();

    virtual void CatchCommand(const char* cmd);

    void LoadLogSettings();

    void SaveLogSettings();

    void LoadCompleted();

    bool IsReady();

    void Tick();

    bool LoadMap(const char* mapfile);

    LocationType* FindRegion(const char* regname);

    LocationType* FindLocation(const char* locname);

    Location* FindLocation(const char* loctype, const char* name);

    Location* FindNearestLocation(const char* loctype, csVector3 &pos, iSector* sector, float range = -1, float* found_range = NULL);

    Location* FindRandomLocation(const char* loctype, csVector3 &pos, iSector* sector, float range = -1, float* found_range = NULL);

    Waypoint* FindNearestWaypoint(const csVector3 &v, iSector* sector, float range = -1, float*  found_range = NULL);

    Waypoint* FindRandomWaypoint(const csVector3 &v, iSector* sector, float range = -1, float*  found_range = NULL);

    Waypoint* FindNearestWaypoint(const char* group, csVector3 &v, iSector* sector, float range = -1, float*  found_range = NULL);

    Waypoint* FindRandomWaypoint(const char* group, csVector3 &v, iSector* sector, float range = -1, float*  found_range = NULL);

    Waypoint* FindWaypoint(gemNPCObject* entity);

    Waypoint* FindNearestWaypoint(gemNPCObject* entity, float range, float* found_range);


    Waypoint* FindWaypoint(int id);

    Waypoint* FindWaypoint(const char* name, WaypointAlias** alias);

    csList<Waypoint*> FindWaypointRoute(Waypoint*  start, Waypoint*  end, const psPathNetwork::RouteFilter* filter);

    csList<Edge*> FindEdgeRoute(Waypoint*  start, Waypoint*  end, const psPathNetwork::RouteFilter* filter);

    NPCType* FindNPCType(const char* npctype_name);

    void AddRaceInfo(const psNPCRaceListMessage::NPCRaceInfo_t &raceInfo);

    psNPCRaceListMessage::NPCRaceInfo_t* GetRaceInfo(const char* name);

    bool DumpRace(const char* pattern);

    float GetWalkVelocity(csString &race);

    float GetRunVelocity(csString &race);

    NetworkManager* GetNetworkMgr()
    {
        return network;
    }

    psNetConnection* GetNetConnection()
    {
        return connection;
    }

    void RegisterReaction(NPC* npc, Reaction* reaction);

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

    EventManager* GetEventManager()
    {
        return eventmanager;
    }

    MathScriptEngine*  GetMathScriptEngine()
    {
        return mathScriptEngine;
    }

    void Disconnect();

    void SetEntityPos(EID id, csVector3 &pos, iSector* sector, InstanceID instance, bool force = false);

    NPC* FindNPCByPID(PID character_id);

    NPC* FindNPC(EID entid);

    psPath* FindPath(const char* name);

    void EnableDisableNPCs(const char* pattern, bool enable);

    void ListAllNPCs(const char* pattern);

    size_t GetNpcListAmount()
    {
        return npcs.GetSize();
    }

    unsigned int GetTickCounter() const
    {
        return tick_counter;
    }

    bool DumpNPC(const char* pattern);

    bool InfoNPC(const char* pattern);

    void ListAllEntities(const char* pattern, bool onlyCharacters = false);

    void ListTribes(const char* pattern);

    void ListTribeRecipes(const char* tribeID);

    void ListReactions(const char* pattern);

    void ListWaypoints(const char* pattern);

    void ListPaths(const char* pattern);

    void ListLocations(const char* pattern);

    void HandleDeath(NPC* who);

    void Add(gemNPCObject* object);
    void Remove(gemNPCObject* object);
    void RemoveAll();

    void Remove(NPC* npc);

    gemNPCObject* FindCharacterID(PID pid);
    gemNPCObject* FindEntityID(EID eid);

    gemNPCObject* FindEntityByName(const char* name);

    bool CheckAttachTribes(NPC* npc);

    void AttachNPC(gemNPCActor* actor, uint8_t DRcounter, EID ownerEID, PID masterID);

    iCollideSystem* GetCollDetSys()
    {
        return cdsys;
    }

    NPC* ReadSingleNPC(PID char_id, PID master_id = 0);

    NPC* ReadMasteredNPC(PID char_id, PID master_id);

    void UpdateTime(int minute, int hour, int day, int month, int year);

    iCelHNavStruct*  GetNavStruct()
    {
        return navStruct;
    }

    iCelHPath* ShortestPath(NPC* npc, const csVector3 &from, iSector* fromSector, const csVector3 &goal, iSector* goalSector);

    psWorld*  GetWorld()
    {
        return world;
    }

    iEngine*  GetEngine()
    {
        return engine;
    }

    iVFS*   GetVFS()
    {
        return vfs;
    }


    int GetGameTODMinute()
    {
        return gameMinute;
    }

    int GetGameTODHour()
    {
        return gameHour;
    }

    int GetGameTODDay()
    {
        return gameDay;
    }

    int GetGameTODMonth()
    {
        return gameMonth;
    }

    int GetGameTODYear()
    {
        return gameYear;
    }

    void AttachObject(iObject* object, gemNPCObject* gobject);

    void UnattachObject(iObject* object, gemNPCObject* gobject);

    gemNPCObject* FindAttachedObject(iObject* object);


    csArray<gemNPCObject*> FindNearbyEntities(iSector* sector, const csVector3 &pos, float radius, bool doInvisible = false);

    csArray<gemNPCActor*> FindNearbyActors(iSector* sector, const csVector3 &pos, float radius, bool doInvisible = false);

    csPtr<iDocumentNode> GetRootNode(const char* xmlfile);

    bool AddNPCType(csString newType);

    bool LoadNPCTypes(iDocumentNode* root);

    bool LoadNPCTypes();

    bool FirePerception(int NPCId, const char* perception);

    bool LoadPathNetwork();

    psPathNetwork* GetPathNetwork()
    {
        return pathNetwork;
    }

    LocationManager* GetLocationManager()
    {
        return locationManager;
    }

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

protected:
    bool ReadNPCsFromDatabase();

    bool LoadLocations();

    bool LoadTribes();

    void PerceptProximityItems();

    void PerceptProximityLocations();

    void PerceptProximityTribeHome();

public:
    static psNPCClient*             npcclient;
protected:
    psNetConnection*                connection;
    iObjectRegistry*                objreg;
    csRef<iEngine>                  engine;
    csRef<iConfigManager >          configmanager;
    csRef<MsgHandler>               msghandler;
    ServerConsole*                  serverconsole;
    EventManager*                   eventmanager;
    RecipeManager*                  recipemanager;
    NetworkManager*                 network;
    psDatabase*                     database;
    csRef<iVFS>                     vfs;

    csHash<NPCType*, const char*>   npctypes;
    LocationManager*                locationManager;         
    MathScriptEngine*               mathScriptEngine;
    psPathNetwork*                  pathNetwork;
    csRef<iCelHNavStruct>           navStruct;
    csPDelArray<NPC>                npcs;
    csArray<DeferredNPC>            npcsDeferred;
    csPDelArray<Tribe>              tribes;
    csHash<gemNPCObject*, EID>      all_gem_objects_by_eid;
    csHash<gemNPCObject*, PID>      all_gem_objects_by_pid;
    csPDelArray<gemNPCObject>       all_gem_objects;
    csArray<gemNPCItem*>            all_gem_items;
    csArray<gemNPCActor*>           all_gem_actors;

    csHash<psNPCRaceListMessage::NPCRaceInfo_t,csString>     raceInfos; 

    csHash<NPC*,csString>           allReactions;     
    csArray<csString>               notUsedReactions; 

    csRef<iCollideSystem>           cdsys;

    psWorld*                        world;

    //    psPFMaps*                       PFMaps;

    unsigned int                    tick_counter;

    int                             current_long_range_perception_index;
    int                             current_long_range_perception_loc_index;
    int                             current_tribe_home_perception_index;

    // Game Time
    int                             gameMinute;
    int                             gameHour;
    int                             gameDay;
    int                             gameMonth;
    int                             gameYear;
    csTicks                         gameTimeUpdated;

};

#endif