messages.h

Go to the documentation of this file.

/*
 * messages.h
 *
 * Copyright (C) 2001-2002 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 __MESSAGES_H__
#define __MESSAGES_H__

#include "net/netbase.h"
#include "net/message.h"
#include <csutil/csstring.h>
#include <csutil/array.h>
#include <csutil/stringarray.h>
#include <csutil/strset.h>
#include <csutil/databuf.h>
#include <csutil/md5.h>
#include "util/psscf.h"
#include <csgeom/vector3.h>
#include "rpgrules/psmoney.h"
#include "util/psconst.h"
#include "util/skillcache.h"
#include <ivideo/graph3d.h>

#include "bulkobjects/activespell.h"

struct iSpriteCal3DState;
struct iEngine;


class psLinearMovement;
class csStringHashReversible;

// This holds the version number of the network code, remember to increase
// this each time you do an update which breaks compatibility
#define PS_NETVERSION   0x00B9
// Remember to bump the version in pscssetup.h, as well.


// NPC Networking version is separate so we don't have to break compatibility
// with clients to enhance the superclients.  Made it a large number to ensure
// no inadvertent overlaps.
#define PS_NPCNETVERSION 0x1035

enum Slot_Containers
{
    CONTAINER_INVENTORY_BULK      = -1,
    CONTAINER_INVENTORY_EQUIPMENT = -2,
    CONTAINER_EXCHANGE_OFFERING  = -3,
    CONTAINER_EXCHANGE_RECEIVING  = -4,

    CONTAINER_INVENTORY_MONEY = -5,
    CONTAINER_OFFERING_MONEY = -6,
    CONTAINER_RECEIVING_MONEY = -7,

    CONTAINER_WORLD = -8,
    CONTAINER_GEM_OBJECT = -9,
    CONTAINER_SPELL_BOOK = -10
};

struct iSector;

enum MSG_TYPES
{
    MSGTYPE_PING = 1,
    MSGTYPE_AUTHENTICATE,
    MSGTYPE_PREAUTHENTICATE,
    MSGTYPE_PREAUTHAPPROVED,
    MSGTYPE_AUTHAPPROVED,
    MSGTYPE_AUTHREJECTED,
    MSGTYPE_DISCONNECT,
    MSGTYPE_CHAT,
    MSGTYPE_CHANNEL_JOIN,
    MSGTYPE_CHANNEL_JOINED,
    MSGTYPE_CHANNEL_LEAVE,
    MSGTYPE_GUILDCMD,
    MSGTYPE_USERCMD,
    MSGTYPE_SYSTEM,
    MSGTYPE_CHARREJECT,
    MSGTYPE_DEAD_RECKONING,
    MSGTYPE_FORCE_POSITION,
    MSGTYPE_CELPERSIST,
    MSGTYPE_CONFIRMQUESTION,
    MSGTYPE_USERACTION,
    MSGTYPE_ADMINCMD,
    MSGTYPE_GUIINTERACT,
    MSGTYPE_GUIINVENTORY,
    MSGTYPE_VIEW_ITEM,
    MSGTYPE_VIEW_CONTAINER,
    MSGTYPE_VIEW_SKETCH,
    MSGTYPE_VIEW_ACTION_LOCATION,
    MSGTYPE_READ_BOOK,
    MSGTYPE_WRITE_BOOK,
    MSGTYPE_UPDATE_ITEM,
    MSGTYPE_MODE,
    MSGTYPE_WEATHER,
    MSGTYPE_NEWSECTOR,
    MSGTYPE_GUIGUILD,
    MSGTYPE_EQUIPMENT,
    MSGTYPE_GUIEXCHANGE,
    MSGTYPE_EXCHANGE_REQUEST,
    MSGTYPE_EXCHANGE_ADD_ITEM,
    MSGTYPE_EXCHANGE_REMOVE_ITEM,
    MSGTYPE_EXCHANGE_ACCEPT,
    MSGTYPE_EXCHANGE_STATUS,
    MSGTYPE_EXCHANGE_END,
    MSGTYPE_EXCHANGE_AUTOGIVE,
    MSGTYPE_EXCHANGE_MONEY,
    MSGTYPE_GUIMERCHANT,
    MSGTYPE_GUISTORAGE,
    MSGTYPE_GROUPCMD,
    MSGTYPE_GUIGROUP,
    MSGTYPE_STATDRUPDATE,
    MSGTYPE_SPELL_BOOK,
    MSGTYPE_GLYPH_REQUEST,
    MSGTYPE_GLYPH_ASSEMBLE,
    MSGTYPE_PURIFY_GLYPH,
    MSGTYPE_SPELL_CAST,
    MSGTYPE_SPELL_CANCEL,
    MSGTYPE_EFFECT,
    MSGTYPE_EFFECT_STOP,
    MSGTYPE_NPCAUTHENT,
    MSGTYPE_NPCLIST,
    MSGTYPE_GUITARGETUPDATE,
    MSGTYPE_MAPLIST,
    MSGTYPE_NPCCOMMANDLIST,
    MSGTYPE_NPCREADY,
    MSGTYPE_ALLENTITYPOS,
    MSGTYPE_PERSIST_ALL_ENTITIES,
    MSGTYPE_NEW_NPC,
    MSGTYPE_PETITION,
    MSGTYPE_MSGSTRINGS,
    MSGTYPE_CHARACTERDATA,
    MSGTYPE_AUTHCHARACTER,
    MSGTYPE_AUTHCHARACTERAPPROVED,
    MSGTYPE_CHAR_CREATE_CP,
    MSGTYPE_COMBATEVENT,
    MSGTYPE_LOOT,
    MSGTYPE_LOOTITEM,
    MSGTYPE_LOOTREMOVE,
    MSGTYPE_GUISKILL,
    MSGTYPE_OVERRIDEACTION,
    MSGTYPE_QUESTLIST,
    MSGTYPE_QUESTINFO,
    MSGTYPE_GMGUI,
    MSGTYPE_WORKCMD,
    MSGTYPE_BUDDY_LIST,
    MSGTYPE_BUDDY_STATUS,
    MSGTYPE_MOTD,
    MSGTYPE_MOTDREQUEST,
    MSGTYPE_QUESTION,
    MSGTYPE_QUESTIONRESPONSE,
    MSGTYPE_SLOT_MOVEMENT,
    MSGTYPE_QUESTIONCANCEL,
    MSGTYPE_GUILDMOTDSET,
    MSGTYPE_PLAYSOUND,
    MSGTYPE_CHARACTERDETAILS,
    MSGTYPE_CHARDETAILSREQUEST,
    MSGTYPE_CHARDESCUPDATE,
    MSGTYPE_FACTION_INFO,
    MSGTYPE_QUESTREWARD,
    MSGTYPE_NAMECHANGE,
    MSGTYPE_GUILDCHANGE,
    MSGTYPE_LOCKPICK,
    MSGTYPE_GMSPAWNITEMS,
    MSGTYPE_GMSPAWNTYPES,
    MSGTYPE_GMSPAWNITEM,
    MSGTYPE_ADVICE,
    MSGTYPE_ACTIVEMAGIC,
    MSGTYPE_GROUPCHANGE,
    MSGTYPE_MAPACTION,
    MSGTYPE_CLIENTSTATUS,
    MSGTYPE_TUTORIAL,
    MSGTYPE_BANKING,
    MSGTYPE_CMDDROP,

    // Movement
    MSGTYPE_REQUESTMOVEMENTS,
    MSGTYPE_MOVEINFO,
    MSGTYPE_MOVEMOD,
    MSGTYPE_MOVELOCK,

    // Char creation messages under this
    MSGTYPE_CHAR_DELETE,
    MSGTYPE_CHAR_CREATE_PARENTS,
    MSGTYPE_CHAR_CREATE_CHILDHOOD,
    MSGTYPE_CHAR_CREATE_LIFEEVENTS,
    MSGTYPE_CHAR_CREATE_UPLOAD,
    MSGTYPE_CHAR_CREATE_VERIFY,
    MSGTYPE_CHAR_CREATE_NAME,
    MSGTYPE_PERSIST_WORLD_REQUEST,
    MSGTYPE_PERSIST_WORLD,
    MSGTYPE_PERSIST_ACTOR_REQUEST,
    MSGTYPE_PERSIST_ACTOR,
    MSGTYPE_PERSIST_ITEM,
    MSGTYPE_PERSIST_ACTIONLOCATION,
    MSGTYPE_PERSIST_ALL,
    MSGTYPE_REMOVE_OBJECT,
    MSGTYPE_CHANGE_TRAIT,

    // Internal Server Events here
    MSGTYPE_DAMAGE_EVENT,
    MSGTYPE_DEATH_EVENT,
    MSGTYPE_TARGET_EVENT,
    MSGTYPE_ZPOINT_EVENT,
    MSGTYPE_BUY_EVENT,
    MSGTYPE_SELL_EVENT,
    MSGTYPE_PICKUP_EVENT,
    MSGTYPE_DROP_EVENT,
    MSGTYPE_LOOT_EVENT,
    MSGTYPE_CONNECT_EVENT,
    MSGTYPE_MOVEMENT_EVENT,
    MSGTYPE_GENERIC_EVENT, // catchall for many Tutorial Events

    // Sound Events here
    MSGTYPE_SOUND_EVENT,

    // Char creation message
    MSGTYPE_CHAR_CREATE_TRAITS,
    MSGTYPE_STATS,

    // Pet Related Messages
    MSGTYPE_PET_COMMAND,
    MSGTYPE_PET_SKILL,

    MSGTYPE_CRAFT_INFO,

    MSGTYPE_PETITION_REQUEST,
    MSGTYPE_HEART_BEAT,
    MSGTYPE_NPC_COMMAND,

    // Minigame messages
    MSGTYPE_MINIGAME_STARTSTOP,
    MSGTYPE_MINIGAME_BOARD,
    MSGTYPE_MINIGAME_UPDATE,

    // Entance message type
    MSGTYPE_ENTRANCE,

    // GM Event message
    MSGTYPE_GMEVENT_LIST,
    MSGTYPE_GMEVENT_INFO,

    MSGTYPE_SEQUENCE,
    MSGTYPE_NPCRACELIST,

    MSGTYPE_INTRODUCTION,

    MSGTYPE_CACHEFILE,
    MSGTYPE_DIALOG_MENU,
    MSGTYPE_SIMPLE_STRING,
    MSGTYPE_ORDEREDTEST,
    MSGTYPE_GENERICCMD,

    //Extra value made to new clients
    MSGTYPE_CRAFT_CANCEL,

    //music playing messages
    MSGTYPE_MUSICAL_SHEET,
    MSGTYPE_PLAY_SONG,
    MSGTYPE_STOP_SONG,

    MSGTYPE_SIMPLE_RENDER_MESH,
    MSGTYPE_NPC_WORKDONE,
    MSGTYPE_PATH_NETWORK,
    MSGTYPE_LOCATION,

    // mechanisms
    MSGTYPE_MECS_ACTIVATE,
    
    MSGTYPE_NPC_DELETED,
    MSGTYPE_HIRED_NPC_SCRIPT,

    MSGTYPE_GMSPAWNGETMODS,
    MSGTYPE_GMSPAWNMODS,

    MSGTYPE_ATTACK_QUEUE,
    MSGTYPE_ATTACK_BOOK,
    MSGTYPE_SPECCOMBATEVENT
};

class psMessageCracker;


// Types of system messages
#define MSG_ERROR               0x00000000 // Used for stuff that failed (By default, OnScreen Red)
#define MSG_INFO                0x00010000
#define MSG_INFO_SERVER         0x00010001
#define MSG_RESULT              0x00010002 // Used for things that the user might be interested in (By default, OnScreen Yellow)
#define MSG_OK                  0x00010003 // Used for confimation that the action was accepted (By default, OnScreen Green)
#define MSG_WHO                 0x00010004 // Used for the message with /who content
#define MSG_ACK                 0x00010005 // Used for feedback localy (By default, OnScreen Blue)
#define MSG_INFO_BASE           0x00010006 // System messages that are shown on the "Main" tab
#define MSG_COMBAT              0x00020000
#define MSG_COMBAT_DODGE        0x00020001
#define MSG_COMBAT_BLOCK        0x00020002
#define MSG_COMBAT_HITYOU       0x00020003
#define MSG_COMBAT_HITOTHER     0x00020004
#define MSG_COMBAT_YOURHIT      0x00020005
#define MSG_COMBAT_OTHERHIT     0x00020006
#define MSG_COMBAT_MISS         0x00020007
#define MSG_COMBAT_OWN_DEATH    0x00020008
#define MSG_COMBAT_DEATH        0x00020009
#define MSG_COMBAT_VICTORY      0x0002000a
#define MSG_COMBAT_STANCE       0x0002000b
#define MSG_COMBAT_NEARLY_DEAD  0x0002000c
#define MSG_LOOT                0x00030000
#define MSG_SEC                 0x00300000
#define SEC_LEVEL0              0x00300000
#define SEC_LEVEL1              0x00300001
#define SEC_LEVEL2              0x00300002
#define SEC_LEVEL3              0x00300003
#define SEC_LEVEL4              0x00300004
#define MSG_PURCHASE            0x00400000

#define TOP_SHORT_INT_VAL       65535

class PublishVector;
class MsgHandler;


class psMessageCracker
{
public:
    static MsgHandler* msghandler;

    csRef<MsgEntry> msg;
    bool valid;
    int filterNumber;

    psMessageCracker()
        : msg(NULL),valid(true)
    {}

    virtual ~psMessageCracker() {}

    void SendMessage();

    void Multicast(csArray<PublishDestination> &multi, uint32_t except, float range);

    void FireEvent();

    virtual csString GetMessageTypeName() const = 0;

    virtual csString ToString(NetBase::AccessPointers* accessPointers) = 0;
    //{ return "Not implemented"; }
};

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

// PSF MESSAGE FACTORY stuff

typedef psMessageCracker* (*psfMsgFactoryFunc)(MsgEntry* me, NetBase::AccessPointers* accessPointers);

csString GetMsgTypeName(int msgType);
void DecodeMessage(MsgEntry* me, NetBase::AccessPointers* accessPointers, bool filterhex, csString &msgText, int &filterNumber);

void psfRegisterMsgFactoryFunction(psfMsgFactoryFunc factoryfunc, int msgtype, const char* msgtypename);
void psfUnRegisterMsgFactories(void);
psMessageCracker* psfCreateMsg(int msgtype,
                               MsgEntry* me,
                               NetBase::AccessPointers* accessPointers);
csString psfMsgTypeName(int msgType);
int psfMsgType(const char* msgTypeName);

#define PSF_DECLARE_MSG_FACTORY()                                 \
    virtual csString GetMessageTypeName() const;                  \
    static psMessageCracker* CreateMessage(MsgEntry* me,          \
               NetBase::AccessPointers* accessPointers)

#define PSF_IMPLEMENT_MSG_FACTORY_REGISTER(Class,MsgType)         \
    class Class##_StaticInit                                      \
    {                                                             \
    public:                                                       \
        Class##_StaticInit()                                      \
        {                                                         \
            psfRegisterMsgFactoryFunction (Class::CreateMessage,  \
                                           MsgType,#MsgType);     \
        }                                                         \
    } Class##_static_init__


#define PSF_IMPLEMENT_MSG_FACTORY_CREATE1(Class)                  \
    psMessageCracker* Class::CreateMessage(MsgEntry* me,          \
           NetBase::AccessPointers* /*accessPointers*/)           \
    {                                                             \
        return (psMessageCracker*)new Class(me);                  \
    }

