npcmessages.h

Go to the documentation of this file.

/*
* npcmessages.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 __NPCMESSAGES_H__
#define __NPCMESSAGES_H__

#include "net/message.h"
#include "net/messages.h"
#include <csutil/csstring.h>
#include <csutil/databuf.h>
#include <csgeom/vector3.h>
#include "util/psstring.h"


// Forward declarations
class Location;
class LocationType;
class Waypoint;
class WaypointAlias;
class psPath;
class psPathPoint;
struct iSector;

class psNPCAuthenticationMessage : public psAuthenticationMessage
{
public:

    psNPCAuthenticationMessage(uint32_t clientnum,
        const char *userid,
        const char *password);

    psNPCAuthenticationMessage(MsgEntry *message);
    
    PSF_DECLARE_MSG_FACTORY();

    bool NetVersionOk();
};

class psNPCListMessage : public psMessageCracker
{
public:

    psString xml;

    psNPCListMessage(uint32_t clientToken,int size);

    psNPCListMessage(MsgEntry *message);
    
    PSF_DECLARE_MSG_FACTORY();

    virtual csString ToString(NetBase::AccessPointers * accessPointers);
};

class psNPCReadyMessage : public psMessageCracker
{
public:
        psNPCReadyMessage();

        psNPCReadyMessage(MsgEntry *message);
    
    PSF_DECLARE_MSG_FACTORY();

    virtual csString ToString(NetBase::AccessPointers * accessPointers);
};

class psMapListMessage : public psMessageCracker
{
public:

    csArray<csString> map;

    psMapListMessage(uint32_t clientToken,csString& str);

    psMapListMessage(MsgEntry *message);
    
    PSF_DECLARE_MSG_FACTORY();

    virtual csString ToString(NetBase::AccessPointers * accessPointers);
};

class psNPCRaceListMessage : public psMessageCracker
{
public:

    typedef struct
    {
        csString  name;      
        float     walkSpeed;
        float     runSpeed;
        csVector3 size;
        float     scale;     
    } NPCRaceInfo_t;
    

    csArray<NPCRaceInfo_t> raceInfo;

    psNPCRaceListMessage(uint32_t clientToken,int count);

    psNPCRaceListMessage(MsgEntry *message);
    
    PSF_DECLARE_MSG_FACTORY();

    void AddRace(csString& name, float walkSpeed, float runSpeed, const csVector3& size, float scale, bool last);

    virtual csString ToString(NetBase::AccessPointers * accessPointers);
};

class psNPCCommandsMessage : public psMessageCracker
{
public:

    enum Flags
    {
        NONE        = 0,
        INVISIBLE   = 1 << 0,
        INVINCIBLE  = 1 << 1,
        IS_ALIVE    = 1 << 2
    };

    enum PerceptionType
    {
        // Commands go from superclient to server
        CMD_TERMINATOR,
        CMD_ASSESS,
        CMD_ATTACK,
        CMD_BUSY,
        CMD_CAST,
        CMD_DELETE_NPC,
        CMD_DEQUIP,
        CMD_DRDATA,
        CMD_DROP,
        CMD_EMOTE,
        CMD_ANIMATION,
        CMD_EQUIP,
        CMD_TEMPORARILY_IMPERVIOUS,
        CMD_INFO_REPLY,
        CMD_PICKUP,
        CMD_RESURRECT,
        CMD_SEQUENCE,
        CMD_SCRIPT,             // used for superclient to request a progress script to be run at server
        CMD_SIT,
        CMD_SPAWN,
        CMD_SPAWN_BUILDING,     // used for superclient to request a new building
        CMD_TALK,
        CMD_TRANSFER,
        CMD_UNBUILD,            // used for superclient to request a building to be tearn down
        CMD_VISIBILITY,
        CMD_WORK,
        CMD_CONTROL,
        CMD_LOOT,
        // Perceptions go from server to superclient
        PCPT_ANYRANGEPLAYER,    
        PCPT_ASSESS, 
        PCPT_ATTACK,
        PCPT_CHANGE_BRAIN,      
        PCPT_DEATH,
        PCPT_DEBUG_NPC,         
        PCPT_DEBUG_TRIBE,       
        PCPT_DMG,
        PCPT_FAILED_TO_ATTACK,
        PCPT_FLAG,
        PCPT_GROUPATTACK,
        PCPT_INFO_REQUEST,      // Command to superclient, not a perception
        PCPT_INVENTORY,
        PCPT_LONGRANGEPLAYER,
        PCPT_NPCCMD,
        PCPT_OWNER_ACTION,
        PCPT_OWNER_CMD,
        PCPT_PERCEPT,
        PCPT_SHORTRANGEPLAYER,
        PCPT_SPAWNED,
        PCPT_SPELL,
        PCPT_STAT_DR,        
        PCPT_SPOKEN_TO,
        PCPT_TALK,   
        PCPT_TELEPORT,
        PCPT_TRANSFER,
        PCPT_VERYSHORTRANGEPLAYER,
        PCPT_CHANGE_OWNER,      // Command to superclient, not a perception
    };

    enum PerceptionTalkType
    {
        TALK_SAY,
        TALK_ME,
        TALK_MY,
        TALK_NARRATE
    };

    psNPCCommandsMessage(uint32_t clientToken, int size);

    psNPCCommandsMessage(MsgEntry *message);

    PSF_DECLARE_MSG_FACTORY();
    
    virtual csString ToString(NetBase::AccessPointers * accessPointers);
};


//helpers for message splitting
#define ALLENTITYPOS_SIZE_PER_ENTITY (4 * sizeof(float) + sizeof(bool) + sizeof(uint32_t) + 100*sizeof(char))
#define ALLENTITYPOS_MAX_AMOUNT  (MAX_MESSAGE_SIZE-2)/ALLENTITYPOS_SIZE_PER_ENTITY

class psAllEntityPosMessage: public psMessageCracker
{
public:
    int count;

    psAllEntityPosMessage() { count = 0; msg=NULL; }

    psAllEntityPosMessage(MsgEntry *message);
    
    PSF_DECLARE_MSG_FACTORY();

    virtual csString ToString(NetBase::AccessPointers * accessPointers);

    void SetLength(int size,int client);

    void Add(EID id, csVector3 & pos, iSector* & sector, InstanceID instance, csStringSet* msgstrings, bool forced = false);

    EID Get(csVector3 & pos, iSector* & sector, InstanceID & instance, bool &forced, csStringSet* msgstrings,
        csStringHashReversible* msgstringshash, iEngine* engine);
};

class psNPCWorkDoneMessage : public psMessageCracker
{
public:
    EID         npcEID;
    const char* resource;
    const char* nick;

    psNPCWorkDoneMessage(uint32_t clientToken, EID npcEID, const char* resource, const char* nick);
    
    psNPCWorkDoneMessage(MsgEntry *message);
    
    PSF_DECLARE_MSG_FACTORY();
    
    virtual csString ToString(NetBase::AccessPointers* accessPointers);
};

class psNewNPCCreatedMessage : public psMessageCracker
{
public:
    PID new_npc_id, master_id, owner_id;

    psNewNPCCreatedMessage(uint32_t clientToken, PID new_npc_id, PID master_id, PID owner_id);

    psNewNPCCreatedMessage(MsgEntry *message);
    
    PSF_DECLARE_MSG_FACTORY();

    virtual csString ToString(NetBase::AccessPointers * accessPointers);
};

class psNPCDeletedMessage : public psMessageCracker
{
public:
    PID npc_id;

    psNPCDeletedMessage(uint32_t clientToken, PID npc_id);

    psNPCDeletedMessage(MsgEntry *message);
    
    PSF_DECLARE_MSG_FACTORY();

    virtual csString ToString(NetBase::AccessPointers * accessPointers);
};

class psPETCommandMessage : public psMessageCracker
{
public:

    typedef enum 
    {
        CMD_FOLLOW,
        CMD_STAY,
        CMD_DISMISS,
        CMD_SUMMON,
        CMD_ATTACK,
        CMD_GUARD,
        CMD_ASSIST,
        CMD_STOPATTACK,
        CMD_NAME,
        CMD_TARGET,
        CMD_RUN,
        CMD_WALK,
        CMD_LAST // LAST command, insert new commands before this
    } PetCommand_t;

    static const char *petCommandString[];

    int command;
    psString target;
    psString options;

    psPETCommandMessage(uint32_t clientToken, int cmd, const char * target, const char * options);

    psPETCommandMessage(MsgEntry *message);
    
    PSF_DECLARE_MSG_FACTORY();

    virtual csString ToString(NetBase::AccessPointers * accessPointers);
};

class psServerCommandMessage : public psMessageCracker
{
public:
    
    psString command;

    psServerCommandMessage(uint32_t clientToken, const char * target);

    psServerCommandMessage(MsgEntry *message);
    
    PSF_DECLARE_MSG_FACTORY();

    virtual csString ToString(NetBase::AccessPointers* accessPointers);
};

class psPathNetworkMessage : public psMessageCracker
{
public:

    typedef enum 
    {
        PATH_ADD_POINT,
        PATH_CREATE,
        PATH_RENAME,
        PATH_REMOVE_POINT,
        PATH_SET_FLAG,
        POINT_ADJUSTED,
        WAYPOINT_ADJUSTED,
        WAYPOINT_ALIAS_ADD,
        WAYPOINT_ALIAS_REMOVE,
        WAYPOINT_ALIAS_ROTATION_ANGLE,
        WAYPOINT_CREATE,
        WAYPOINT_RADIUS,
        WAYPOINT_RENAME,
        WAYPOINT_SET_FLAG
    } Command;

    Command   command;    
    uint32_t  id;         
    csVector3 position;   
    iSector*  sector;     
    csString  string;     
    bool      enable;     
    float     radius;     
    csString  flags;      
    uint32_t  startId;
    uint32_t  stopId;
    uint32_t  secondId;
    float     rotationAngle; 
    uint32_t  aliasID;    
    
    // Create psMessageBytes struct for outbound use
    
    psPathNetworkMessage(Command command, const psPath* path);

    psPathNetworkMessage(Command command, const psPath* path, const psPathPoint* point);

    psPathNetworkMessage(Command command, const psPath* path, int secondId);
    
    
    psPathNetworkMessage(Command command, const psPath* path, const csString& string, bool enable);

    psPathNetworkMessage(Command command, const psPathPoint* point);

    psPathNetworkMessage(Command command, const Waypoint* waypoint);

    psPathNetworkMessage(Command command, const Waypoint* waypoint, const WaypointAlias* alias);

    psPathNetworkMessage(Command command, const Waypoint* waypoint, const csString& string);

    psPathNetworkMessage(Command command, const Waypoint* waypoint, const csString& string, bool enable);


    psPathNetworkMessage(MsgEntry *message);
    
    PSF_DECLARE_MSG_FACTORY();

    virtual csString ToString(NetBase::AccessPointers* accessPointers);
};

class psLocationMessage : public psMessageCracker
{
public:

    typedef enum 
    {
        LOCATION_ADJUSTED,
        LOCATION_CREATED,
        LOCATION_DELETED,
        LOCATION_INSERTED,
        LOCATION_RADIUS,
        LOCATION_RENAME,
        LOCATION_SET_FLAG,
        LOCATION_TYPE_ADD,
        LOCATION_TYPE_REMOVE
    } Command;

    Command   command;       
    uint32_t  id;            
    csVector3 position;      
    iSector*  sector;        
    bool      enable;        
    float     radius;        
    float     rotationAngle; 
    csString  flags;         
    csString  typeName;      
    csString  name;          
    uint32_t  prevID;        
    
    // Create psMessageBytes struct for outbound use
    
    psLocationMessage(Command command, const Location* location);

    psLocationMessage(Command command, const LocationType* locationType);
    
    psLocationMessage(Command command, const csString& name);

    psLocationMessage(MsgEntry *message);
    
    PSF_DECLARE_MSG_FACTORY();

    virtual csString ToString(NetBase::AccessPointers* accessPointers);
};

#endif