adminmanager.h

Go to the documentation of this file.

/*
 * adminmanager.h
 *
 * Copyright (C) 2001 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 __ADMINMANAGER_H__
#define __ADMINMANAGER_H__

//=============================================================================
// Crystal Space Includes
//=============================================================================
#include <csutil/ref.h>

//=============================================================================
// Project Includes
//=============================================================================
#include "net/messages.h"            // Chat Message definitions
#include "util/psconst.h"
#include "util/waypoint.h"

//=============================================================================
// Local Includes
//=============================================================================
#include "msgmanager.h"             // Parent class
#include "gmeventmanager.h"

#define PETITION_GM 0xFFFFFFFF

//------------------------------------------------------------------------------------
// Forward Declarations
//------------------------------------------------------------------------------------
class psDatabase;
class psSpawnManager;
class psServer;
class psDatabase;
class EventManager;
class ClientConnectionSet;
class EntityManager;
class psSpawnManager;
class psAdminGameEvent;
class psNPCDialog;
class psItem;
class psSkillInfo;
struct Result;
class iResultSet;
class Client;
class psPathNetwork;
class LocationManager;
class psPath;
class Waypoint;
class WordArray;
class gemNPC;

enum GM_LEVEL
{
    GM_DEVELOPER = 30,
    GM_LEVEL_9 = 29,
    GM_LEVEL_8 = 28,
    GM_LEVEL_7 = 27,
    GM_LEVEL_6 = 26,
    GM_LEVEL_5 = 25,
    GM_LEVEL_4 = 24,
    GM_LEVEL_3 = 23,
    GM_LEVEL_2 = 22,
    GM_LEVEL_1 = 21,
    GM_LEVEL_0 = 20,
    GM_TESTER  = 10
};

class psRewardData
{
public:
    enum Reward_Type
    {
        REWARD_EXPERIENCE, 
        REWARD_FACTION, 
        REWARD_SKILL, 
        REWARD_MONEY, 
        REWARD_ITEM, 
        REWARD_PRACTICE 
    };

    Reward_Type rewardType; 

    psRewardData(Reward_Type prewardType);

    virtual ~psRewardData();

    virtual bool IsZero();

    //virtual void Award(int gmClientNum, Client* target);
};

class psRewardDataExperience : public psRewardData
{
public:
    int expDelta; 

    psRewardDataExperience(int pexpDelta);

    virtual bool IsZero(); 

};

class psRewardDataFaction : public psRewardData
{
public:
    csString factionName; 
    int factionDelta; 

    psRewardDataFaction(csString pfactionName, int pfactionDelta);

    virtual bool IsZero(); 
};

class psRewardDataSkill : public psRewardData
{
public:
    csString skillName;
    int skillDelta; 
    unsigned int skillCap; 

    bool relativeSkill;

    psRewardDataSkill(csString pskillName, int pskillDelta, int pskillCap, bool prelativeSkill);

    virtual bool IsZero(); 
};

class psRewardDataPractice : public psRewardData
{
public:
    csString skillName;
    int practice; 

    psRewardDataPractice(csString pSkillName, int pDelta);

    virtual bool IsZero(); 
};

class psRewardDataMoney : public psRewardData
{
public:
    csString moneyType; 

    int moneyCount;
    bool random; 

    psRewardDataMoney(csString pmoneyType, int pmoneyCount, bool prandom);

    virtual bool IsZero(); 
};

class psRewardDataItem : public psRewardData
{
public:
    csString itemName; 
    unsigned short stackCount; 

    psRewardDataItem(csString pitemName, int pstackCount);

    virtual bool IsZero(); 
};

enum ADMINCMD_TARGET_TYPES
{
    ADMINCMD_TARGET_UNKNOWN = 0, 
    ADMINCMD_TARGET_TARGET = 1, 
    ADMINCMD_TARGET_PID = 1 << 1, 
    ADMINCMD_TARGET_AREA = 1 << 2, 
    ADMINCMD_TARGET_ME = 1 << 3, 
    ADMINCMD_TARGET_PLAYER = 1 << 4, 
    ADMINCMD_TARGET_OBJECT = 1 << 5, 
    ADMINCMD_TARGET_NPC = 1 << 6, 
    ADMINCMD_TARGET_EID = 1 << 7, 
    ADMINCMD_TARGET_ITEM = 1 << 8, 
    ADMINCMD_TARGET_CLIENTTARGET = 1 << 9, 
    ADMINCMD_TARGET_ACCOUNT = 1 << 10, 
    ADMINCMD_TARGET_DATABASE = 1 << 11, 
    ADMINCMD_TARGET_STRING = 1 << 14 
};

class AdminCmdData
{
public:
    csString command; 
    bool help; 
    bool valid; 

    AdminCmdData(csString commandName)
        : command(commandName), help(false), valid(true)
    {}

    AdminCmdData(csString commandName, WordArray &words);

    virtual ~AdminCmdData()
    {}

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();

    void ParseError(MsgEntry* me, const char* errmsg);

    virtual bool LogGMCommand(Client* gmClient, const char* cmd);

    virtual bool IsQuietInvalid()
    {
        return false;
    }

protected:
    bool LogGMCommand(Client* gmClient, PID playerID, const char* cmd);

    bool IsHelp(const csString &word)
    {
        help = (word == "help");
        return help;
    }
};

class AdminCmdTargetParser
{
public:
    gemObject* targetObject; 
    gemActor* targetActor; 
    Client* targetClient; 

    bool area; 
    bool duplicateActor;
    csString target; 
    PID targetID; 

    AdminCmdTargetParser(int targetTypes)
        : targetObject(NULL), targetActor(NULL), targetClient(NULL),
        area(false), duplicateActor(false), target(), targetID(),
        allowedTargetTypes(targetTypes), targetTypes(ADMINCMD_TARGET_UNKNOWN),
        targetAccountID()
    {}

    virtual ~AdminCmdTargetParser()
    {}

    bool IsTargetTypeUnknown()
    {
        return (targetTypes == ADMINCMD_TARGET_UNKNOWN);
    }

    bool IsAllowedTargetType(ADMINCMD_TARGET_TYPES targetType)
    {
        return (allowedTargetTypes & targetType);
    }

    bool IsTargetType(ADMINCMD_TARGET_TYPES targetType)
    {
        return (targetTypes & targetType);
    }

    virtual bool ParseTarget(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, csString target);

    virtual csString GetHelpMessagePartForTarget();

    virtual AccountID GetAccountID(size_t gmClientNum);

    bool IsOnline()
    {
        return (targetObject != NULL);
    }

protected:
    int allowedTargetTypes; 
    int targetTypes; 
    AccountID targetAccountID; 

    bool GetPlayerAccountIDByPID(size_t gmClientNum, const csString &word);

    bool GetPlayerAccountIDByPIDFromName(size_t gmClientNum, const csString &word, bool reporterror);

    bool GetPlayerAccountIDByName(size_t gmClientNum, const csString &word, bool reporterror);

    bool GetPlayerClient(AdminManager* msgManager, size_t gmClientNum, const csString &playerName, bool allowduplicate);

    virtual void Reset();
};

class AdminCmdSubCommandParser
{
public:
    csHash<csString, csString> subCommands; 

    AdminCmdSubCommandParser()
    {}

    AdminCmdSubCommandParser(csString commandList);

    virtual ~AdminCmdSubCommandParser()
    {}

    virtual csString GetHelpMessage();

    virtual csString GetHelpMessage(const csString &subcommand);

    bool IsSubCommand(const csString &word);

    void Push(csString subcommand, csString helpmsg);
};

class AdminCmdRewardParser
{
public:
    AdminCmdSubCommandParser rewardTypes; 

    csPDelArray<psRewardData> rewards;  
    csString error; 


    AdminCmdRewardParser();

    ~AdminCmdRewardParser()
    {}

    bool ParseWords(size_t index, const WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdOnOffToggleParser
{
public:
    enum ADMINCMD_SETTING_ONOFF
    {
        ADMINCMD_SETTING_UNKNOWN = 0, 
        ADMINCMD_SETTING_ON = 1, 
        ADMINCMD_SETTING_OFF, 
        ADMINCMD_SETTING_TOGGLE 
    };

    ADMINCMD_SETTING_ONOFF value; 
    csString error; 

    AdminCmdOnOffToggleParser(ADMINCMD_SETTING_ONOFF defaultValue = ADMINCMD_SETTING_UNKNOWN);

    csString GetHelpMessage();

    bool IsOn();

    bool IsOff();

    bool IsToggle();

    bool ParseWord(const csString &word);
};

class AdminCmdDataTarget : public AdminCmdData, public AdminCmdTargetParser
{
public:
    AdminCmdDataTarget(csString commandName, int targetTypes)
        : AdminCmdData(commandName), AdminCmdTargetParser(targetTypes)
    {}

    AdminCmdDataTarget(csString commandName, int targetTypes, AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataTarget()
    {}

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();

    virtual bool LogGMCommand(Client* gmClient, const char* cmd);

    virtual bool IsQuietInvalid()
    {
        return IsTargetType(ADMINCMD_TARGET_AREA);
    }
};

class AdminCmdDataTargetReason : public AdminCmdDataTarget
{
public:
    csString reason; 

    AdminCmdDataTargetReason(csString command)
        : AdminCmdDataTarget(command, ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_EID |ADMINCMD_TARGET_CLIENTTARGET)
    {};

    AdminCmdDataTargetReason(csString command, AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataTargetReason()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataDeath : public AdminCmdDataTarget
{
public:
    csString requestor; 

    AdminCmdDataDeath()
        : AdminCmdDataTarget("/death",  ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_CLIENTTARGET | ADMINCMD_TARGET_NPC | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_EID)
    {};

    AdminCmdDataDeath(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataDeath()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataDeleteChar : public AdminCmdDataTarget
{
public:
    AdminCmdTargetParser requestor; 

    AdminCmdDataDeleteChar()
        : AdminCmdDataTarget("/deletechar", ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_PID), requestor(ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET | ADMINCMD_TARGET_DATABASE)
    {};

    AdminCmdDataDeleteChar(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataDeleteChar()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};


class AdminCmdDataUpdateRespawn : public AdminCmdDataTarget
{
public:
    csString place; 

    AdminCmdDataUpdateRespawn()
        : AdminCmdDataTarget("/updaterespawn", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_NPC | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET)
    {};

    AdminCmdDataUpdateRespawn(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataUpdateRespawn()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataBan : public AdminCmdDataTarget
{
public:
    int minutes; 
    int hours;   
    int days;    
    bool banIP;  
    csString reason; 

    AdminCmdDataBan()
        : AdminCmdDataTarget("/ban", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_ACCOUNT | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET | ADMINCMD_TARGET_DATABASE)
    {};

    AdminCmdDataBan(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataBan()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataKillNPC : public AdminCmdDataTarget
{
public:
    bool   reload; 
    float  damage; 

    AdminCmdDataKillNPC()
        : AdminCmdDataTarget("/killnpc", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_NPC | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET | ADMINCMD_TARGET_DATABASE), reload(false), damage(0.0)
    {};

    AdminCmdDataKillNPC(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataKillNPC()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataPercept : public AdminCmdDataTarget
{
public:
    csString perception; 
    csString type;       

    AdminCmdDataPercept()
        : AdminCmdDataTarget("/percept", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_NPC | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET)
    {};

    AdminCmdDataPercept(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataPercept()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataChangeNPCType : public AdminCmdDataTarget
{
public:
    csString npcType; 

    AdminCmdDataChangeNPCType()
        : AdminCmdDataTarget("/changenpctype", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_NPC | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET), npcType("")
    {};

    AdminCmdDataChangeNPCType(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataChangeNPCType()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataDebugNPC : public AdminCmdDataTarget
{
public:
    int debugLevel; 

    AdminCmdDataDebugNPC()
        : AdminCmdDataTarget("/debugnpc", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_NPC | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET), debugLevel(0)
    {};

    AdminCmdDataDebugNPC(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataDebugNPC()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataDebugTribe : public AdminCmdDataTarget
{
public:
    int debugLevel; 

    AdminCmdDataDebugTribe()
        : AdminCmdDataTarget("/debugtribe", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_NPC | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET), debugLevel(0)
    {};

    AdminCmdDataDebugTribe(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataDebugTribe() {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataSetStackable : public AdminCmdDataTarget
{
public:
    AdminCmdSubCommandParser subCommandList; 
    csString stackableAction; 

    AdminCmdDataSetStackable()
        : AdminCmdDataTarget("/setstackable", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_ITEM | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET), subCommandList("info on off reset help")
    {};

    AdminCmdDataSetStackable(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataSetStackable()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataLoadQuest : public AdminCmdData
{
public:
    csString questName; 

    AdminCmdDataLoadQuest()
        : AdminCmdData("/loadquest")
    {};

    AdminCmdDataLoadQuest(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataLoadQuest()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataInfo : public AdminCmdDataTarget
{
public:
    csString subCmd; 

    AdminCmdDataInfo()
        : AdminCmdDataTarget("/info", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_OBJECT | ADMINCMD_TARGET_NPC | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_ITEM | ADMINCMD_TARGET_CLIENTTARGET | ADMINCMD_TARGET_DATABASE), subCmd("summary")
    {};

    AdminCmdDataInfo(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataInfo()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataItem : public AdminCmdDataTarget
{
public:
    bool random; 
    int quality; 
    int quantity; 

    AdminCmdDataItem()
        : AdminCmdDataTarget("/item", ADMINCMD_TARGET_ITEM | ADMINCMD_TARGET_STRING), random(false), quality(50), quantity(1)
    {}

    AdminCmdDataItem(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataItem()
    {}

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataKey : public AdminCmdDataTarget
{
public:
    AdminCmdSubCommandParser subCommandList; 
    AdminCmdSubCommandParser subTargetCommandList; 
    csString subCommand; 

    AdminCmdDataKey()
        : AdminCmdDataTarget("/key", ADMINCMD_TARGET_ITEM | ADMINCMD_TARGET_OBJECT | ADMINCMD_TARGET_CLIENTTARGET),
          subCommandList("make makemaster copy clearlocks skel"),
          subTargetCommandList("changelock makeunlockable securitylockable addlock removelock")
    {};

    AdminCmdDataKey(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataKey()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataRunScript : public AdminCmdDataTarget
{
public:
    csString scriptName; 
    AdminCmdTargetParser origObj; 

    AdminCmdDataRunScript()
        : AdminCmdDataTarget("/runscript", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_OBJECT | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_NPC | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_ITEM | ADMINCMD_TARGET_CLIENTTARGET), origObj(ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_OBJECT | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_NPC | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_ITEM | ADMINCMD_TARGET_CLIENTTARGET)
    {};

    AdminCmdDataRunScript(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataRunScript()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataCrystal : public AdminCmdDataTarget
{
public:
    int interval; 
    int random; 
    int amount; 
    float range; 
    csString itemName; 

    AdminCmdDataCrystal()
        : AdminCmdDataTarget("/hunt_location", ADMINCMD_TARGET_ITEM | ADMINCMD_TARGET_STRING)
    {};

    AdminCmdDataCrystal(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataCrystal()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataTeleport : public AdminCmdDataTarget
{
public:
    AdminCmdSubCommandParser destList; 

    AdminCmdTargetParser destObj;
    InstanceID destInstance; 
    bool destInstanceValid; 
    csString dest; 
    csString destMap; 
    csString destSector; 
    float x; 
    float y; 
    float z; 

    AdminCmdDataTeleport()
        : AdminCmdDataTarget("/teleport", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_OBJECT | ADMINCMD_TARGET_NPC | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_ITEM | ADMINCMD_TARGET_DATABASE), destList("here there last spawn restore"), destObj(ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_OBJECT | ADMINCMD_TARGET_NPC | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_ITEM)
    {};

    AdminCmdDataTeleport(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataTeleport()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataSlide : public AdminCmdDataTarget
{
public:
    csString direction; 
    float slideAmount; 

    AdminCmdDataSlide()
        : AdminCmdDataTarget("/slide", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_NPC | ADMINCMD_TARGET_OBJECT | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_ITEM | ADMINCMD_TARGET_CLIENTTARGET), slideAmount(0)
    {}

    AdminCmdDataSlide(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataSlide()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataChangeName : public AdminCmdDataTarget
{
public:
    bool uniqueName; 
    bool uniqueFirstName; 
    csString newName; 
    csString newLastName; 

    AdminCmdDataChangeName()
        : AdminCmdDataTarget("/changename", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET | ADMINCMD_TARGET_DATABASE), uniqueName(true), uniqueFirstName(true)
    {};

    AdminCmdDataChangeName(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataChangeName()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};


class AdminCmdDataChangeGuildName : public AdminCmdData
{
public:
    csString guildName; 
    csString newName; 

    AdminCmdDataChangeGuildName()
        : AdminCmdData("/changeguildname")
    {};

    AdminCmdDataChangeGuildName(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataChangeGuildName()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataChangeGuildLeader : public AdminCmdDataTarget
{
public:
    csString guildName; 

    AdminCmdDataChangeGuildLeader()
        : AdminCmdDataTarget("/changeguildleader", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET | ADMINCMD_TARGET_DATABASE)
    {};

    AdminCmdDataChangeGuildLeader(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataChangeGuildLeader()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataPetition : public AdminCmdData
{
public:
    csString petition; 

    AdminCmdDataPetition()
        : AdminCmdData("/petition")
    {};

    AdminCmdDataPetition(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataPetition()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataImpersonate : public AdminCmdDataTarget
{
public:
    csString commandMod; 
    csString text; 
    int duration; 

    AdminCmdDataImpersonate()
        : AdminCmdDataTarget("/impersonate", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_CLIENTTARGET | ADMINCMD_TARGET_NPC | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_ITEM | ADMINCMD_TARGET_OBJECT)
    {};

    AdminCmdDataImpersonate(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataImpersonate()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataDeputize : public AdminCmdDataTarget
{
public:
    csString securityLevel; 

    AdminCmdDataDeputize()
        : AdminCmdDataTarget("/deputize", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET)
    {};

    AdminCmdDataDeputize(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataDeputize()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataAward : public AdminCmdDataTarget
{
public:
    AdminCmdRewardParser rewardList; 

    AdminCmdDataAward()
        : AdminCmdDataTarget("/award", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_EID |ADMINCMD_TARGET_CLIENTTARGET)
    {};

    AdminCmdDataAward(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataAward()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataItemTarget : public AdminCmdDataTarget
{
public:
    csString itemName; 
    int stackCount; 

    AdminCmdDataItemTarget(csString command)
        : AdminCmdDataTarget(command, ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA |ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_EID |ADMINCMD_TARGET_CLIENTTARGET), stackCount(0)
    {};

    AdminCmdDataItemTarget(csString command, AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataItemTarget()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataCheckItem : public AdminCmdDataItemTarget
{
public:
    AdminCmdDataCheckItem()
        : AdminCmdDataItemTarget("/checkitem")
    {};

    AdminCmdDataCheckItem(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataCheckItem()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataSectorTarget : public AdminCmdData
{
public:
    bool isClientSector; 
    csString sectorName;    
    psSectorInfo* sectorInfo; 

    AdminCmdDataSectorTarget(csString command)
        : AdminCmdData(command), isClientSector(false), sectorInfo(NULL)
    {};

    AdminCmdDataSectorTarget(csString command, AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataSectorTarget()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();

    virtual bool ParseTarget(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, csString target);


    virtual bool GetSectorOfClient(Client* client);
};

class AdminCmdDataWeather : public AdminCmdDataSectorTarget
{
public:
    bool enabled; 
    int type; 

    AdminCmdDataWeather()
        : AdminCmdDataSectorTarget("/weather"), enabled(false), type(0)
    {};

    AdminCmdDataWeather(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataWeather()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataWeatherEffect : public AdminCmdDataSectorTarget
{
public:
    bool enabled; 
    int particleCount; 
    int interval; 
    int fadeTime; 

    AdminCmdDataWeatherEffect(csString command)
        : AdminCmdDataSectorTarget(command), enabled(false), particleCount(4000), interval(600000), fadeTime(10000)
    {};

    AdminCmdDataWeatherEffect(csString command, AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataWeatherEffect()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataFog : public AdminCmdDataSectorTarget
{
public:
    bool enabled; 
    int density; 
    int fadeTime; 
    int interval; 
    int r; 
    int g; 
    int b; 

    AdminCmdDataFog()
        : AdminCmdDataSectorTarget("/fog"), enabled(false), density(200), fadeTime(10000), interval(0), r(200), g(200), b(200)
    {};

    AdminCmdDataFog(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataFog()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataModify : public AdminCmdDataTarget
{
public:
    AdminCmdSubCommandParser attributeList;
    csString subCommand; 
    int interval; 
    int maxinterval; 
    int amount; 
    int range; 
    float x; 
    float y; 
    float z; 
    float rot; 
    csString skillName; 
    int level; 
    bool enabled; 

    AdminCmdDataModify()
        : AdminCmdDataTarget("/modify", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_ITEM | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET), attributeList("pickupable unpickable transient npcowned collide settingitem")
    {};

    AdminCmdDataModify(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataModify()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataMorph : public AdminCmdDataTarget
{
public:
    csString subCommand; 
    csString raceName;   
    csString genderName; 
    csString scale;      

    AdminCmdDataMorph()
        : AdminCmdDataTarget("/morph", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_CLIENTTARGET | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_EID)
    {};

    AdminCmdDataMorph(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataMorph()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataScale : public AdminCmdDataTarget
{
public:
    csString subCommand; 
    csString scale;      

    AdminCmdDataScale()
        : AdminCmdDataTarget("/scale", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_CLIENTTARGET | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_EID)
    {};

    AdminCmdDataScale(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataScale()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};


class AdminCmdDataSetSkill : public AdminCmdDataTarget
{
public:
    AdminCmdTargetParser sourcePlayer;
    csString subCommand; 
    psRewardDataSkill skillData; 
    /*
    csString skillName; ///< Name of the skill to set
    int value; ///< value of the skill
    bool relative; ///< when the value should be relative
    */

    AdminCmdDataSetSkill()
        : AdminCmdDataTarget("/setskill", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET), sourcePlayer(ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_NPC | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET), subCommand(), skillData("",0,0,false)
    {};

    AdminCmdDataSetSkill(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataSetSkill()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataSet : public AdminCmdDataTarget
{
public:
    AdminCmdSubCommandParser subCommandList; 
    AdminCmdSubCommandParser attributeList; 
    AdminCmdOnOffToggleParser setting; 

    csString subCommand; 
    csString attribute; 

    AdminCmdDataSet()
        : AdminCmdDataTarget("/set", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_NPC | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET | ADMINCMD_TARGET_ME), subCommandList("list gm player"), attributeList("invincible invincibility invisibility invisible viewall nevertired nofalldamage infiniteinventory questtester infinitemana instantcast givekillexp attackable buddyhide"), setting()
    {};

    AdminCmdDataSet(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataSet()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataSetLabelColor : public AdminCmdDataTarget
{
public:
    AdminCmdSubCommandParser labelTypeList; 

    csString labelType; 

    AdminCmdDataSetLabelColor()
        : AdminCmdDataTarget("/setlabelcolor", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA  | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_CLIENTTARGET | ADMINCMD_TARGET_EID), labelTypeList("normal alive dead npc tester gm gm1 player")
    {};

    AdminCmdDataSetLabelColor(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataSetLabelColor()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataAction : public AdminCmdDataSectorTarget
{
public:
    AdminCmdSubCommandParser subCommandList; 
    csString subCommand; 
    csString guildName; 
    csString description; 

    AdminCmdDataAction()
        : AdminCmdDataSectorTarget("/action"), subCommandList("create_entrance")
    {};

    AdminCmdDataAction(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataAction()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataLocation : public AdminCmdData
{
public:
    AdminCmdSubCommandParser subCommandList; 
    csString subCommand; 
    csString locationType; 
    csString locationName; 
    float radius; 
    float searchRadius; 
    float rotAngle; 

    AdminCmdDataLocation()
        : AdminCmdData("/location"), subCommandList("help adjust display hide")
    {};

    AdminCmdDataLocation(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataLocation()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataPath : public AdminCmdData
{
public:
    AdminCmdSubCommandParser subCommandList; 
    AdminCmdSubCommandParser aliasSubCommandList; 
    AdminCmdSubCommandParser wpList; 
    csString subCmd;    
    csString aliasSubCmd; 
    bool wpOrPathIsWP; 
    float defaultRadius; 
    float radius; 
    float newRadius; 
    csString waypoint; 
    csString alias; 
    csString flagName; 
    csString waypointPathName; 
    int firstIndex; 
    csString waypointFlags; 
    csString pathFlags; 
    csString cmdTarget; 
    int waypointPathIndex; 
    bool wpOrPathIsIndex; 
    float rotationAngle; 


    AdminCmdDataPath()
        : AdminCmdData("/path"), subCommandList("adjust alias display format help hide info point start stop"), aliasSubCommandList("add remove"), wpList("waypoints points"), subCmd(), defaultRadius(2.0)
    {};

    AdminCmdDataPath(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataPath()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataGameMasterEvent : public AdminCmdData
{
public:
    AdminCmdSubCommandParser subCommandList; 
    csString subCmd; 

    AdminCmdTargetParser player; 
    AdminCmdRewardParser rewardList; 

    csString gmeventName; 
    csString gmeventDesc; 

    csString commandMod; 
    RangeSpecifier rangeSpecifier; 
    float range; 

    AdminCmdDataGameMasterEvent()
        : AdminCmdData("/event"), subCommandList("help list"), subCmd(), player(ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_CLIENTTARGET)
    {};

    AdminCmdDataGameMasterEvent(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataGameMasterEvent()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataHire : public AdminCmdData
{
public:
    AdminCmdSubCommandParser subCommandList; 
    csString  subCmd;      
    csString  typeName;    
    csString  typeNPCType; 
    PID       masterPID;   

    gemActor* owner;
    gemNPC*   hiredNPC;

    AdminCmdDataHire()
        : AdminCmdData("/hire"), subCommandList("help list"), subCmd(), owner(NULL), hiredNPC(NULL)
    {};

    AdminCmdDataHire(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataHire()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataBadText : public AdminCmdDataTarget
{
public:
    int first; 
    int last; 

    AdminCmdDataBadText()
        : AdminCmdDataTarget("/badtext", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_NPC | ADMINCMD_TARGET_EID |ADMINCMD_TARGET_CLIENTTARGET)
    {};

    AdminCmdDataBadText(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataBadText()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataQuest : public AdminCmdDataTarget
{
public:
    AdminCmdSubCommandParser subCommandList; 
    csString subCmd; 
    csString questName; 

    AdminCmdDataQuest()
        : AdminCmdDataTarget("/quest", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET | ADMINCMD_TARGET_DATABASE),
          subCommandList("complete list discard assign")
    {};

    AdminCmdDataQuest(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataQuest()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataSetQuality : public AdminCmdDataTarget
{
public:
    int quality; 
    int qualityMax; 

    AdminCmdDataSetQuality()
        : AdminCmdDataTarget("/setquality", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_AREA |ADMINCMD_TARGET_ITEM | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET)
    {};

    AdminCmdDataSetQuality(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataSetQuality()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataSetTrait : public AdminCmdDataTarget
{
public:
    csString subCmd; 
    csString race; 
    PSCHARACTER_GENDER gender; 
    csString traitName; 

    AdminCmdDataSetTrait()
        : AdminCmdDataTarget("/settrait", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET)
    {};

    AdminCmdDataSetTrait(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataSetTrait()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataSetItem : public AdminCmdDataTarget
{
public:
    csString name; 
    csString description; 

    AdminCmdDataSetItem()
        : AdminCmdDataTarget("/setitemname", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_ITEM | ADMINCMD_TARGET_EID |ADMINCMD_TARGET_CLIENTTARGET)
    {};

    AdminCmdDataSetItem(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataSetItem()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataReload : public AdminCmdData
{
public:
    csString subCmd; 
    int itemID; 
    AdminCmdSubCommandParser subCommandList; 

    AdminCmdDataReload()
        : AdminCmdData("/reload"), itemID(0)
    {};

    AdminCmdDataReload(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataReload()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataListWarnings : public AdminCmdDataTarget
{
public:
    AdminCmdDataListWarnings()
        : AdminCmdDataTarget("/listwarnings", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_CLIENTTARGET | ADMINCMD_TARGET_DATABASE)
    {};

    AdminCmdDataListWarnings(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataListWarnings()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataDisableQuest : public AdminCmdData
{
public:
    csString questName; 
    bool saveToDb; 

    AdminCmdDataDisableQuest()
        : AdminCmdData("/disablequest")
    {};

    AdminCmdDataDisableQuest(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataDisableQuest()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataSetKillExp : public AdminCmdDataTarget
{
public:
    int expValue; 

    AdminCmdDataSetKillExp()
        : AdminCmdDataTarget("/setkillexp", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET)
    {};

    AdminCmdDataSetKillExp(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataSetKillExp()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataAssignFaction : public AdminCmdDataTarget
{
public:
    csString factionName; 
    int factionPoints; 

    AdminCmdDataAssignFaction()
        : AdminCmdDataTarget("/assignfaction", ADMINCMD_TARGET_TARGET | ADMINCMD_TARGET_PID | ADMINCMD_TARGET_AREA | ADMINCMD_TARGET_ME | ADMINCMD_TARGET_PLAYER | ADMINCMD_TARGET_EID | ADMINCMD_TARGET_CLIENTTARGET)
    {};

    AdminCmdDataAssignFaction(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataAssignFaction()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataServerQuit : public AdminCmdData
{
public:
    csString reason; 
    int time; 

    AdminCmdDataServerQuit()
        : AdminCmdData("/serverquit")
    {};

    AdminCmdDataServerQuit(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataServerQuit()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataNPCClientQuit : public AdminCmdData
{
public:
    AdminCmdDataNPCClientQuit()
        : AdminCmdData("/npcclientquit")
    {};

    AdminCmdDataNPCClientQuit(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataNPCClientQuit()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataSimple : public AdminCmdData
{
public:
    AdminCmdDataSimple(csString commandName)
        : AdminCmdData(commandName)
    {};

    AdminCmdDataSimple(csString commandName, AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataSimple()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};


class AdminCmdDataRndMsgTest : public AdminCmdData
{
public:
    csString text; 
    bool sequential; 

    AdminCmdDataRndMsgTest()
        : AdminCmdData("/rndmsgtest")
    {};

    AdminCmdDataRndMsgTest(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataRndMsgTest()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataList : public AdminCmdData
{
public:
    AdminCmdSubCommandParser subCommandList; 
    csString subCommand; 

    AdminCmdDataList()
        : AdminCmdData("/list"), subCommandList("map")
    {};

    AdminCmdDataList(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataList()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};

class AdminCmdDataTime : public AdminCmdData
{
public:
    AdminCmdSubCommandParser subCommandList; 
    csString subCommand; 
    int hour,minute;

    AdminCmdDataTime()
        : AdminCmdData("/time"), subCommandList("show set"), hour(0), minute(0)
    {}

    AdminCmdDataTime(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual ~AdminCmdDataTime()
    {};

    virtual AdminCmdData* CreateCmdData(AdminManager* msgManager, MsgEntry* me, psAdminCmdMessage &msg, Client* client, WordArray &words);

    virtual csString GetHelpMessage();
};


class AdminCmdDataFactory
{
public:
    AdminCmdDataFactory();
    virtual ~AdminCmdDataFactory();

    AdminCmdData* FindFactory(csString datatypename);

    /*/* @brief Register a new AdminCmdData for a command.
     * @param func Factory function that creates data objects for the command
     * @param datatypename Name of the command to search for (including /)
     */
    //void RegisterMsgFactoryFunction(AdminCmdMsgFactoryFunc func, const char* datatypename);

    void RegisterMsgFactoryFunction(AdminCmdData* obj);

protected:
    csPDelArray<AdminCmdData> adminCmdDatas; 
};

class AdminManager : public MessageManager<AdminManager>, public iEffectIDAllocator
{
public:
    AdminManager();
    virtual ~AdminManager();

    void Admin(int clientnum, Client* client, int requestedLevel = -1);

    void AwardExperienceToTarget(int gmClientnum, Client* target, int ppAward);

    void AdjustFactionStandingOfTarget(int gmClientnum, Client* target, csString factionName, int standingDelta);

    bool ApplySkill(int gmClientNum, Client* target, psSkillInfo* skill, int value, bool relative = false, int cap = 0);

    void AwardToTarget(unsigned int gmClientNum, Client* target, psRewardData* data);

    bool GetStartOfMap(int clientnum, const csString &map, iSector* &targetSector,  csVector3 &targetPoint);

    void HandleNpcCommand(MsgEntry* pMsg, Client* client);

    psPathNetwork* GetPathNetwork()
    {
        return pathNetwork;
    }

    LocationManager* GetLocationManager()
    {
        return locations;
    }

protected:
    AdminCmdDataFactory* dataFactory;

    bool IsReseting(const csString &command);

    void HandleAdminCmdMessage(MsgEntry* pMsg, Client* client);

    void HandlePetitionMessage(MsgEntry* pMsg, Client* client);

    void HandleGMGuiMessage(MsgEntry* pMsg, Client* client);

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

    void SpawnItemInv(MsgEntry* me, psGMSpawnItem &msg, Client* client);

    void HandleLoadQuest(psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void GetSiblingChars(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);


    void GetInfo(MsgEntry* me,psAdminCmdMessage &msg, AdminCmdData* data,Client* client);


    void CreateNPC(MsgEntry* me,psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void KillNPC(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void Percept(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void ChangeNPCType(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* cmddata, Client* client);

    void DebugNPC(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* cmddata, Client* client);

    void DebugTribe(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* cmddata, Client* client);

    void CreateItem(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void ModifyKey(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void ChangeLock(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void MakeUnlockable(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void MakeSecurity(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);


    void MakeKey(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client, bool masterkey);

    void CopyKey(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client, psItem* key);

    void AddRemoveLock(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client,psItem* key);

    void RunScript(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void CreateHuntLocation(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void ModifyItem(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void Slide(MsgEntry* me,psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void TeleportOfflineCharacter(Client* client, AdminCmdDataTeleport* data);

    void Teleport(MsgEntry* me,psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    bool GetTargetOfTeleport(Client* client, psAdminCmdMessage &msg, AdminCmdData* data, iSector* &targetSector,  csVector3 &targetPoint, float &yRot, gemObject* subject, InstanceID &instance);

    bool MoveObject(Client* client, gemObject* target, csVector3 &pos, float yrot, iSector* sector, InstanceID instance);

    void WarnMessage(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void KickPlayer(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void MutePlayer(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void UnmutePlayer(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void Death(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void Impersonate(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void SetAttrib(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void SetLabelColor(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void Divorce(MsgEntry* me, AdminCmdData* data);

    void ViewMarriage(MsgEntry* me, AdminCmdData* data);

    int PathPointCreate(int pathID, int prevPointId, csVector3 &pos, csString &sectorName);

    void FindPath(csVector3 &pos, iSector* sector, float radius,
                  Waypoint** wp, float* rangeWP,
                  psPath** path, float* rangePath, int* indexPath, float* fraction,
                  psPath** pointPath, float* rangePoint, int* indexPoint);

    virtual uint32_t GetEffectID();

    void HideAllPaths(bool clearSelected);

    void HidePaths(Client* client);

    void HideWaypoints(Client* client);

    void HidePaths(Client* client, iSector* sector);

    void HideWaypoints(Client* client, iSector* sector);

    void RedisplayAllPaths();

    void ShowPaths(Client* client);

    void ShowWaypoints(Client* client);

    void ShowPaths(Client* client, iSector* sector);

    void ShowWaypoints(Client* client, iSector* sector);

    void UpdateDisplayPath(psPathPoint* point);

    void UpdateDisplayWaypoint(Waypoint* wp);

    void HandlePath(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    int LocationCreate(int typeID, csVector3 &pos, csString &sectorName, csString &name, int radius);

    void ShowLocations(Client* client);

    void ShowLocations(Client* client, iSector* sector);

    void HideAllLocations(bool clearSelected);

    void HideLocations(Client* client);

    void HideLocations(Client* client, iSector* sector);

    void RedisplayAllLocations();

    void UpdateDisplayLocation(Location* location);

    void HandleLocation(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void HandleActionLocation(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void HandleAddPetition(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data,Client* client);

    void BroadcastDirtyPetitions(int clientNum, bool includeSelf=false);

    bool GetPetitionsArray(csArray<psPetitionInfo> &petitions, Client* client, bool IsGMrequest = false);

    void ListPetitions(MsgEntry* me, psPetitionRequestMessage &msg, Client* client);

    void CancelPetition(MsgEntry* me, psPetitionRequestMessage &msg, Client* client);

    void ChangePetition(MsgEntry* me, psPetitionRequestMessage &msg, Client* client);

    void GMListPetitions(MsgEntry* me, psPetitionRequestMessage &msg, Client* client);

    void GMHandlePetition(MsgEntry* me, psPetitionRequestMessage &msg, Client* client);

    void SendGMPlayerList(MsgEntry* me, psGMGuiMessage &msg, Client* client);

    void HandleList(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data,Client* client);

    void HandleTime(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data,Client* client);

    void ChangeName(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void UpdateRespawn(AdminCmdData* data, Client* client);

    void Weather(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void Rain(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void Snow(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void Thunder(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void Fog(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void DeleteCharacter(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void BanName(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void UnBanName(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void BanClient(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void UnbanClient(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void BanAdvisor(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void UnbanAdvisor(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void SendSpawnTypes(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

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

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

    void RenameGuild(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void ChangeGuildLeader(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void SendAwardInfo(size_t gmClientnum, Client* target, const char* awardname, const char* awarddesc, int awarded);

    void AwardExperience(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client, Client* target);

    void Award(AdminCmdData* data, Client* client);

    void TransferItem(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void CheckItem(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data);

    void FreezeClient(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void ThawClient(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void Inspect(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void SetSkill(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void Morph(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void Scale(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void TempSecurityLevel(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    int GetTrueSecurityLevel(AccountID accountID);

    void HandleGMEvent(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void HandleHire(AdminCmdData* data, Client* client);

    void HandleBadText(psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void HandleQuest(MsgEntry* me,psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void HandleSetQuality(psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void ItemStackable(MsgEntry* me, AdminCmdData* data, Client* client);

    void HandleSetTrait(psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void HandleSetItemName(psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void HandleReload(psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void HandleListWarnings(psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void CheckTarget(psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void DisableQuest(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void SetKillExp(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void AssignFaction(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void HandleServerQuit(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void HandleNPCClientQuit(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    void HandleVersion(MsgEntry* me, psAdminCmdMessage &msg, AdminCmdData* data, Client* client);

    bool AddPetition(PID playerID, const char* petition);

    iResultSet* GetPetitions(PID playerID, PID gmID = PETITION_GM);

    bool CancelPetition(PID playerID, int petitionID, bool isGMrequest = false);

    bool ChangePetition(PID playerID, int petitionID, const char* petition);

    bool ClosePetition(PID gmID, int petitionID, const char* desc);

    bool AssignPetition(PID gmID, int petitionID);

    bool DeassignPetition(PID gmID, int gmLevel, int petitionID);

    bool EscalatePetition(PID gmID, int gmLevel, int petitionID);

    bool DescalatePetition(PID gmID, int gmLevel, int petitionID);

    bool LogGMCommand(AccountID accountID, PID gmID, PID playerID, const char* cmd);

    void RandomMessageTest(AdminCmdData* data, Client* client);

    const char* GetLastSQLError();

    csString lasterror; 

    ClientConnectionSet* clients; 


    void SendGMAttribs(Client* client);

    psNPCDialog* npcdlg;

    psPathNetwork* pathNetwork;

    LocationManager* locations;
};

#endif