#define PSF_IMPLEMENT_MSG_FACTORY_TYPENAME(Class,MsgType)         \
    csString Class::GetMessageTypeName() const                    \
    {                                                             \
        return #MsgType;                                          \
    }

#define PSF_IMPLEMENT_MSG_FACTORY(Class,MsgType)                  \
    PSF_IMPLEMENT_MSG_FACTORY_TYPENAME(Class,MsgType)             \
    PSF_IMPLEMENT_MSG_FACTORY_CREATE1(Class)                      \
    PSF_IMPLEMENT_MSG_FACTORY_REGISTER(Class,MsgType)

#define PSF_IMPLEMENT_MSG_FACTORY_CREATE2(Class)                  \
    psMessageCracker* Class::CreateMessage(MsgEntry* me,          \
           NetBase::AccessPointers* a_p)                          \
    {                                                             \
        return (psMessageCracker*)new Class(me, a_p);             \
    }

#define PSF_IMPLEMENT_MSG_FACTORY_ACCESS_POINTER(Class,MsgType)   \
    PSF_IMPLEMENT_MSG_FACTORY_TYPENAME(Class,MsgType)             \
    PSF_IMPLEMENT_MSG_FACTORY_CREATE2(Class)                      \
    PSF_IMPLEMENT_MSG_FACTORY_REGISTER(Class,MsgType)

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

class psMarriageMsgPropose : public psMessageCracker
{
public:
    psMarriageMsgPropose(const char* charName, const char* proposeMessage,
                         uint32_t clientNum = 0);
    psMarriageMsgPropose(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    csString charName;      
    csString proposeMsg;  
};

class psMarriageMsgDivorce : public psMessageCracker
{
public:
    psMarriageMsgDivorce(const char* divorceMessage, uint32_t clientNum = 0);
    psMarriageMsgDivorce(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    csString divorceMsg;  
};

class psMarriageMsgDivorceConfirm : public psMessageCracker
{
public:
    psMarriageMsgDivorceConfirm(uint32_t clientNum = 0);
    psMarriageMsgDivorceConfirm(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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


class psCharDeleteMessage : public psMessageCracker
{
public:
    psCharDeleteMessage(const char* charNameToDel, uint32_t clientNum);
    psCharDeleteMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    csString charName;
};

class psPreAuthenticationMessage : public psMessageCracker
{
public:
    uint32_t  netversion;
    psPreAuthenticationMessage(uint32_t clientnum,uint32_t version=PS_NETVERSION);
    psPreAuthenticationMessage(MsgEntry* message);


    PSF_DECLARE_MSG_FACTORY();

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

    bool NetVersionOk();
};

class psAuthenticationMessage : public psMessageCracker
{
public:
    uint32_t  netversion;
    csString  sAddr,
              sUser,
              sPassword,
              sPassword256,
              os_,
              os_platform,
              machine_type,
              gfxcard_, gfxversion_;
    uint16    os_ver_major,
              os_ver_minor;

    psAuthenticationMessage(uint32_t clientnum,const char* userid,
                            const char* password, const char* os, uint16 os_ver_major, uint16 os_ver_minor, const char *os_platform, const char *machine_type, const char* gfxcard, const char* gfxversion, const char* sPassword256 = "", uint32_t version=PS_NETVERSION);

    psAuthenticationMessage(MsgEntry* message);


    PSF_DECLARE_MSG_FACTORY();

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

    bool NetVersionOk();
};

class psCharacterPickerMessage : public psMessageCracker
{
public:
    psCharacterPickerMessage(const char* character);
    psCharacterPickerMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    csString characterName;
};

class psCharacterApprovedMessage : public psMessageCracker
{
public:
    psCharacterApprovedMessage(uint32_t clientnum);
    psCharacterApprovedMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

class psPreAuthApprovedMessage : public psMessageCracker
{
public:

    uint32_t  ClientNum;
    psPreAuthApprovedMessage(uint32_t clientnum);

    psPreAuthApprovedMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

};

class psAuthApprovedMessage : public psMessageCracker
{
public:
    uint32_t msgClientValidToken;
    PID msgPlayerID;

    uint8_t msgNumOfChars;

    psAuthApprovedMessage(uint32_t clientnum, PID playerID, uint8_t numCharacters);

    psAuthApprovedMessage(MsgEntry* message);

    void AddCharacter(const char* fullname, const char* race,
                      const char* mesh, const char* traits, const char* equipment);

    void GetCharacter(MsgEntry* message,csString &fullname, csString &race,
                      csString &mesh, csString &traits,csString &equipment);

    void ConstructMsg();

    PSF_DECLARE_MSG_FACTORY();

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

private:
    csStringArray contents;
};


class psAuthRejectedMessage : public psMessageCracker
{
public:
    csString msgReason;

    psAuthRejectedMessage(uint32_t clientToken,const char* reason);

    psAuthRejectedMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

};

enum
{
    CHAT_SYSTEM,
    CHAT_COMBAT,
    CHAT_SAY,
    CHAT_TELL,
    CHAT_GROUP,
    CHAT_GUILD,
    CHAT_ALLIANCE,
    CHAT_AUCTION,
    CHAT_SHOUT,
    CHAT_CHANNEL,
    CHAT_TELLSELF,
    CHAT_REPORT,
    CHAT_ADVISOR,
    CHAT_ADVICE,
    CHAT_ADVICE_LIST,
    CHAT_SERVER_TELL,      
    CHAT_GM,
    CHAT_SERVER_INFO,
    CHAT_NPC,
    CHAT_NPCINTERNAL,
    CHAT_SYSTEM_BASE,      
    CHAT_PET_ACTION,
    CHAT_NPC_ME,
    CHAT_NPC_MY,
    CHAT_NPC_NARRATE,
    CHAT_AWAY,             
    CHAT_END
};

class psChatMessage : public psMessageCracker
{
public:
    uint8_t  iChatType;

    csString  sPerson;

    csString sOther;

    csString  sText;

    bool translate;

    EID actor;

    uint16_t channelID;

    psChatMessage(uint32_t cnum, EID actorid, const char* person, const char* other, const char* chatMessage,
                  uint8_t type, bool translate, uint16_t channelID = 0);

    psChatMessage(MsgEntry* message);


    PSF_DECLARE_MSG_FACTORY();

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

    const char* GetTypeText();
};

class psChannelJoinMessage : public psMessageCracker
{
public:
    csString channel;
    psChannelJoinMessage(const char* name);
    psChannelJoinMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

class psChannelJoinedMessage : public psMessageCracker
{
public:
    uint16_t id;
    csString channel;
    psChannelJoinedMessage(uint32_t clientnum, const char* name, uint16_t id);
    psChannelJoinedMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

class psChannelLeaveMessage : public psMessageCracker
{
public:
    uint16_t chanID;
    psChannelLeaveMessage(uint16_t id);
    psChannelLeaveMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();


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

#define MAXSYSTEMMSGSIZE 1024

class psSystemMessage : public psMessageCracker
{
protected:
    psSystemMessage() {}
public:
    csString msgline;
    uint32_t type;

    psSystemMessage(uint32_t clientnum, uint32_t msgtype, const char* fmt, ...);
    psSystemMessage(uint32_t clientnum, uint32_t msgtype, const char* fmt, va_list args);
    psSystemMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

class psSystemMessageSafe : public psSystemMessage
{
public:
    psSystemMessageSafe(uint32_t clientnum, uint32_t msgtype,
                        const char* text);
};

struct psPetitionInfo
{
    int id;                 
    csString petition;      
    csString status;        
    csString assignedgm;    

    int escalation;         
    csString player;        
    csString created;       
    csString resolution;    

    bool online;            
};

enum
{
    PETITION_LIST = 0,      
    PETITION_CANCEL = 1,    
    PETITION_CLOSE = 2,     
    PETITION_CHANGE = 3,    
    PETITION_ASSIGN = 4,    
    PETITION_DEASSIGN = 5,  
    PETITION_ESCALATE = 6,  
    PETITION_DESCALATE = 7, 
    PETITION_DIRTY = 8      
};

class psPetitionMessage : public psMessageCracker
{
public:
    csArray<psPetitionInfo> petitions;
    bool success;
    csString error;
    int msgType;
    bool isGM;

    psPetitionMessage()
    {
        msgType = PETITION_LIST;
    }
    psPetitionMessage(uint32_t clientnum, csArray<psPetitionInfo>* petitionArray, const char* errMsg,
                      bool succeed = true, int type = PETITION_LIST, bool gm = false);
    psPetitionMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

class psPetitionRequestMessage: public psMessageCracker
{
public:
    bool isGM;
    csString request;
    csString desc;
    int id;

    psPetitionRequestMessage(bool gm, const char* requestCmd, int petitionID = -1, const char* petDesc = "");
    psPetitionRequestMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

class psGMGuiMessage : public psMessageCracker
{
public:

    struct PlayerInfo
    {
        csString name;
        csString lastName;
        int gender;
        csString guild;
        csString sector;
    };

    int gmSettings;
    csArray<PlayerInfo> players;
    int type;

    enum
    {
        TYPE_QUERYPLAYERLIST,
        TYPE_PLAYERLIST,
        TYPE_GETGMSETTINGS
    };

    psGMGuiMessage(uint32_t clientnum, int gmSets);
    psGMGuiMessage(uint32_t clientnum, csArray<PlayerInfo>* playerArray, int type);
    psGMGuiMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

//--------------------------------------------------------------------------

class psGuildCmdMessage : public psMessageCracker
{
public:
    csString command, subCmd, permission, guildname, player, levelname, accept, secret, web_page,motd, alliancename;
    int level;


    psGuildCmdMessage(const char* cmd);
    psGuildCmdMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

//--------------------------------------------------------------------------

class psGUIGuildMessage : public psMessageCracker
{
public:
    enum Command { SUBSCRIBE_GUILD_DATA,       
                   UNSUBSCRIBE_GUILD_DATA,     
                   SET_ONLINE,                 

                   GUILD_DATA,                 
                   LEVEL_DATA,                 
                   MEMBER_DATA,                
                   ALLIANCE_DATA,              

                   CLOSE_WINDOW,               

                   NOT_IN_GUILD,               

                   SET_LEVEL_RIGHT,            

                   SET_MEMBER_POINTS,          
                   SET_MAX_GUILD_POINTS,       
                   SET_MEMBER_PUBLIC_NOTES,
                   SET_MEMBER_PRIVATE_NOTES,

                   SET_GUILD_NOTIFICATION,      
                   SET_ALLIANCE_NOTIFICATION      
                 };

    psGUIGuildMessage(uint32_t command,
                      csString commandData);

    psGUIGuildMessage(uint32_t clientNum,
                      uint32_t command,
                      csString commandData);

    psGUIGuildMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    uint32_t command;
    csString commandData;
};

//--------------------------------------------------------------------------

class psGroupCmdMessage : public psMessageCracker
{
public:
    csString command,player,accept;

    psGroupCmdMessage(const char* cmd);
    psGroupCmdMessage(uint32_t clientnum,const char* cmd);
    psGroupCmdMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

//--------------------------------------------------------------------------

class psUserCmdMessage : public psMessageCracker
{
public:
    csString command,player,filter,action,text,target,attack;
    int dice,sides,dtarget;
    int level;
    csString stance;

    psUserCmdMessage(const char* cmd);
    psUserCmdMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

//--------------------------------------------------------------------------

class psWorkCmdMessage : public psMessageCracker
{
public:
    csString command;
    csString player;
    csString filter;

    csString repairSlotName;        

    psWorkCmdMessage(const char* cmd);
    psWorkCmdMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

//--------------------------------------------------------------------------

class psAdminCmdMessage : public psMessageCracker
{
public:
    csString cmd;

    psAdminCmdMessage(const char* cmd);
    psAdminCmdMessage(const char* cmd, uint32_t client = 0);

    psAdminCmdMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

//--------------------------------------------------------------------------

class psGenericCmdMessage : public psMessageCracker
{
public:
    csString cmd;

    psGenericCmdMessage(const char* cmd);
    psGenericCmdMessage(const char* cmd, uint32_t client = 0);

    psGenericCmdMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

//--------------------------------------------------------------------------
class psDisconnectMessage : public psMessageCracker
{
public:
    EID actor;
    csString msgReason;

    psDisconnectMessage(uint32_t clientnum, EID actorid, const char* reason);
    psDisconnectMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

//--------------------------------------------------------------------------

class psUserActionMessage : public psMessageCracker
{
public:
    EID target;
    csString action;
    csString dfltBehaviors;

    psUserActionMessage(uint32_t clientnum, EID target, const char* action, const char* dfltBehaviors="");
    psUserActionMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

//---------------------------------------------------------------------------

class psGUIInteractMessage : public psMessageCracker
{
public:
    psGUIInteractMessage(uint32_t clientnum, uint32_t options, csString command = "");
    psGUIInteractMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    enum guiOptions
    {
        PICKUP      = 0x00000001,
        EXAMINE     = 0x00000002,
        UNLOCK      = 0x00000004,
        LOOT        = 0x00000008,
        BUYSELL     = 0x00000010,
        GIVE        = 0x00000020,
        CLOSE       = 0x00000040,
        USE         = 0x00000080,
        PLAYERDESC  = 0x00000100,
        ATTACK      = 0x00000200,
        COMBINE     = 0x00000400,
        EXCHANGE    = 0x00000800,
        TRAIN       = 0x00001000,
        NPCTALK     = 0x00002000,
        // Pet Commands
        VIEWSTATS   = 0x00004000,
        DISMISS     = 0x00008000,
        // Marriage
        MARRIAGE    = 0x00010000,
        DIVORCE     = 0x00020000,
        // Stuff
        PLAYGAME    = 0x00040000,
        ENTER       = 0x00080000,
        LOCK        = 0x00100000,
        ENTERLOCKED = 0x00200000,
        BANK        = 0x00400000,
        INTRODUCE   = 0x00800000,
        CONSTRUCT   = 0x01000000,
        MOUNT       = 0x02000000,
        UNMOUNT     = 0x04000000,
        STORAGE     = 0x08000000,
        GENERIC     = 0x10000000
    };

public:
    uint32_t options;
    csString genericCommand;
};

//--------------------------------------------------------------------------

class psMapActionMessage : public psMessageCracker
{
public:

    uint32_t command;
    enum commands
    {
        QUERY,
        NOT_HANDLED,
        SAVE,
        LIST,
        LIST_QUERY,
        DELETE_ACTION,
        RELOAD_CACHE
    };

    csStringFast<1024> actionXML;

    // ctor
    psMapActionMessage(uint32_t clientnum, uint32_t cmd, const char* xml);

    // cracker
    psMapActionMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

//---------------------------------------------------------------------------
class psAttackQueueMessage : public psMessageCracker
{
public:
    struct AAttack
    {
        csString Name;
        csString Image;
    };
    psAttackQueueMessage();
    psAttackQueueMessage(uint32_t clientnum);
    psAttackQueueMessage( MsgEntry* me, NetBase::AccessPointers* accessPointers );

    PSF_DECLARE_MSG_FACTORY();

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

    void AddAttack(const csString& name, const csString& image);
    void Construct(csStringSet* msgstrings);

    csArray<AAttack> attacks;
private:
    uint32_t client;
    uint32_t size;

};
//---------------------------------------------------------------------------
class psModeMessage : public psMessageCracker
{
public:
    psModeMessage(uint32_t clientnum, EID actorID, uint8_t mode, uint32_t value);
    psModeMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    enum playerMode
    {
        PEACE = 1,
        COMBAT,
        SPELL_CASTING,
        WORK,
        DEAD,
        SIT,
        OVERWEIGHT,
        EXHAUSTED,
        DEFEATED,
        STATUE,
        PLAY,
        WALK,
        RUN
    };

public:
    EID actorID;
    uint8_t mode;
    uint32_t value; 
};

//---------------------------------------------------------------------------

class psMoveLockMessage : public psMessageCracker
{
public:
    psMoveLockMessage(uint32_t clientnum, bool locked);
    psMoveLockMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

public:
    bool locked;
};

//---------------------------------------------------------------------------

class psWeatherMessage : public psMessageCracker
{
public:
    enum playerMode
    {
        DAYNIGHT = 1,
        WEATHER  = 2
    };

    enum Weather
    {
        RAIN = 4,
        SNOW = 8,
        FOG = 16,
        LIGHTNING = 32
    };

    struct NetWeatherInfo
    {
        bool has_downfall;
        bool downfall_is_snow;
        bool has_fog;
        bool has_lightning;
        csString sector;
        int downfall_drops; // 0 = no downfall
        int downfall_fade;
        int fog_density;    // 0 = no fog
        int fog_fade;
        int r,g,b;          // For fog
    };

    psWeatherMessage(uint32_t client, psWeatherMessage::NetWeatherInfo info , uint clientnum = 0);
    psWeatherMessage(uint32_t client, int minute, int hour, int day, int month, int year);
    psWeatherMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

public:
    int type;

    uint minute;
    uint hour;
    uint day;
    uint month;
    uint year;

    NetWeatherInfo weather;
};


//---------------------------------------------------------------------------

class psGUIInventoryMessage : public psMessageCracker
{
public:
    enum commands
    {
        LIST,               
        REQUEST,            
        UPDATE_REQUEST,     
        UPDATE_LIST         
    };

    // One of the commands as defined above.
    uint8_t command;

    psGUIInventoryMessage(uint8_t command = REQUEST, uint32_t size=0);


    psGUIInventoryMessage(uint32_t clientNum,
                          uint8_t command,
                          uint32_t totalItems,
                          uint32_t totalEmptiedSlots,
                          float maxWeight,
                          uint32_t cache_version,
                          size_t msgsize);


    psGUIInventoryMessage(MsgEntry* message, NetBase::AccessPointers* accessPointers);

    PSF_DECLARE_MSG_FACTORY();

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


    void AddItem(const char* name,
                 const char* meshName,
                 const char* materialName,
                 int containerID,
                 int slot,
                 int stackcount,
                 float weight,
                 float size,
                 const char* icon,
                 int purifyStatus,
                 csStringSet* msgstrings);

    void AddEmptySlot(int containerID, int slotID);

    void AddMoney(const psMoney &money);

    // Used in a move message.

    struct ItemDescription
    {
        csString name;
        csString meshName;
        csString materialName;
        int slot;
        float weight;
        float size;
        int stackcount;
        csString iconImage;
        int container;
        int purifyStatus;
    };

    // Item list
    csArray<ItemDescription> items;
    size_t totalItems;
    size_t totalEmptiedSlots;
    float maxWeight;    
    psMoney money;
    uint32 version;     
};

//---------------------------------------------------------------------------

class psNewSectorMessage : public psMessageCracker
{
public:
    psNewSectorMessage(const csString &oldSector, const csString &newSector, csVector3 pos, bool use_yrot = false, float yrot = 0.0);
    psNewSectorMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

public:
    csString oldSector, newSector;
    csVector3 pos;
    float yrot;              
    bool use_yrot;           
};

//---------------------------------------------------------------------------

class psLootItemMessage : public psMessageCracker
{
public:
    enum
    {
        LOOT_SELF,
        LOOT_ROLL
    };
    psLootItemMessage(int client, EID entity, int item, int action);
    psLootItemMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    EID entity;
    int lootitem;
    int lootaction;
};

//---------------------------------------------------------------------------

class psLootMessage : public psMessageCracker
{
public:
    psLootMessage();
    psLootMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    void Populate(EID entity, csString &lootstr, int cnum);

    EID entity_id;
    csString lootxml;
};

//---------------------------------------------------------------------------

class psQuestListMessage : public psMessageCracker
{
public:
    psQuestListMessage();
    psQuestListMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    void Populate(csString &queststr, int cnum);

    csString questxml;
};

//---------------------------------------------------------------------------

class psQuestInfoMessage : public psMessageCracker
{
public:
    enum
    {
        CMD_QUERY,
        CMD_INFO,
        CMD_DISCARD
    };
    psQuestInfoMessage(int cnum, int cmd, int id, const char* name,const char* info);
    psQuestInfoMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    int command,id;
    csString xml;
};

//---------------------------------------------------------------------------

class psOverrideActionMessage : public psMessageCracker
{
public:
    psOverrideActionMessage(int client, EID entity, const char* action, int duration = 0);
    psOverrideActionMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    EID entity_id;
    csString action;
    int duration;
};

//---------------------------------------------------------------------------


//--------------------------------------------------------------------------

class psEquipmentMessage : public psMessageCracker
{
public:
    enum Command { EQUIP, DEEQUIP };

    psEquipmentMessage(uint32_t clientNum,
                       EID actorid,
                       uint8_t type,
                       int slot,
                       csString &mesh,
                       csString &part,
                       csString &texture,
                       csString &partMesh,
                       csString &removedMesh);


    psEquipmentMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    uint8_t type;
    int player;
    csString mesh;
    int slot;
    csString part;
    csString texture;
    csString partMesh; /* Set if the body part given by pattern given in part
                          should be replaced with this */
    csString removedMesh; 
};

//--------------------------------------------------------------------------

//--------------------------------------------------------------------------

class psGUIMerchantMessage : public psMessageCracker
{
public:
    enum Command { REQUEST,
                   MERCHANT,
                   CATEGORIES,
                   CATEGORY,
                   MONEY,
                   ITEMS,
                   BUY,
                   SELL,
                   VIEW,
                   CANCEL
                 };

    psGUIMerchantMessage(uint32_t clientNum,
                         uint8_t command,
                         csString commandData);

    psGUIMerchantMessage(uint8_t command,
                         csString commandData);

    psGUIMerchantMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    uint8_t command;
    csString commandData;
};

//--------------------------------------------------------------------------

class psGUIStorageMessage : public psMessageCracker
{
public:
    enum Command { REQUEST,
                   STORAGE,
                   CATEGORIES,
                   CATEGORY,
                   MONEY,
                   ITEMS,
                   WITHDRAW,
                   STORE,
                   VIEW,
                   CANCEL
                 };

    psGUIStorageMessage(uint32_t clientNum,
                        uint8_t command,
                        csString commandData);

    psGUIStorageMessage(uint8_t command,
                        csString commandData);

    psGUIStorageMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    uint8_t command;
    csString commandData;
};

//--------------------------------------------------------------------------

class psGUIGroupMessage : public psMessageCracker
{
public:
    enum Command { GROUP,
                   MEMBERS,
                   LEAVE
                 };

    psGUIGroupMessage(uint32_t clientNum,
                      uint8_t command,
                      csString commandData);

    psGUIGroupMessage(uint8_t command,
                      csString commandData);

    psGUIGroupMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    uint8_t command;
    csString commandData;
};

class psSpellCancelMessage : public psMessageCracker
{
public:
    psSpellCancelMessage()
    {
        msg.AttachNew(new MsgEntry());
        msg->SetType(MSGTYPE_SPELL_CANCEL);
        msg->clientnum = 0;
    }
    psSpellCancelMessage(MsgEntry* /*message*/) {};

    PSF_DECLARE_MSG_FACTORY();

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

//--------------------------------------------------------------------------
class psCraftCancelMessage : public psMessageCracker
{
public:
    psCraftCancelMessage()
    {
        msg.AttachNew(new MsgEntry());
        msg->SetType(MSGTYPE_CRAFT_CANCEL);
        msg->clientnum = 0;
    }
    psCraftCancelMessage(MsgEntry* message)
    {
        craftTime = message->GetInt32();
    }

    PSF_DECLARE_MSG_FACTORY();

    void SetCraftTime(int craftTime, uint32_t client);
    virtual csString ToString(NetBase::AccessPointers* accessPointers);

    int craftTime;
};

//--------------------------------------------------------------------------

class psAttackBookMessage : public psMessageCracker
{
public:
    struct NetworkAttack
    {
        csString name;
        csString description;
        csString type;
        csString image;
    };

    psAttackBookMessage();
    psAttackBookMessage( uint32_t client );
    psAttackBookMessage( MsgEntry* me, NetBase::AccessPointers* accessPointers );

    PSF_DECLARE_MSG_FACTORY();


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

    void AddAttack(const csString& name, const csString& description, const csString& type, const csString& image);
    void Construct(csStringSet* msgstrings);

    csArray<NetworkAttack> attacks;

private:
    uint32_t size;
    uint32_t client;
};
//--------------------------------------------------------------------------
class psSpellBookMessage : public psMessageCracker
{
public:
    struct NetworkSpell
    {
        csString name;
        csString description;
        csString way;
        int realm;
        csString glyphs[4];
        csString image;
    };

    psSpellBookMessage();
    psSpellBookMessage(uint32_t client);
    psSpellBookMessage(MsgEntry* me, NetBase::AccessPointers* accessPointers);

    PSF_DECLARE_MSG_FACTORY();

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

    void AddSpell(const csString &name, const csString &description, const csString &way, int realm, const csString &glyph0, const csString &glyph1, const csString &glyph2, const csString &glyph3, const csString &image);
    void Construct(csStringSet* msgstrings);

    csArray<NetworkSpell> spells;

private:
    uint32_t size;
    uint32_t client;
};

//--------------------------------------------------------------------------

class psPurifyGlyphMessage : public psMessageCracker
{
public:
    psPurifyGlyphMessage(uint32_t glyphID);
    psPurifyGlyphMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    uint32_t glyph;
};

//--------------------------------------------------------------------------

class psSpellCastMessage : public psMessageCracker
{
public:
    psSpellCastMessage(csString &spellName, float kFactor);
    psSpellCastMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    csString spell;
    float kFactor;
};


//--------------------------------------------------------------------------
class psGlyphAssembleMessage : public psMessageCracker
{
public:
    psGlyphAssembleMessage() {}

    psGlyphAssembleMessage(int slot0, int slot1, int slot2, int slot3, bool info = false);
    psGlyphAssembleMessage(uint32_t clientNum,
                           csString spellName, csString image, csString description);
    psGlyphAssembleMessage(MsgEntry* me);
    void FromClient(MsgEntry* me);
    void FromServer(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    int glyphs[4];
    bool info;
    csString description;
    csString name;
    csString image;

private:
    bool msgFromServer;
};



class psRequestGlyphsMessage : public psMessageCracker
{
public:
    struct NetworkGlyph
    {
        csString name;
        csString image;
        uint32_t purifiedStatus;
        uint32_t way;
        uint32_t statID;
    };


    psRequestGlyphsMessage(uint32_t client = 0);
    psRequestGlyphsMessage(MsgEntry* me);
    virtual ~psRequestGlyphsMessage();

    PSF_DECLARE_MSG_FACTORY();

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

    void AddGlyph(csString name, csString image, int purifiedStatus,
                  int way, int statID);

    void Construct();

    csArray<NetworkGlyph> glyphs;
private:
    size_t size;
    uint32_t client;

};


//--------------------------------------------------------------------------
class psStopEffectMessage : public psMessageCracker
{
public:
    psStopEffectMessage(uint32_t clientNum, uint32_t uid)
    {
        msg.AttachNew(new MsgEntry(sizeof(uint32_t)));

        msg->SetType(MSGTYPE_EFFECT_STOP);
        msg->clientnum = clientNum;
        msg->Add(uid);
        valid = !(msg->overrun);
    }

    psStopEffectMessage(uint32_t uid)
    {
        msg.AttachNew(new MsgEntry(sizeof(uint32_t)));

        msg->SetType(MSGTYPE_EFFECT_STOP);
        msg->clientnum = 0;
        msg->Add(uid);
        valid = !(msg->overrun);
    }

    psStopEffectMessage(MsgEntry* message)
    {
        if(!message)
            return;

        uid = message->GetUInt32();
    }

    PSF_DECLARE_MSG_FACTORY();
    csString ToString(NetBase::AccessPointers* /*accessPointers*/)
    {
        csString msgtext;
        msgtext.AppendFmt("Effect ID: %d", uid);
        return msgtext;
    }

    uint32_t uid;
};


class psEffectMessage : public psMessageCracker
{
public:

    psEffectMessage(uint32_t clientNum, const csString &effectName,
                    const csVector3 &effectOffset, EID anchorID,
                    EID targetID, uint32_t uid, float scale1 = 0.0, float scale2 = 0.0, float scale3 = 0.0, float scale4 = 0.0);

    psEffectMessage(uint32_t clientNum, const csString &effectName,
                    const csVector3 &effectOffset, EID anchorID,
                    EID targetID, uint32_t duration, uint32_t uid, float scale1 = 0.0, float scale2 = 0.0, float scale3 = 0.0, float scale4 = 0.0);

    psEffectMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    csString  name;
    csVector3 offset;
    EID       anchorID;
    EID       targetID;
    uint32_t  duration;
    uint32_t  uid;
    float     scale[4]; // Scales of the effect, not sent on network if 0.
};

//--------------------------------------------------------------------------

class psGUITargetUpdateMessage : public psMessageCracker
{
public:
    psGUITargetUpdateMessage(uint32_t clientNum, EID targetID);

    psGUITargetUpdateMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    uint32_t clientNum;
    EID targetID;
};


class psMsgStringsMessage : public psMessageCracker
{
public:
    csStringHashReversible* msgstrings;

    psMsgStringsMessage();

    psMsgStringsMessage(uint32_t clientnum, csMD5::Digest &digest);

    psMsgStringsMessage(uint32_t clientnum, csMD5::Digest &digest, char* stringsdata,
                        unsigned long size, uint32_t num_strings);

    psMsgStringsMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    csMD5::Digest* digest;
    bool only_carrying_digest;

private:
    uint32_t nstrings;
};

#if 0

class psCharacterDataMessage : public psMessageCracker
{
public:
    csString fullname;
    csString race_name;
    csString mesh_name;
    csString traits;
    csString equipment;

    psCharacterDataMessage(uint32_t clientnum,
                           csString fullname,
                           csString race_name,
                           csString mesh_name,
                           csString traits,
                           csString equipment);

    psCharacterDataMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

class psSpecialCombatEventMessage : public psMessageCracker
{
public:
    EID        attacker_id;
    EID        target_id;
    int        attack_anim;
    int        defense_anim;

    psSpecialCombatEventMessage(uint32_t clientnum,
                         EID attacker,
                         EID target,
                         int attack_anim,
                         int defense_anim);

    void SetClientNum(int cnum);

    psSpecialCombatEventMessage(MsgEntry *message);

    PSF_DECLARE_MSG_FACTORY();

    virtual csString ToString(NetBase::AccessPointers* accessPointers);
};
class psCombatEventMessage : public psMessageCracker
{
public:
    int        event_type;
    EID        attacker_id;
    EID        target_id;
    int        target_location; // Where on the target the attack hit/miss
    float      damage;
    int        attack_anim;
    int        defense_anim;
    enum
    {
        COMBAT_DODGE,
        COMBAT_BLOCK,
        COMBAT_DAMAGE,
        COMBAT_MISS,
        COMBAT_OUTOFRANGE,
        COMBAT_DEATH,
        COMBAT_DAMAGE_NEARLY_DEAD       // This is equal to COMBAT_DAMAGE plus the target is nearly dead
    };

    psCombatEventMessage(uint32_t clientnum,
                         int event_type,
                         EID attacker,
                         EID target,
                         int target_location,
                         float damage,
                         int attack_anim,
                         int defense_anim);

    void SetClientNum(int cnum);

    psCombatEventMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

//--------------------------------------------------------------------------

class psSoundEventMessage : public psMessageCracker
{
public:
    uint32_t type;
    psSoundEventMessage(uint32_t clientnum, uint32_t type);

    psSoundEventMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

class psStatDRMessage : public psMessageCracker
{
public:
    psStatDRMessage(uint32_t clientnum, EID eid, csArray<float> fVitals, csArray<uint32_t> uiVitals, uint8_t version, int flags);

    psStatDRMessage();

    psStatDRMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    bool request; // Set to true if this is a request
    EID entityid;
    uint32_t statsDirty;
    uint8_t counter;

    float hp,hp_rate,mana,mana_rate,pstam,pstam_rate;
    float mstam,mstam_rate,exp,prog;
};

//--------------------------------------------------------------------------

class psStatsMessage : public psMessageCracker
{
public:
    psStatsMessage(uint32_t client, float maxHP, float maxMana, float maxWeight, float maxCapacity);

    psStatsMessage(MsgEntry* me);

    psStatsMessage();

    PSF_DECLARE_MSG_FACTORY();

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

    bool  request; // True if this is a request for stats
    float hp;
    float mana;
    float weight;
    float capacity;
};




//--------------------------------------------------------------------------

class psGUISkillMessage : public psMessageCracker
{
public:
    enum Command { REQUEST,
                   BUY_SKILL,
                   SKILL_LIST,
                   SKILL_SELECTED,
                   DESCRIPTION,
                   QUIT
                 };

    static const char* SkillCommandString[];

    psGUISkillMessage(uint8_t command,
                      csString commandData);

    psGUISkillMessage(uint32_t clientNum,
                      uint8_t command,
                      csString commandData,
                      psSkillCache* skills,
                      uint32_t str,
                      uint32_t end,
                      uint32_t agi,
                      uint32_t inl,
                      uint32_t wil,
                      uint32_t chr,
                      uint32_t hp,
                      uint32_t man,
                      uint32_t physSta,
                      uint32_t menSta,
                      uint32_t hpMax,
                      uint32_t manMax,
                      uint32_t physStaMax,
                      uint32_t menStaMax,
                      bool open,
                      int32_t focus,
                      int32_t selSkillCat,
                      bool isTraining);

    psGUISkillMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    uint8_t command;
    csString commandData;
    psSkillCache skillCache;

    unsigned int strength;
    unsigned int endurance;
    unsigned int agility;
    unsigned int intelligence;
    unsigned int will;
    unsigned int charisma;
    unsigned int hitpoints;
    unsigned int mana;
    unsigned int physStamina;
    unsigned int menStamina;

    unsigned int hitpointsMax;
    unsigned int manaMax;
    unsigned int physStaminaMax;
    unsigned int menStaminaMax;
    bool openWindow;
    int32_t focusSkill;
    int32_t skillCat;
    bool trainingWindow; //Are we training or not?

private:
    bool includeStats;
};


//--------------------------------------------------------------------------

class psGUIBankingMessage : public psMessageCracker
{
public:
    enum Command { WITHDRAWFUNDS,
                   DEPOSITFUNDS,
                   EXCHANGECOINS,
                   VIEWBANK
                 };

        // Used to display information in the bankwindow with psGUIBankingMessage::VIEWBANK
    psGUIBankingMessage(uint32_t clientNum,
                        uint8_t command,
                        bool guild,
                        int circlesBanked,
                        int octasBanked,
                        int hexasBanked,
                        int triasBanked,
                        int circles,
                        int octas,
                        int hexas,
                        int trias,
                        int maxCircles,
                        int maxOctas,
                        int maxHexas,
                        int maxTrias,
                        float exchangeFee,
                        bool forceOpen);

        // Used to withdraw or deposit with psGUIBankingMessage::WITHDRAWFUNDS or psGUIBankingMessage::DEPOSITFUNDS
    psGUIBankingMessage(uint8_t command,
                        bool guild,
                        int circles,
                        int octas,
                        int hexas,
                        int trias);

        // Used to exchange coins with psGUIBankingMessage::EXCHANGECOINS
    psGUIBankingMessage(uint8_t command,
                        bool guild,
                        int coins,
                        int coin);

    psGUIBankingMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    uint8_t command;
    bool guild;
    int circlesBanked;
    int octasBanked;
    int hexasBanked;
    int triasBanked;
    int circles;
    int octas;
    int hexas;
    int trias;
    int maxCircles;
    int maxOctas;
    int maxHexas;
    int maxTrias;
    int coins;
    int coin;
    float exchangeFee;
    bool openWindow;

private:
    bool sendingFull;
    bool sendingExchange;
};

//--------------------------------------------------------------------------

class psPetSkillMessage : public psMessageCracker
{
public:
    enum Command { REQUEST,
                   BUY_SKILL,
                   SKILL_LIST,
                   SKILL_SELECTED,
                   DESCRIPTION,
                   QUIT
                 };

    psPetSkillMessage(uint8_t command,
                      csString commandData);

    psPetSkillMessage(uint32_t clientNum,
                      uint8_t command,
                      csString commandData,
                      uint32_t str,
                      uint32_t end,
                      uint32_t agi,
                      uint32_t inl,
                      uint32_t wil,
                      uint32_t chr,
                      uint32_t hp,
                      uint32_t man,
                      uint32_t physSta,
                      uint32_t menSta,
                      uint32_t hpMax,
                      uint32_t manMax,
                      uint32_t physStaMax,
                      uint32_t menStaMax,
                      bool open,
                      int32_t focus);

    psPetSkillMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    uint8_t command;
    csString commandData;

    unsigned int strength;
    unsigned int endurance;
    unsigned int agility;
    unsigned int intelligence;
    unsigned int will;
    unsigned int charisma;
    unsigned int hitpoints;
    unsigned int mana;
    unsigned int physStamina;
    unsigned int menStamina;

    unsigned int hitpointsMax;
    unsigned int manaMax;
    unsigned int physStaminaMax;
    unsigned int menStaminaMax;
    bool openWindow;
    int32_t focusSkill;

private:
    bool includeStats;
};

//-----------------------------------------------------------------------------

class psDRMessage : public psMessageCracker
{
protected:
    void WriteDRInfo(uint32_t client, EID mappedid,
                     bool on_ground, uint8_t mode, uint8_t counter,
                     const csVector3 &pos, float yrot, iSector* sector,
                     csString sectorName, const csVector3 &vel, csVector3 &worldVel,
                     float ang_vel, csStringSet* msgstrings, bool donewriting=true);
    void ReadDRInfo(MsgEntry* me, NetBase::AccessPointers* accessPointers);
    void CreateMsgEntry(uint32_t client, NetBase::AccessPointers* accessPointers, iSector* sector, csString sectorName);

    enum DRDataFlags
    {
        NOT_MOVING      = 0,
        ACTOR_MODE      = 1 << 0,
        ANG_VELOCITY    = 1 << 1,
        X_VELOCITY      = 1 << 2,
        Y_VELOCITY      = 1 << 3,
        Z_VELOCITY      = 1 << 4,
        X_WORLDVELOCITY = 1 << 5,
        Y_WORLDVELOCITY = 1 << 6,
        Z_WORLDVELOCITY = 1 << 7,
        ALL_DATA        = ~0
    };

    enum { ON_GOUND = 128 }; 

    static uint8_t GetDataFlags(const csVector3 &v, const csVector3 &wv, float yrv, uint8_t mode);

public:
    uint8_t counter;        
    bool on_ground;         
    uint8_t mode;           
    csVector3 pos,          
              vel,          
              worldVel;     
    float yrot;             
    iSector* sector;        
    csString sectorName;    
    float ang_vel;          
    EID entityid;           

    psDRMessage() { }
    psDRMessage(uint32_t client, EID mappedid, uint8_t counter,
                NetBase::AccessPointers* accessPointers,
                psLinearMovement* linmove, uint8_t mode=0);
    psDRMessage(uint32_t client, EID mappedid,
                bool on_ground, uint8_t mode, uint8_t counter,
                const csVector3 &pos, float yrot, iSector* sector, csString sectorName,
                const csVector3 &vel, csVector3 &worldVel, float ang_vel,
                NetBase::AccessPointers* accessPointers);
    psDRMessage(void* data, int size, NetBase::AccessPointers* accessPointers);
    psDRMessage(MsgEntry* me, NetBase::AccessPointers* accessPointers);

    bool IsNewerThan(uint8_t oldCounter);

    PSF_DECLARE_MSG_FACTORY();

    void operator=(psDRMessage &other);

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

//-----------------------------------------------------------------------------

class psForcePositionMessage : public psMessageCracker
{
public:
    csVector3 pos;           
    float yrot;              
    iSector* sector;         
    csString sectorName;     
    csString backgroundname; 
    uint32_t loadTime;       
    csVector2 start;         
    csVector2 dest;          
    csString loadWidget;     
    float    vel;            

    psForcePositionMessage() { }
    psForcePositionMessage(uint32_t client, uint8_t sequence,
                           const csVector3 &pos, float yRot, iSector* sector, float vel,
                           csStringSet* msgstrings, uint32_t time = 0, csString loadBackground = "", csVector2 start = 0, csVector2 dest = 0, csString loadWidget = "");
    psForcePositionMessage(MsgEntry* me, NetBase::AccessPointers* accessPointers);

    PSF_DECLARE_MSG_FACTORY();

    void operator=(psForcePositionMessage &other);

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

//-----------------------------------------------------------------------------

class psPersistWorldRequest : public psMessageCracker
{
public:
    psPersistWorldRequest();
    psPersistWorldRequest(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

class psRequestAllObjects : public psMessageCracker
{
public:
    psRequestAllObjects();
    psRequestAllObjects(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

class psPersistWorld : public psMessageCracker
{
public:
    psPersistWorld(uint32_t clientNum, csVector3 pos, const char* sectorName);
    psPersistWorld(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    csString sector;
    csVector3 pos;
};

class psPersistActorRequest : public psMessageCracker
{
public:
    psPersistActorRequest()
    {
        msg.AttachNew(new MsgEntry());
        msg->SetType(MSGTYPE_PERSIST_ACTOR_REQUEST);
        msg->clientnum  = 0;
    }

    psPersistActorRequest(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

};


class psPersistAllEntities : public psMessageCracker
{
public:
    psPersistAllEntities(uint32_t client)
    {
        msg.AttachNew(new MsgEntry(60000));
        msg->SetType(MSGTYPE_PERSIST_ALL_ENTITIES);
        msg->clientnum  = client;
    }

    psPersistAllEntities(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    bool AddEntityMessage(MsgEntry* newEnt);

    MsgEntry* GetEntityMessage();
};


class psPersistActor : public psDRMessage
{
public:
    enum Flags
    {
        NONE            = 0,
        INVISIBLE       = 1 << 0, 
        INVINCIBLE      = 1 << 1, 
        NPC             = 1 << 2, 
        NAMEKNOWN       = 1 << 3, 
        IS_ALIVE        = 1 << 4  
    };

    psPersistActor(uint32_t clientnum,
                   int type,
                   int masqueradeType,
                   bool control,
                   const char* name,
                   const char* guild,
                   const char* factname,
                   const char* matname,
                   const char* race,
                   const char* mountFactname,
                   const char* MounterAnim,
                   unsigned short int gender,
                   float scale,
                   float mountscale,
                   const char* helmGroup,
                   const char* BracerGroup,
                   const char* BeltGroup,
                   const char* CloakGroup,
                   csVector3 collTop, csVector3 collBottom, csVector3 collOffset,
                   const char* texParts,
                   const char* equipmentParts,
                   uint8_t counter,
                   EID mappedid, csStringSet* msgstrings, psLinearMovement* linmove,
                   uint8_t movementMode,
                   uint8_t serverMode,
                   PID playerID = 0, uint32_t groupID = 0, EID ownerEID = 0,
                   uint32_t flags = NONE, PID masterID = 0, bool forNPClient = false);

    psPersistActor(MsgEntry* me, NetBase::AccessPointers* accessPointers, bool forNPClient = false);

    PSF_DECLARE_MSG_FACTORY();

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

    void SetInstance(InstanceID instance);

    static uint32_t PeekEID(MsgEntry* me);

    csString name;
    csString guild;
    csString factname;
    csString matname;
    csString race;
    csString mountFactname;
    csString MounterAnim;               
    unsigned short int gender;
    csString helmGroup;                 
    csString bracerGroup;               
    csString beltGroup;                 
    csString cloakGroup;                
    csVector3 top, bottom, offset;
    csString texParts;
    csString equipment;
    int type;
    int masqueradeType;
    uint8_t serverMode;
    PID playerID;
    uint32_t groupID;
    EID ownerEID;
    bool control;
    PID masterID;
    uint32_t flags;
    InstanceID instance;

    int posPlayerID;  
    int posInstance;  
    float scale;      
    float mountScale; 
};


class psPersistItem : public psMessageCracker
{
public:
    enum Flags
    {
        NONE            = 0,
        NOPICKUP        = 1 << 0,
        COLLIDE         = 1 << 1,
        TRIBEID         = 1 << 2,
        ITEM_UID        = 1 << 3
    };

    psPersistItem(uint32_t clientnum,
                  EID id,
                  int type,
                  const char* name,
                  const char* factname,
                  const char* matname,
                  const char* sector,
                  csVector3 pos,
                  float xRot,
                  float yRot,
                  float zRot,
                  uint32_t flags,
                  csStringSet* msgstrings,
                  uint32_t tribeid = 0,
                  uint32_t uid = 0
                 );

    psPersistItem(MsgEntry* me, NetBase::AccessPointers* accessPointers);

    PSF_DECLARE_MSG_FACTORY();

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

    csString name;
    csString factname;
    csString matname;
    csString sector;
    csVector3 pos;
    float xRot;
    float yRot;
    float zRot;
    uint32_t tribeID;
    EID eid;
    uint32_t type;
    uint32_t flags;
    uint32_t uid;
};

class psPersistActionLocation : public psMessageCracker
{
public:
    psPersistActionLocation(uint32_t clientNum,
                            EID eid,
                            int type,
                            const char* name,
                            const char* sector,
                            const char* mesh
                           );

    psPersistActionLocation(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    csString name;
    csString sector;
    csString mesh;
    EID eid;
    uint32_t type;
};

class psRemoveObject : public psMessageCracker
{
public:
    psRemoveObject(uint32_t clientNum, EID objectEID);
    psRemoveObject(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    EID objectEID;
};



class psBuddyListMsg : public psMessageCracker
{
public:
    struct BuddyData
    {
        csString name;
        bool online;
    };

    psBuddyListMsg(uint32_t clientNum, int totalBuddies);
    psBuddyListMsg(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    void AddBuddy(int num, const char* name, bool onlineStatus);
    void Build();

    csArray<BuddyData> buddies;
};



class psBuddyStatus : public psMessageCracker
{
public:
    psBuddyStatus(uint32_t clientNum, csString &buddyName, bool online)
    {
        msg.AttachNew(new MsgEntry(buddyName.Length()+1 + sizeof(bool)));

        msg->SetType(MSGTYPE_BUDDY_STATUS);
        msg->clientnum = clientNum;

        msg->Add(buddyName);
        msg->Add(online);
    }

    psBuddyStatus(MsgEntry* me)
    {
        buddy        = me->GetStr();
        onlineStatus = me->GetBool();
    }

    PSF_DECLARE_MSG_FACTORY();

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

    csString buddy;
    bool onlineStatus;
};

class psMOTDMessage : public psMessageCracker
{
public:
    psMOTDMessage(uint32_t clientNum, const csString &tipMsg, const csString &motdMsg, const csString &guildMsg, const csString &guild)
    {
        msg.AttachNew(new MsgEntry(tipMsg.Length()+1 + motdMsg.Length()+1 + guildMsg.Length()+1 + guild.Length() +1));

        msg->SetType(MSGTYPE_MOTD);
        msg->clientnum = clientNum;

        msg->Add(tipMsg);
        msg->Add(motdMsg);
        msg->Add(guildMsg);
        msg->Add(guild);
    }

    psMOTDMessage(MsgEntry* me)
    {
        tip        = me->GetStr();
        motd       = me->GetStr();
        guildmotd  = me->GetStr();
        guild      = me->GetStr();
    }

    PSF_DECLARE_MSG_FACTORY();

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

    csString tip;
    csString motd;
    csString guildmotd;
    csString guild;
};

class psMOTDRequestMessage : public psMessageCracker
{
public:
    psMOTDRequestMessage()
    {
        msg.AttachNew(new MsgEntry());
        msg->SetType(MSGTYPE_MOTDREQUEST);
        msg->clientnum  = 0;
    }
    psMOTDRequestMessage(MsgEntry* /*me*/) {}


    PSF_DECLARE_MSG_FACTORY();

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

class psQuestionResponseMsg : public psMessageCracker
{
public:
    uint32_t questionID;
    csString answer;

    psQuestionResponseMsg(int clientnum,uint32_t questionID,const csString &answer)
    {
        msg.AttachNew(new MsgEntry(sizeof(questionID)+answer.Length()+1));
        msg->SetType(MSGTYPE_QUESTIONRESPONSE);
        msg->clientnum  = clientnum;
        msg->Add(questionID);
        msg->Add(answer);
    }
    psQuestionResponseMsg(MsgEntry* me)
    {
        questionID = me->GetUInt32();
        answer     = me->GetStr();
        valid = true;
    }

    PSF_DECLARE_MSG_FACTORY();

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

class psQuestionMessage : public psMessageCracker
{
public:
    enum questionType_t
    {
        generalConfirm,    
        secretGuildNotify, 
        duelConfirm,       
        marriageConfirm    
    };

    uint32_t questionID;
    csString question;     // some string - its format depends on 'type'
    questionType_t type;

    psQuestionMessage(int clientnum,
                      uint32_t questionID,
                      const char* question,
                      questionType_t type)
    {
        msg.AttachNew(new MsgEntry(sizeof(questionID) +strlen(question)+1 +2));
        msg->SetType(MSGTYPE_QUESTION);
        msg->clientnum  = clientnum;

        msg->Add(questionID);
        msg->Add(question);
        msg->Add((uint16_t)type);
        valid=!(msg->overrun);
    }
    psQuestionMessage(MsgEntry* me)
    {
        questionID  =       me->GetUInt32();
        question    =       me->GetStr();
        type        = (questionType_t)me->GetInt16();
        valid = true;
    }

    PSF_DECLARE_MSG_FACTORY();

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

class psAdviceMessage : public psMessageCracker
{
public:
    csString sCommand;
    csString sTarget;
    csString sMessage;

    psAdviceMessage(int clientNum, const char* command, const char* target, const char* message)
    {
        size_t msgSize = 0;

        if(message) msgSize = strlen(message);

        msg.AttachNew(new MsgEntry(strlen(command) + strlen(target) + msgSize + 3));
        msg->SetType(MSGTYPE_ADVICE);
        msg->clientnum  = clientNum;
        msg->Add(command);
        msg->Add(target);
        msg->Add(message?message:"");
        valid = !(msg->overrun);
    };

    psAdviceMessage(MsgEntry* me)
    {
        sCommand = me->GetStr();
        sTarget  = me->GetStr();
        sMessage = me->GetStr();
        valid = true;
    };

    PSF_DECLARE_MSG_FACTORY();

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


class psGUIActiveMagicMessage : public psMessageCracker
{
public:
    
    enum commandType { Add, Remove, List };

    psGUIActiveMagicMessage(uint32_t clientNum, csArray<ActiveSpell*>& spells, uint32_t index, csTicks serverTime )
    {
        //                  MSGTYPE_ACTIVEMAGIC + clientNum        + command         + valid        + index            + spellCount;
        size_t    msgSize = sizeof(uint8_t)     + sizeof(uint32_t) + sizeof(uint8_t) + sizeof(bool) + sizeof(uint32_t) + sizeof(uint32_t); 

        size_t    numSpells = spells.GetSize();

        for( size_t i=0; i<numSpells; i++ )
        {
            msgSize += sizeof(uint8_t);     //SPELL_TYPE 
            msgSize += sizeof(uint32_t);    //duration
            msgSize += spells[i]->Name().Length() + 1;
            msgSize += spells[i]->Image().Length() + 1;
            msgSize += sizeof(uint32_t);    //registrationTime
            msgSize += sizeof(uint32_t);    //serverTime
        }

        msg.AttachNew(new MsgEntry(msgSize));
        msg->SetType(MSGTYPE_ACTIVEMAGIC);
        msg->clientnum = clientNum;
        msg->Add((uint8_t)psGUIActiveMagicMessage::List);
        msg->Add((uint32_t)index);
        msg->Add((uint32_t)numSpells);
        for( size_t i=0; i<numSpells; i++ )
        {
            msg->Add((uint8_t)spells[i]->Type());
            msg->Add((uint32_t)spells[i]->Duration());
            msg->Add(spells[i]->Name().GetData());
            msg->Add(spells[i]->Image().GetData());
            msg->Add((uint32_t)spells[i]->RegistrationTime());
            msg->Add((uint32_t)serverTime);
        }
        valid = !(msg->overrun);
    }

    psGUIActiveMagicMessage(MsgEntry* message)
    {
        //what type of message : Add, Remove or List. retained so older style messages won't make the system crash.
        command = (commandType)message->GetUInt8();
        if( command != List )
        {
            valid = false;
            return;
        }

        //what is the index number of this message?
        index = message->GetUInt32();

        //how many spells are in the message?
        size_t totalSpells = message->GetUInt32();

        //read the spells
        for( size_t i=0; i<totalSpells; i++ )
        {
            type.Push( (SPELL_TYPE) message->GetUInt8() );
            duration.Push( message->GetUInt32());
            name.Push( message->GetStr());          //if there was no name when the message was sent, this should read a null string
            image.Push( message->GetStr());         //if there was no name when the message was sent, this should read a null string
            registrationTime.Push( message->GetUInt32());
            serverTime=message->GetUInt32();
        }
        valid = true;
    }

    PSF_DECLARE_MSG_FACTORY();

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

    uint32_t             index;
    commandType command;
    csArray<SPELL_TYPE>  type;
    csArray<uint32>      duration;
    csArray<uint32>      registrationTime;
    uint32               serverTime;
    csArray<csString>    name;
    csArray<csString>    image;
};

//-----------------------------------------------------------------------------
class psSlotMovementMsg : public psMessageCracker
{
public:
    psSlotMovementMsg(int fromContainerID,
                      int fromSlotID,
                      int toContainerID,
                      int toSlotID,
                      int stackCount,
                      csVector3* pt3d=NULL,
                      csVector3* rot=NULL,
                      bool guarded=true,
                      bool inplace=true)
    {
        msg.AttachNew(new MsgEntry(sizeof(int32_t) * 5 + 3 * sizeof(float) + 3 * sizeof(float) + 2 * sizeof(bool)));

        msg->SetType(MSGTYPE_SLOT_MOVEMENT);
        msg->clientnum  = 0;

        msg->Add((int32_t) fromContainerID);
        msg->Add((int32_t) fromSlotID);
        msg->Add((int32_t) toContainerID);
        msg->Add((int32_t) toSlotID);
        msg->Add((int32_t) stackCount);
        if(pt3d != NULL)
            msg->Add(*pt3d);
        else
        {
            csVector3 v = 0;
            msg->Add(v);  // Add dummy zeroes if not specified.
        }
        if(rot != NULL)
        {
            msg->Add(rot->y);
        }
        else
        {
            msg->Add(0.f); // Add 0 rotation if not specified.
        }
        msg->Add(guarded);
        msg->Add(inplace);
        if(rot != NULL)
        {
            msg->Add(rot->x);
            msg->Add(rot->z);
        }
        else
        {
            msg->Add(0.f);
            msg->Add(0.f);
        }
    }

    psSlotMovementMsg(MsgEntry* me)
    {
        fromContainer = me->GetInt32();
        fromSlot      = me->GetInt32();
        toContainer   = me->GetInt32();
        toSlot        = me->GetInt32();
        stackCount    = me->GetInt32();
        posWorld      = me->GetVector3();
        rot.y         = me->GetFloat();
        guarded       = me->GetBool();
        inplace       = me->GetBool();
        rot.x         = me->GetFloat();
        rot.z         = me->GetFloat();
    }

    PSF_DECLARE_MSG_FACTORY();

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

    int fromContainer;
    int fromSlot;
    int toContainer;
    int toSlot;
    int stackCount;
    csVector3 posWorld;
    csVector3 rot;
    bool guarded;
    bool inplace; // drop at the character's position.
};

class psCmdDropMessage : public psMessageCracker
{
public:
    psCmdDropMessage(int quantity, csString &itemName, bool container, bool guarded, bool inplace);
    psCmdDropMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    int quantity;
    csString itemName;

    bool container;
    bool guarded;
    bool inplace;
};

class psQuestionCancelMessage : public psMessageCracker
{
public:
    uint32_t questionID;

    psQuestionCancelMessage(int clientnum, uint32_t id)
    {
        msg.AttachNew(new MsgEntry(sizeof(id)));
        msg->SetType(MSGTYPE_QUESTIONCANCEL);
        msg->clientnum  = clientnum;

        msg->Add(id);
    }
    psQuestionCancelMessage(MsgEntry* me)
    {
        questionID = me->GetUInt32();
        valid = true;
    }

    PSF_DECLARE_MSG_FACTORY();

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

class psGuildMOTDSetMessage : public psMessageCracker
{
public:
    psGuildMOTDSetMessage(csString &guildMsg,csString &guild)
    {
        msg.AttachNew(new MsgEntry(guildMsg.Length()+1 + guild.Length() +1));

        msg->SetType(MSGTYPE_GUILDMOTDSET);
        msg->clientnum = 0;
        msg->Add(guildMsg);
        msg->Add(guild);
    }

    psGuildMOTDSetMessage(MsgEntry* me)
    {
        guildmotd  = me->GetStr();
        if(!guildmotd.Length())
            guildmotd = "(No message of the day.)";
        guild      = me->GetStr();
        if(!guild.Length())
            valid = false;
    }

    PSF_DECLARE_MSG_FACTORY();

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

    csString guildmotd;
    csString guild;
};

class psCharacterDetailsMessage : public psMessageCracker
{
public:
    struct NetworkDetailSkill
    {
        int category;
        csString text;
    };

    psCharacterDetailsMessage(int clientnum, const csString &name2s,unsigned short int gender2s,const csString &race2s,
                              const csString &desc2s, const csArray<NetworkDetailSkill> &skills2s, const csString &desc_ooc, const csString &creationinfo, const csString &requestor);
    psCharacterDetailsMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    csString name;
    unsigned short int gender;
    csString race;
    csString desc;
    csString desc_ooc;
    csString creationinfo;
    csArray<NetworkDetailSkill> skills;

    csString requestor;  // Identifies which part of system initiated this
};

class psCharacterDetailsRequestMessage : public psMessageCracker
{
public:
    psCharacterDetailsRequestMessage(bool myself, bool simple, const csString &requestor)
    {
        //If myself = true, the server sends the information about the player
        //If myself = false, the server sends the information about the target

        msg.AttachNew(new MsgEntry(sizeof(myself) + sizeof(simple) + requestor.Length() + 1));
        msg->SetType(MSGTYPE_CHARDETAILSREQUEST);
        msg->clientnum  = 0;
        msg->Add(myself);
        msg->Add(simple);
        msg->Add(requestor.GetData());
    }

    psCharacterDetailsRequestMessage(MsgEntry* me)
    {
        isMe       =  me->GetBool();
        isSimple   =  me->GetBool();
        requestor  =  me->GetStr();
    }

    PSF_DECLARE_MSG_FACTORY();

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

    bool isMe;
    bool isSimple;          
    csString requestor;     
};

enum DESCTYPE
{
    DESC_IC = 1, 
    DESC_OOC,    
    DESC_CC      
};

class psCharacterDescriptionUpdateMessage : public psMessageCracker
{
public:
    psCharacterDescriptionUpdateMessage(csString &newValue, DESCTYPE desctype)
    {

        msg.AttachNew(new MsgEntry(newValue.Length() +1 + sizeof(uint8_t)));
        msg->SetType(MSGTYPE_CHARDESCUPDATE);

        msg->clientnum  = 0;
        msg->Add(newValue);
        msg->Add((uint8_t)desctype);
    }

    psCharacterDescriptionUpdateMessage(MsgEntry* me)
    {
        newValue    =  me->GetStr();
        desctype    = (DESCTYPE) me->GetUInt8();
    }

    PSF_DECLARE_MSG_FACTORY();

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

    csString newValue;
    DESCTYPE desctype;
};

//------------------------------------------------------------------------------

class psViewActionLocationMessage : public psMessageCracker
{
public:
    psViewActionLocationMessage(uint32_t clientnum, const char* actname, const char* desc);
    psViewActionLocationMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    const char* name;
    const char* description;
};

//------------------------------------------------------------------------------

class psViewItemDescription : public psMessageCracker
{
public:
    psViewItemDescription(int containerID, int slotID);

    psViewItemDescription(uint32_t to, const char* itemName, const char* description, const char* icon,
                          uint32_t stackCount);

    psViewItemDescription(MsgEntry* me, NetBase::AccessPointers* accessPointers);

    PSF_DECLARE_MSG_FACTORY();

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

    const char* itemName;

    const char* itemDescription;

    const char* itemIcon;

    uint32_t stackCount;

    int containerID;

    int ContainerSlots;

    int slotID;

    int msgSize;

    bool hasContents;

    int to;

private:
    enum
    {
        REQUEST,
        DESCR
    };
    int format;
};


//------------------------------------------------------------------------------

class psViewContainerDescription : public psMessageCracker
{
public:
    psViewContainerDescription(int containerID, int slotID);

    psViewContainerDescription(uint32_t to, const char* itemName, const char* description, const char* icon,
                               uint32_t stackCount);

    psViewContainerDescription(MsgEntry* me, NetBase::AccessPointers* accessPointers);

    PSF_DECLARE_MSG_FACTORY();

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

    const char* itemName;

    const char* itemDescription;

    const char* itemIcon;

    uint32_t stackCount;

    int containerID;

    int maxContainerSlots;

    int slotID;

    int msgSize;

    bool hasContents;

    bool renameable;

    bool CanTransform;

    int to;

    void AddContents(const char* name, const char* meshName, const char* materialName, const char* icon, int purifyStatus, int slot, int stack);

    void ConstructMsg(csStringSet* msgstrings);

    struct ContainerContents
    {
        csString name;
        csString icon;
        csString meshName;
        csString materialName;
        int slotID;
        int stackCount;
        int purifyStatus;
    };

    csArray<ContainerContents> contents;

private:
    enum
    {
        REQUEST,
        DESCR
    };
    int format;
};



class psViewItemUpdate : public psMessageCracker
{
public:
    psViewItemUpdate(uint32_t to, EID containerID, uint32_t slotID, bool clearSlot, const char* itemName, const char* icon, const char* meshName, const char* materialName, uint32_t stackCount, EID ownerID, csStringSet* msgstrings);

    psViewItemUpdate(MsgEntry* me, NetBase::AccessPointers* accessPointers);

    PSF_DECLARE_MSG_FACTORY();

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

//    /// Running count of message size. Used for constructing the outgoing message.
//    int msgSize;

    bool clearSlot;

    EID containerID;

    csString name;
    csString icon;
    csString meshName;
    csString materialName;
    int slotID;
    int stackCount;
    EID ownerID;
};


class psWriteBookMessage : public psMessageCracker
{
public:
    psWriteBookMessage(int slotID, int containerID);
    psWriteBookMessage(int slotID, int containerID, csString &title, csString &content);
    psWriteBookMessage(uint32_t clientNum, csString &title, csString &content, bool success,  int slotID, int containerID);
    psWriteBookMessage(uint32_t clientNum, csString &title, bool success);

    psWriteBookMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    uint8_t messagetype;
    csString title, content;
    int slotID;
    int containerID;
    bool success;

    enum
    {
        REQUEST,
        RESPONSE,
        SAVE,
        SAVERESPONSE
    };
};

class psReadBookTextMessage : public psMessageCracker
{
public:
    psReadBookTextMessage(uint32_t clientNum, csString &itemName, csString &bookText, bool canWrite, int slotID, int containerID, csString backgroundImg);

    psReadBookTextMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    csString name;
    csString text;
    bool canWrite;
    int slotID;
    int containerID;
    csString backgroundImg;
};

//--------------------------------------------------------------------------

class psQuestRewardMessage : public psMessageCracker
{
public:
    enum
    {
        offerRewards,
        selectReward
    };

    psQuestRewardMessage(uint32_t clientnum, csString &newValue, uint8_t type)
    {
        msg.AttachNew(new MsgEntry(newValue.Length() + 1 + sizeof(uint8_t)));
        msg->SetType(MSGTYPE_QUESTREWARD);
        msg->clientnum  = clientnum;
        msg->Add(newValue);
        msg->Add(type);
    }

    psQuestRewardMessage(MsgEntry* me)
    {
        newValue    = me->GetStr();
        msgType     = me->GetUInt8();
    }

    PSF_DECLARE_MSG_FACTORY();

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

    int msgType;
    csString newValue;
};

//--------------------------------------------------------------------------

class psExchangeMoneyMsg : public psMessageCracker
{
public:
    psExchangeMoneyMsg(uint32_t client, int container,
                       int trias, int hexas, int circles,int octas);

    psExchangeMoneyMsg(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    int container;

    int trias;
    int octas;
    int hexas;
    int circles;
};

class psExchangeRequestMsg : public psMessageCracker
{
public:
    psExchangeRequestMsg(bool withPlayer);

    psExchangeRequestMsg(uint32_t client, csString &name, bool withPlayer);

    PSF_DECLARE_MSG_FACTORY();

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


    psExchangeRequestMsg(MsgEntry* me);

    csString player;
    bool withPlayer;
};


class psExchangeAddItemMsg : public psMessageCracker
{
public:
    psExchangeAddItemMsg(uint32_t clientNum,
                         const csString &name,
                         const csString &meshFactName,
                         const csString &materialName,
                         int containerID,
                         int slot,
                         int stackcount,
                         const csString &icon,
                         csStringSet* msgstrings);

    psExchangeAddItemMsg(MsgEntry* me, NetBase::AccessPointers* accessPointers);

    PSF_DECLARE_MSG_FACTORY();

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

    csString name;
    csString meshFactName;
    csString materialName;
    int container;
    int slot;
    int stackCount;
    csString icon;
};

//------------------------------------------------------------------------------

class psExchangeRemoveItemMsg : public psMessageCracker
{
public:
    psExchangeRemoveItemMsg(uint32_t client, int container, int slot, int newStack);
    psExchangeRemoveItemMsg(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    int container;          // CONTAINER_EXCHANGE_*
    int slot;
    int newStackCount;
};

//------------------------------------------------------------------------------

class psExchangeAcceptMsg : public psMessageCracker
{
public:
    psExchangeAcceptMsg(uint32_t client = 0);
    psExchangeAcceptMsg(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

//------------------------------------------------------------------------------

class psExchangeStatusMsg : public psMessageCracker
{
public:
    psExchangeStatusMsg(uint32_t client, bool playerAccept, bool otherPlayerAccept);
    psExchangeStatusMsg(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    bool playerAccept;
    bool otherAccept;
};
//------------------------------------------------------------------------------


class psExchangeEndMsg : public psMessageCracker
{
public:
    psExchangeEndMsg(uint32_t client = 0);
    psExchangeEndMsg(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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


//------------------------------------------------------------------------------

class psUpdateObjectNameMessage : public psMessageCracker
{
public:
    psUpdateObjectNameMessage(uint32_t client, EID eid, const char* newName);
    psUpdateObjectNameMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    EID objectID;
    csString newObjName;
};

/*
 * Used to send the information to the clients that a player or multiple players have changed their guild
 * The client will then update the second line of text (containing the guild's name) above the player's head.
 */ 
class psUpdatePlayerGuildMessage : public psMessageCracker
{
public:
    psUpdatePlayerGuildMessage(uint32_t client, int total,  const char* newGuild);
    psUpdatePlayerGuildMessage(uint32_t client, EID entity, const char* newGuild); // shortcut for only 1 entity
    psUpdatePlayerGuildMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    void AddPlayer(EID id); // Adds an object

    csArray<uint32_t> objectID; // Array with objects
    csString newGuildName;
};


class psUpdatePlayerGroupMessage : public psMessageCracker
{
public:
    psUpdatePlayerGroupMessage(int clientnum, EID objectID, uint32_t groupID);
    psUpdatePlayerGroupMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    EID objectID;
    uint32_t groupID;
};

//------------------------------------------------------------------------------

class psNameCheckMessage : public psMessageCracker
{
public:
    psNameCheckMessage() {}
    psNameCheckMessage(const char* name);
    psNameCheckMessage(const char* firstName, const char* lastName);
    psNameCheckMessage(uint32_t client, bool accepted, const char* reason);
    psNameCheckMessage(MsgEntry* me);

    void FromClient(MsgEntry* me);
    void FromServer(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    csString firstName;
    csString lastName;
    csString reason;
    bool accepted;

private:
    bool msgFromServer;
};

//-----------------------------------------------------------------------------

#define PINGFLAG_REQUESTFLAGS    0x0001
#define PINGFLAG_READY           0x0002
#define PINGFLAG_HASBEENREADY    0x0004
#define PINGFLAG_SERVERFULL      0x0008

class psPingMsg : public psMessageCracker
{
public:
    psPingMsg(uint32_t client, uint32_t id, uint8_t flags);
    psPingMsg(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    uint32_t id;
    uint8_t flags;
};

//-----------------------------------------------------------------------------

class psHeartBeatMsg : public psMessageCracker
{
public:
    psHeartBeatMsg(uint32_t client);
    psHeartBeatMsg(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

//-----------------------------------------------------------------------------

class psLockpickMessage : public psMessageCracker
{
public:
    psLockpickMessage(const char* password);   // Password is for future use
    psLockpickMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    csString password;
};

//-----------------------------------------------------------------------------

class psGMSpawnItems : public psMessageCracker
{
public:
    psGMSpawnItems(uint32_t client,const char* type,unsigned int size);
    psGMSpawnItems(const char* type);
    psGMSpawnItems(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    bool request;

    struct Item
    {
        csString name;
        csString mesh;
        csString icon;
    };

    csArray<Item> items;

    csString type;
};

class psGMSpawnTypes : public psMessageCracker
{
public:
    psGMSpawnTypes(uint32_t client,unsigned int size);
    psGMSpawnTypes(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    csArray<csString> types;
};

/*
 * Request item modifiers for a given item.
 */
class psGMSpawnGetMods : public psMessageCracker
{
public:
    psGMSpawnGetMods(const char *itemname);
    psGMSpawnGetMods(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    csString item;
};

/*
 * Returns the list of item modifiers for the last request.
 */
class psGMSpawnMods : public psMessageCracker
{
public:
    enum ItemModType {
        ITEM_PREFIX,
        ITEM_SUFFIX,
        ITEM_ADJECTIVE,
        ITEM_NUM_TYPES
    };

    struct ItemModifier
    {
        csString name;
        uint32_t id;
        uint32_t type;
    };

    psGMSpawnMods(uint32_t client, csArray<ItemModifier>& imods);
    psGMSpawnMods(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    csArray<ItemModifier> mods;
};

class psGMSpawnItem : public psMessageCracker
{
public:
    psGMSpawnItem(
        const char* item,
        unsigned int count,
        bool lockable,
        bool locked,
        const char* lskill,
        int lstr,
        bool pickupable,
        bool collidable,
        bool Unpickable,
        bool Transient,
        bool SettingItem,
        bool NPCOwned,
        bool pickupableWeak,
        bool random = false,
        float quality = 0.0f,
        csArray<uint32_t>* mods = 0
        );

    psGMSpawnItem(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    csString item;
    unsigned int count;
    bool lockable,locked,pickupable,collidable,Unpickable,SettingItem,NPCOwned,Transient, pickupableWeak;

    csString lskill;
    int lstr;
    bool random;
    float quality;
    csArray<uint32_t> mods;
};

class psLootRemoveMessage : public psMessageCracker
{
public:
    psLootRemoveMessage(uint32_t client,int item);
    psLootRemoveMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    int id;
};

class psCharCreateTraitsMessage : public psMessageCracker
{
public:
    psCharCreateTraitsMessage(uint32_t client, csString &string)
    {
        msg.AttachNew(new MsgEntry(string.Length()+1));

        msg->SetType(MSGTYPE_CHAR_CREATE_TRAITS);
        msg->clientnum = client;
        msg->Add(string);
    }

    psCharCreateTraitsMessage(csString &string)
    {
        msg.AttachNew(new MsgEntry(string.Length()+1));

        msg->SetType(MSGTYPE_CHAR_CREATE_TRAITS);
        msg->clientnum = 0;
        msg->Add(string);
    }

    psCharCreateTraitsMessage(MsgEntry* me)
    {
        string  = me->GetStr();
        if(!string.Length())
            valid = false;
    }

    PSF_DECLARE_MSG_FACTORY();

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

    const csString &GetString() const
    {
        return string;
    }

private:
    csString string;
};

class psClientStatusMessage : public psMessageCracker
{
public:
    psClientStatusMessage(bool ready);
    psClientStatusMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    bool ready;

    enum ClientStatus
    {
        READY = 0x1
    };
};

class psMoveModMsg : public psMessageCracker
{
public:
    enum ModType
    {
        NONE = 0,   
        ADDITION,   
        MULTIPLIER, 
        CONSTANT,   
        PUSH        
    };

    psMoveModMsg(uint32_t client, ModType type, const csVector3 &move, float Yrot);
    psMoveModMsg(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    ModType type;
    csVector3 movementMod;
    float rotationMod;
};

class psMsgRequestMovement : public psMessageCracker
{
public:
    psMsgRequestMovement();
    psMsgRequestMovement(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

class psMovementInfoMessage : public psMessageCracker
{
public:
    psMovementInfoMessage(size_t modes, size_t moves);
    psMovementInfoMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

    void AddMode(uint32 id, const char* name, csVector3 move_mod, csVector3 rotate_mod, const char* idle_anim);
    void AddMove(uint32 id, const char* name, csVector3 base_move, csVector3 base_rotate);

    void GetMode(uint32 &id, const char* &name, csVector3 &move_mod, csVector3 &rotate_mod, const char* &idle_anim);
    void GetMove(uint32 &id, const char* &name, csVector3 &base_move, csVector3 &base_rotate);

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

    // Count of each object
    size_t modes, moves;
};

//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------

class psMsgCraftingInfo : public psMessageCracker
{
public:
    psMsgCraftingInfo()
    {
        msg.AttachNew(new MsgEntry(1));
        msg->SetType(MSGTYPE_CRAFT_INFO);
    }

    psMsgCraftingInfo(uint32_t client, csString craftinfo)
    {
        msg.AttachNew(new MsgEntry(craftinfo.Length()+1));

        msg->SetType(MSGTYPE_CRAFT_INFO);
        msg->clientnum = client;
        msg->Add(craftinfo.GetData());
    }

    psMsgCraftingInfo(MsgEntry* me)
    {
        craftInfo = me->GetStr();
        if(!craftInfo.Length())
            valid = false;
    }

    PSF_DECLARE_MSG_FACTORY();

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

    csString craftInfo;
};

//-----------------------------------------------------------------------------

class psTraitChangeMessage : public psMessageCracker
{
public:
    psTraitChangeMessage(uint32_t client, EID targetID, csString &string)
    {
        msg.AttachNew(new MsgEntry(string.Length()+1 + sizeof(uint32_t)));

        msg->SetType(MSGTYPE_CHANGE_TRAIT);
        msg->clientnum = client;
        msg->Add(targetID.Unbox());
        msg->Add(string);
    }

    psTraitChangeMessage(MsgEntry* me)
    {
        target = EID(me->GetUInt32());
        string  = me->GetStr();
        if(!string.Length())
            valid = false;
    }

    PSF_DECLARE_MSG_FACTORY();

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

    EID target;
    csString string;
};

//-----------------------------------------------------------------------------

class psTutorialMessage : public psMessageCracker
{
public:
    psTutorialMessage(uint32_t client, uint32_t which, const char* instructions)
    {
        msg.AttachNew(new MsgEntry(sizeof(uint32_t) + strlen(instructions)+1));

        msg->SetType(MSGTYPE_TUTORIAL);
        msg->clientnum = client;
        msg->Add(which);
        msg->Add(instructions);
    }

    psTutorialMessage(MsgEntry* me)
    {
        whichMessage = me->GetUInt32();
        instrs = me->GetStr();
    }

    PSF_DECLARE_MSG_FACTORY();

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

    int whichMessage;
    csString instrs;
};

class psSketchMessage : public psMessageCracker
{
public:
    psSketchMessage(uint32_t client, uint32_t itemID, uint8_t flags, const char* limitxml,const char* sketch_def, bool rightToEditFlag, const char* sketch_name, const char* backgroundImg)
    {
        msg.AttachNew(new MsgEntry(sizeof(uint32_t)+1+strlen(limitxml)+1+strlen(sketch_def)+1+sizeof(bool)+strlen(sketch_name)+1+strlen(backgroundImg)+1));

        msg->SetType(MSGTYPE_VIEW_SKETCH);
        msg->clientnum = client;
        msg->Add(itemID);
        msg->Add(flags);
        msg->Add(limitxml);
        msg->Add(sketch_def);
        msg->Add(rightToEditFlag);
        msg->Add(sketch_name);
        msg->Add(backgroundImg);
    }

    psSketchMessage(MsgEntry* me)
    {
        ItemID = me->GetUInt32();
        Flags  = me->GetUInt8();
        limits = me->GetStr();
        Sketch = me->GetStr();
        rightToEdit = me->GetBool();
        name = me->GetStr();
        backgroundImg = me->GetStr();
    }

    PSF_DECLARE_MSG_FACTORY();

    virtual csString ToString(NetBase::AccessPointers* accessPointers)
    {
        (void)accessPointers; // NOT USED
        return csString("not implemented");
    }

    uint32_t ItemID;
    uint8_t  Flags;
    csString Sketch;
    csString limits;
    bool rightToEdit;
    csString name;
    csString backgroundImg;
};

class psMusicalSheetMessage: public psMessageCracker
{
public:
    psMusicalSheetMessage(uint32_t client, uint32_t itemID, bool readOnly, bool play, const char* songTitle, const char* musicalSheet);

    psMusicalSheetMessage(MsgEntry* me);

    // From psMesageCracker
    //----------------------
    PSF_DECLARE_MSG_FACTORY();

    virtual csString ToString(NetBase::AccessPointers* /*accessPointers*/)
    {
        return csString("not implemented");
    }

    uint32_t itemID;
    bool readOnly;
    bool play;
    csString songTitle;
    csString musicalSheet;
};

class psPlaySongMessage: public psMessageCracker
{
public:
    psPlaySongMessage(uint32_t client, uint32_t songID, bool toPlayer,
                      const char* instrName, uint32_t scoreSize, const char* musicalScore);

    psPlaySongMessage(MsgEntry* me);


    // From psMesageCracker
    //----------------------
    PSF_DECLARE_MSG_FACTORY();

    virtual csString ToString(NetBase::AccessPointers* /*accessPointers*/)
    {
        return csString("not implemented");
    }

    uint32_t songID;
    bool toPlayer;
    csString instrName;
    csString musicalScore;
};


class psStopSongMessage: public psMessageCracker
{
public:

    enum
    {
        NO_SONG_ERROR = 1,
        ILLEGAL_SCORE,
        NO_INSTRUMENT
    };

    psStopSongMessage();

    psStopSongMessage(uint32_t client, uint32_t songID, bool toPlayer, int8_t errorCode);

    psStopSongMessage(MsgEntry* me);


    // From psMesageCracker
    //----------------------
    PSF_DECLARE_MSG_FACTORY();

    virtual csString ToString(NetBase::AccessPointers* /*accessPointers*/)
    {
        return csString("not implemented");
    }

    uint32_t songID;
    bool toPlayer;
    int8_t errorCode;
};

class psMGStartStopMessage : public psMessageCracker
{

public:
    psMGStartStopMessage(uint32_t client, bool start);

    psMGStartStopMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    bool msgStart;
};

class psMGBoardMessage : public psMessageCracker
{

public:
    psMGBoardMessage(uint32_t client, uint8_t counter,
                     uint32_t gameID, uint16_t options, int8_t cols, int8_t rows, uint8_t* layout,
                     uint8_t numOfPieces, uint8_t piecesSize, uint8_t* pieces);

    psMGBoardMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    bool IsNewerThan(uint8_t oldCounter);

    uint8_t msgCounter;

    uint32_t msgGameID;

    uint16_t msgOptions;

    int8_t msgCols;

    int8_t msgRows;

    uint8_t* msgLayout;

    uint8_t msgNumOfPieces;

    uint8_t* msgPieces;

};

class psMGUpdateMessage : public psMessageCracker
{

public:
    psMGUpdateMessage(uint32_t client, uint8_t counter,
                      uint32_t gameID, uint8_t numUpdates, uint8_t* updates);

    psMGUpdateMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    bool IsNewerThan(uint8_t oldCounter);

    uint8_t msgCounter;

    uint32_t msgGameID;

    uint8_t msgNumUpdates;

    uint8_t* msgUpdates;
};

class psEntranceMessage : public psMessageCracker
{

public:
    psEntranceMessage(EID entranceID);

    psEntranceMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

    EID entranceID;
};

//--------------------------------------------------------------------------

class psGMEventListMessage : public psMessageCracker
{
public:

    psGMEventListMessage();
    psGMEventListMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

    void Populate(csString &gmeventStr, int clientnum);

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

    csString gmEventsXML;
};

//---------------------------------------------------------------------------

class psGMEventInfoMessage : public psMessageCracker
{
public:
    enum
    {
        CMD_QUERY,   
        CMD_INFO,    
        CMD_DISCARD, 
        CMD_EVAL     
    };
    psGMEventInfoMessage(int cnum, int cmd, int id, const char* name,const char* info, bool Evaluatable = false);
    psGMEventInfoMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    int command,id;
    bool Evaluatable; 
    csString xml;     
};



class psFactionMessage : public psMessageCracker
{
public:
    // Structure to hold faction name/faction value pairs.
    struct FactionPair
    {
        csString faction;       // Name of the faction.
        int      rating;        // Rating with that faction.
    };

    enum
    {
        MSG_FULL_LIST,          // Data is the full faction list.
        MSG_UPDATE              // Data is an update faction list.
    };

    psFactionMessage(int cnum, int cmd);

    void AddFaction(csString factionName, int rating);

    void BuildMsg();

    psFactionMessage(MsgEntry* message);

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

    int cmd;                                
    int client;                             
    csPDelArray<FactionPair> factionInfo;       
};

//---------------------------------------------------------------------------

class psSequenceMessage : public psMessageCracker
{
public:
    enum // Should use same values as in the NPC client SequenceOperation
    {
        CMD_START = 1,
        CMD_STOP = 2,
        CMD_LOOP = 3
    };
    psSequenceMessage(int cnum, const char* name, int cmd, int count);
    psSequenceMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    csString name;
    int command,count;
};


class psPlaySoundMessage : public psMessageCracker
{
public:
    csString sound;
    psPlaySoundMessage(uint32_t clientnum, csString snd);

    psPlaySoundMessage(MsgEntry* message);

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

//-----------------------------------------------------------------------------

class psCharCreateCPMessage : public psMessageCracker
{
public:
    psCharCreateCPMessage(uint32_t client, int32_t rID, int32_t CPVal);
    psCharCreateCPMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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

    int32_t raceID;
    int32_t CPValue;
};

//-----------------------------------------------------------------------------

class psCharIntroduction : public psMessageCracker
{
public:
    psCharIntroduction();
    psCharIntroduction(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();

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


class psCachedFileMessage : public psMessageCracker
{

public:
    csString hash;
    csRef<iDataBuffer> databuf;

    psCachedFileMessage(uint32_t client, uint8_t sequence, const char* pathname, iDataBuffer* contents);
    psCachedFileMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

};

//-----------------------------------------------------------------------------

class psDialogMenuMessage : public psMessageCracker
{
public:
    csString xml;

    psDialogMenuMessage();
    psDialogMenuMessage(MsgEntry* message);

    PSF_DECLARE_MSG_FACTORY();


    void BuildMsg(int clientnum);

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

    struct DialogResponse
    {
        uint32_t id;
        csString menuText;
        csString triggerText;
        uint32_t flags;
    };

    void AddResponse(uint32_t id, const csString &menuText, const csString &triggerText, uint32_t flags = 0x00);

    csArray<DialogResponse> responses;
};

class psSimpleStringMessage : public psMessageCracker
{

public:
    csString str;

    psSimpleStringMessage(uint32_t client,MSG_TYPES type, const char* string);
    psSimpleStringMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

    virtual csString ToString(NetBase::AccessPointers* accessPointers)
    {
        (void)accessPointers; // NOT USED
        return csString("Str: ") + str;
    }

};

class psSimpleRenderMeshMessage : public psMessageCracker
{

public:
    iSector*           sector;
    csString           name;  
    uint16_t            index; 
    uint16_t            count; 
    csSimpleRenderMesh simpleRenderMesh;

    psSimpleRenderMeshMessage(uint32_t client, NetBase::AccessPointers* accessPointers, const char* name, uint16_t index, uint16_t count, const iSector* sector, const csSimpleRenderMesh &simpleRenderMesh);
    psSimpleRenderMeshMessage(MsgEntry* me, NetBase::AccessPointers* accessPointers);

    PSF_DECLARE_MSG_FACTORY();

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

class psMechanismActivateMessage: public psMessageCracker
{
public:
    psMechanismActivateMessage(uint32_t client, const char* meshName,
                               const char* move, const char* rot);

    psMechanismActivateMessage(MsgEntry* me);

    // From psMessageCracker
    PSF_DECLARE_MSG_FACTORY();

    virtual csString ToString(NetBase::AccessPointers* /*accessPointers*/)
    {
        return csString("not implemented");
    }

    csString meshName;
    csString move;
    csString rot;
};


class psOrderedMessage : public psMessageCracker
{

public:
    int value;

    psOrderedMessage(uint32_t client, int valueToSend, int sequenceNumber);
    psOrderedMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

};

class psHiredNPCScriptMessage : public psMessageCracker
{

public:
    // Hired NPC Script Commands
    enum 
    {
        CANCEL,
        CHECK_WORK_LOCATION,
        CHECK_WORK_LOCATION_RESULT,
        COMMIT,
        COMMIT_REPLY,
        REQUEST,
        REQUEST_REPLY,
        VERIFY,
        VERIFY_REPLY,
        WORK_LOCATION,
        WORK_LOCATION_RESULT,
        WORK_LOCATION_UPDATE
    };

    uint8_t  command;
    EID      hiredEID;
    bool     choice;
    csString workLocation;
    bool     workLocationValid;
    csString script;
    csString locationType;
    csString locationName;
    csString errorMessage;

    psHiredNPCScriptMessage(uint32_t client, uint8_t command, EID hiredEID);

    psHiredNPCScriptMessage(uint32_t client, uint8_t command, EID hiredEID,
                            bool choice, const char* errorMsg);

    psHiredNPCScriptMessage(uint32_t client, uint8_t command, EID hiredEID,
                            const char* script);

    psHiredNPCScriptMessage(uint32_t client, uint8_t command, EID hiredEID,
                            const char* locationType, const char* locationName);

    psHiredNPCScriptMessage(uint32_t client, uint8_t command, EID hiredEID,
                            const char* workLocation, bool workLocationValid,
                            const char* script);

    psHiredNPCScriptMessage(MsgEntry* me);

    PSF_DECLARE_MSG_FACTORY();

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

};


#endif