1112 lines
38 KiB
C++
1112 lines
38 KiB
C++
|
|
#include "common.h"
|
|
#include "PseuWoW.h"
|
|
#include "DefScript/DefScript.h"
|
|
#include "DefScript/DefScriptTools.h"
|
|
#include "Player.h"
|
|
#include "Opcodes.h"
|
|
#include "SharedDefines.h"
|
|
#include "WorldSession.h"
|
|
#include "Channel.h"
|
|
#include "CacheHandler.h"
|
|
#include "SCPDatabase.h"
|
|
|
|
|
|
void DefScriptPackage::_InitDefScriptInterface(void)
|
|
{
|
|
AddFunc("pause",&DefScriptPackage::SCpause);
|
|
AddFunc("emote",&DefScriptPackage::SCemote);
|
|
AddFunc("follow",&DefScriptPackage::SCfollow);
|
|
AddFunc("savecache",&DefScriptPackage::SCsavecache);
|
|
AddFunc("sendchatmessage",&DefScriptPackage::SCSendChatMessage);
|
|
AddFunc("joinchannel",&DefScriptPackage::SCjoinchannel);
|
|
AddFunc("leavechannel",&DefScriptPackage::SCleavechannel);
|
|
AddFunc("listchannel",&DefScriptPackage::SClistchannel);
|
|
AddFunc("loadconf",&DefScriptPackage::SCloadconf);
|
|
AddFunc("applyconf",&DefScriptPackage::SCapplyconf);
|
|
AddFunc("applypermissions",&DefScriptPackage::SCapplypermissions);
|
|
AddFunc("log",&DefScriptPackage::SClog);
|
|
AddFunc("logdetail",&DefScriptPackage::SClogdetail);
|
|
AddFunc("logerror",&DefScriptPackage::SClogerror);
|
|
AddFunc("logdebug",&DefScriptPackage::SClogdebug);
|
|
AddFunc("castspell",&DefScriptPackage::SCcastspell);
|
|
AddFunc("queryitem",&DefScriptPackage::SCqueryitem);
|
|
AddFunc("target",&DefScriptPackage::SCtarget);
|
|
AddFunc("loadscp",&DefScriptPackage::SCloadscp);
|
|
AddFunc("scpexists",&DefScriptPackage::SCScpExists);
|
|
AddFunc("scpsectionexists",&DefScriptPackage::SCScpSectionExists);
|
|
AddFunc("scpentryexists",&DefScriptPackage::SCScpEntryExists);
|
|
AddFunc("getscpvalue",&DefScriptPackage::SCGetScpValue);
|
|
AddFunc("getplayerguid",&DefScriptPackage::SCGetPlayerGuid);
|
|
AddFunc("getname",&DefScriptPackage::SCGetName);
|
|
AddFunc("getentry",&DefScriptPackage::SCGetEntry);
|
|
AddFunc("getitemprotovalue",&DefScriptPackage::SCGetItemProtoValue);
|
|
AddFunc("getobjecttype",&DefScriptPackage::SCGetObjectType);
|
|
AddFunc("objectknown",&DefScriptPackage::SCObjectKnown);
|
|
AddFunc("getplayerperm",&DefScriptPackage::SCGetPlayerPerm);
|
|
AddFunc("getscriptperm",&DefScriptPackage::SCGetScriptPerm);
|
|
AddFunc("lgetfiles",&DefScriptPackage::SCGetFileList);
|
|
AddFunc("printscript",&DefScriptPackage::SCPrintScript);
|
|
AddFunc("getobjectvalue",&DefScriptPackage::SCGetObjectValue);
|
|
AddFunc("getrace",&DefScriptPackage::SCGetRace);
|
|
AddFunc("getclass",&DefScriptPackage::SCGetClass);
|
|
AddFunc("sendworldpacket",&DefScriptPackage::SCSendWorldPacket);
|
|
AddFunc("getopcodename",&DefScriptPackage::SCGetOpcodeName);
|
|
AddFunc("getopcodeid",&DefScriptPackage::SCGetOpcodeID);
|
|
AddFunc("bbgetpackedguid",&DefScriptPackage::SCBBGetPackedGuid);
|
|
AddFunc("bbputpackedguid",&DefScriptPackage::SCBBPutPackedGuid);
|
|
AddFunc("gui",&DefScriptPackage::SCGui);
|
|
AddFunc("sendwho",&DefScriptPackage::SCSendWho);
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCshdn(CmdSet& Set)
|
|
{
|
|
((PseuInstance*)parentMethod)->Stop();
|
|
return true;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCpause(CmdSet& Set){
|
|
((PseuInstance*)parentMethod)->Sleep(atoi(Set.defaultarg.c_str()));
|
|
return true;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCSendChatMessage(CmdSet& Set){
|
|
if(!(((PseuInstance*)parentMethod)->GetWSession()))
|
|
{
|
|
logerror("Invalid Script call: SCSendChatMessage: WorldSession not valid");
|
|
DEF_RETURN_ERROR;
|
|
}
|
|
std::stringstream ss;
|
|
uint32 type=atoi(Set.arg[0].c_str());
|
|
uint32 lang=atoi(Set.arg[1].c_str());
|
|
|
|
ss << lang;
|
|
if(ss.str()!=Set.arg[1]) // given lang is NOT a number
|
|
{
|
|
uint32 dblang;
|
|
dblang = ((PseuInstance*)parentMethod)->dbmgr.GetDB("language").GetFieldByValue("name",Set.arg[1]);
|
|
logdev("looking up language id for lang '%s', found %i",Set.arg[1].c_str(),dblang);
|
|
if(dblang != -1)
|
|
lang = dblang;
|
|
}
|
|
|
|
std::string msg=Set.arg[2];
|
|
std::string to=Set.arg[3];
|
|
((PseuInstance*)parentMethod)->GetWSession()->SendChatMessage(type,lang,msg,to);
|
|
return true;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCsavecache(CmdSet& Set){
|
|
((PseuInstance*)parentMethod)->SaveAllCache();
|
|
if(DefScriptTools::isTrue(Set.defaultarg))
|
|
{
|
|
std::stringstream str;
|
|
if(((PseuInstance*)parentMethod)->GetWSession())
|
|
{
|
|
str << "Cache saved. [ ";
|
|
str << ((PseuInstance*)parentMethod)->GetWSession()->plrNameCache.GetSize();
|
|
str << " Playernames, ";
|
|
str << ((PseuInstance*)parentMethod)->GetWSession()->objmgr.GetItemProtoCount();
|
|
str << " Item Prototypes, ";
|
|
str << ((PseuInstance*)parentMethod)->GetWSession()->objmgr.GetCreatureTemplateCount();
|
|
str << " Creature Templates";
|
|
str << " ]";
|
|
|
|
((PseuInstance*)parentMethod)->GetWSession()->SendChatMessage(CHAT_MSG_SAY,0,str.str(),"");
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCemote(CmdSet& Set){
|
|
if(Set.defaultarg.empty())
|
|
return false;
|
|
if(!(((PseuInstance*)parentMethod)->GetWSession()))
|
|
{
|
|
logerror("Invalid Script call: SCEmote: WorldSession not valid");
|
|
DEF_RETURN_ERROR;
|
|
}
|
|
|
|
// check if the given name exists in the database, if it does, use its record id; if not, convert emote name into a number.
|
|
// this supports calls like "emote 126" and "emote ready"
|
|
uint32 id = uint32(-1);
|
|
SCPDatabaseMgr& dbmgr = ((PseuInstance*)parentMethod)->dbmgr;
|
|
if(dbmgr.HasDB("emote"))
|
|
{
|
|
SCPDatabase& db = dbmgr.GetDB("emote");
|
|
id = db.GetFieldByValue("name",DefScriptTools::stringToUpper(Set.defaultarg)); // emote names are always uppercased
|
|
}
|
|
if(id == uint32(-1))
|
|
{
|
|
id=atoi(Set.defaultarg.c_str());
|
|
if(!id)
|
|
{
|
|
logerror("SCEmote: Invalid emote!");
|
|
return true;
|
|
}
|
|
}
|
|
((PseuInstance*)parentMethod)->GetWSession()->SendEmote(id);
|
|
return true;
|
|
}
|
|
|
|
|
|
DefReturnResult DefScriptPackage::SCfollow(CmdSet& Set)
|
|
{
|
|
DEF_RETURN_ERROR; // prevent execution for now
|
|
/*
|
|
WorldSession *ws=((PseuInstance*)parentMethod)->GetWSession();
|
|
if(Set.defaultarg.empty()){
|
|
ws->SendChatMessage(CHAT_MSG_SAY,0,"Stopping! (Please give me a Playername to follow!)","");
|
|
ws->SetFollowTarget(0);
|
|
return true;
|
|
}
|
|
ws->SetFollowTarget(ws->plrNameCache.GetGuid(Set.defaultarg));
|
|
std::stringstream ss;
|
|
if(ws->GetFollowTarget())
|
|
ss << "Following player '"<<Set.defaultarg<<"'";
|
|
else
|
|
ss << "Can't follow player '"<<Set.defaultarg<<"' (not known)";
|
|
ws->SendChatMessage(CHAT_MSG_SAY,0,ss.str(),"");
|
|
*/
|
|
return true;
|
|
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCjoinchannel(CmdSet& Set){
|
|
if(Set.defaultarg.empty())
|
|
return false;
|
|
if(!(((PseuInstance*)parentMethod)->GetWSession()))
|
|
{
|
|
logerror("Invalid Script call: SCjoinchannel: WorldSession not valid");
|
|
DEF_RETURN_ERROR;
|
|
}
|
|
((PseuInstance*)parentMethod)->GetWSession()->GetChannels()->Join(Set.defaultarg,Set.arg[0]);
|
|
return true;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SClistchannel(CmdSet& Set){
|
|
if(Set.defaultarg.empty())
|
|
return false;
|
|
if(!(((PseuInstance*)parentMethod)->GetWSession()))
|
|
{
|
|
logerror("Invalid Script call: SClistchannel: WorldSession not valid");
|
|
DEF_RETURN_ERROR;
|
|
}
|
|
((PseuInstance*)parentMethod)->GetWSession()->GetChannels()->RequestList(Set.defaultarg);
|
|
return true;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCleavechannel(CmdSet& Set){
|
|
if(Set.defaultarg.empty())
|
|
return false;
|
|
if(!(((PseuInstance*)parentMethod)->GetWSession()))
|
|
{
|
|
logerror("Invalid Script call: SCleavechannel: WorldSession not valid");
|
|
DEF_RETURN_ERROR;
|
|
}
|
|
((PseuInstance*)parentMethod)->GetWSession()->GetChannels()->Leave(Set.defaultarg);
|
|
return true;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCloadconf(CmdSet& Set){
|
|
if(Set.defaultarg.empty())
|
|
return false;
|
|
std::string fn;
|
|
if(Set.defaultarg.find('/')==std::string::npos && Set.defaultarg.find('\\')==std::string::npos)
|
|
fn += ((PseuInstance*)parentMethod)->GetConfDir();
|
|
fn += Set.defaultarg;
|
|
|
|
if(variables.ReadVarsFromFile(fn))
|
|
{
|
|
logdev("Loaded conf file [%s]",fn.c_str());
|
|
return true;
|
|
}
|
|
|
|
log("Error loading conf file [%s]",fn.c_str());
|
|
return false;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCapplypermissions(CmdSet& Set){
|
|
this->My_LoadUserPermissions(variables);
|
|
return true;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCapplyconf(CmdSet& Set){
|
|
((PseuInstance*)parentMethod)->GetConf()->ApplyFromVarSet(variables);
|
|
return true;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SClog(CmdSet& Set){
|
|
log(Set.defaultarg.c_str());
|
|
return true;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SClogdetail(CmdSet& Set){
|
|
logdetail(Set.defaultarg.c_str());
|
|
return true;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SClogdebug(CmdSet& Set){
|
|
logdebug(Set.defaultarg.c_str());
|
|
return true;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SClogerror(CmdSet& Set){
|
|
logerror(Set.defaultarg.c_str());
|
|
return true;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCcastspell(CmdSet& Set)
|
|
{
|
|
if(Set.defaultarg.empty())
|
|
return false;
|
|
if(!(((PseuInstance*)parentMethod)->GetWSession()))
|
|
{
|
|
logerror("Invalid Script call: SCcastspell: WorldSession not valid");
|
|
DEF_RETURN_ERROR;
|
|
}
|
|
|
|
uint32 spellId = atoi(Set.defaultarg.c_str());
|
|
|
|
if (spellId <= 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
((PseuInstance*)parentMethod)->GetWSession()->SendCastSpell(spellId);
|
|
return true;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCqueryitem(CmdSet& Set){
|
|
uint32 id = atoi(Set.defaultarg.c_str());
|
|
if(!id)
|
|
return false;
|
|
|
|
if(!(((PseuInstance*)parentMethod)->GetWSession()))
|
|
{
|
|
logerror("Invalid Script call: SCqueryitem: WorldSession not valid");
|
|
DEF_RETURN_ERROR;
|
|
}
|
|
((PseuInstance*)parentMethod)->GetWSession()->SendQueryItem(id,0);
|
|
return true;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCtarget(CmdSet& Set)
|
|
{
|
|
// TODO: special targets: _self _pet _nearest ...
|
|
DefReturnResult r;
|
|
|
|
if(!(((PseuInstance*)parentMethod)->GetWSession()))
|
|
{
|
|
logerror("Invalid Script call: SCtarget: WorldSession not valid");
|
|
DEF_RETURN_ERROR;
|
|
}
|
|
|
|
if(Set.defaultarg.empty())
|
|
{
|
|
((PseuInstance*)parentMethod)->GetWSession()->SendSetSelection(0); // no target
|
|
return true;
|
|
}
|
|
|
|
// TODO: search through all objects. for now only allow to target player
|
|
uint64 guid = (((PseuInstance*)parentMethod)->GetWSession()->plrNameCache.GetGuid(Set.defaultarg));
|
|
|
|
if( guid && ((PseuInstance*)parentMethod)->GetWSession()->objmgr.GetObj(guid) ) // object must be near
|
|
{
|
|
((PseuInstance*)parentMethod)->GetWSession()->SendSetSelection(guid); // will also set the target for myCharacter
|
|
r.ret=toString(guid);
|
|
}
|
|
else
|
|
{
|
|
logdetail("Target '%s' not found!",Set.defaultarg.c_str());
|
|
return false;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCloadscp(CmdSet& Set)
|
|
{
|
|
SCPDatabaseMgr& dbmgr = ((PseuInstance*)parentMethod)->dbmgr;
|
|
if(Set.defaultarg.empty()) // exit if no filename was given
|
|
return false;
|
|
std::string dbname = stringToLower(Set.arg[0]);
|
|
uint32 sections = 0;
|
|
if(dbname.empty()) // if no db name was supplied, try to find it automatically in the file ("#dbname=...")
|
|
{
|
|
sections = dbmgr.AutoLoadFile((char*)Set.defaultarg.c_str());
|
|
if(!sections)
|
|
{
|
|
logerror("Tried to auto-load SCP file: \"%s\", but no name tag found. skipped.");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sections = dbmgr.GetDB(dbname).LoadFromFile((char*)Set.defaultarg.c_str());
|
|
if(sections)
|
|
{
|
|
logdetail("Loaded SCP: \"%s\" [%s] (%u sections)",dbname.c_str(),Set.defaultarg.c_str(),sections);
|
|
}
|
|
else
|
|
{
|
|
logerror("Failed to load SCP: \"%s\" [%s]",dbname.c_str(),Set.defaultarg.c_str());
|
|
}
|
|
}
|
|
return toString((uint64)sections);;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCScpExists(CmdSet& Set)
|
|
{
|
|
return (!Set.defaultarg.empty()) && ((PseuInstance*)parentMethod)->dbmgr.HasDB(Set.defaultarg);
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCScpSectionExists(CmdSet& Set)
|
|
{
|
|
static std::string dbname;
|
|
if(!Set.arg[0].empty())
|
|
dbname=Set.arg[0];
|
|
return (!Set.defaultarg.empty()) && (!dbname.empty())
|
|
&& ((PseuInstance*)parentMethod)->dbmgr.HasDB(dbname)
|
|
&& ((PseuInstance*)parentMethod)->dbmgr.GetDB(dbname).HasField((uint32)DefScriptTools::toNumber(Set.defaultarg));
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCScpEntryExists(CmdSet& Set)
|
|
{
|
|
static std::string dbname;
|
|
static uint32 keyid;
|
|
if(!Set.arg[0].empty())
|
|
dbname=Set.arg[0];
|
|
if(!Set.arg[1].empty())
|
|
keyid=(uint32)DefScriptTools::toNumber(Set.arg[1]);
|
|
return (!Set.defaultarg.empty()) && (!dbname.empty())
|
|
&& ((PseuInstance*)parentMethod)->dbmgr.HasDB(dbname)
|
|
&& ((PseuInstance*)parentMethod)->dbmgr.GetDB(dbname).HasField(keyid)
|
|
&& ((PseuInstance*)parentMethod)->dbmgr.GetDB(dbname).GetField(keyid).HasEntry(Set.defaultarg);
|
|
}
|
|
|
|
|
|
// GetScpValue,db,key entry
|
|
// db & key will be stored, that multiple calls like GetScpValue entryxyz are possible
|
|
DefReturnResult DefScriptPackage::SCGetScpValue(CmdSet& Set)
|
|
{
|
|
static std::string dbname;
|
|
static uint32 keyid;
|
|
std::string entry;
|
|
DefReturnResult r;
|
|
|
|
if(!Set.arg[0].empty())
|
|
dbname=Set.arg[0];
|
|
if(!Set.arg[1].empty())
|
|
keyid=(uint32)DefScriptTools::toNumber(Set.arg[1]);
|
|
if(!Set.defaultarg.empty())
|
|
entry=Set.defaultarg;
|
|
if( (!entry.empty()) && (!dbname.empty())
|
|
&& ((PseuInstance*)parentMethod)->dbmgr.HasDB(dbname)
|
|
&& ((PseuInstance*)parentMethod)->dbmgr.GetDB(dbname).HasField(keyid)
|
|
&& ((PseuInstance*)parentMethod)->dbmgr.GetDB(dbname).GetField(keyid).HasEntry(entry))
|
|
{
|
|
r.ret = ((PseuInstance*)parentMethod)->dbmgr.GetDB(dbname).GetField(keyid).GetString(entry);
|
|
}
|
|
else
|
|
{
|
|
r.ret = "";
|
|
}
|
|
return r;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCGetPlayerGuid(CmdSet& Set)
|
|
{
|
|
if(!(((PseuInstance*)parentMethod)->GetWSession()))
|
|
{
|
|
logerror("Invalid Script call: SCGetPlayerGuid: WorldSession not valid");
|
|
DEF_RETURN_ERROR;
|
|
}
|
|
DefReturnResult r;
|
|
if(Set.defaultarg.empty())
|
|
{
|
|
r.ret="0";
|
|
}
|
|
else
|
|
{
|
|
uint64 guid=((PseuInstance*)parentMethod)->GetWSession()->plrNameCache.GetGuid(Set.defaultarg);
|
|
r.ret=toString(guid);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCGetName(CmdSet& Set)
|
|
{
|
|
WorldSession *ws = ((PseuInstance*)parentMethod)->GetWSession();
|
|
if(!ws)
|
|
{
|
|
logerror("Invalid Script call: SCGetName: WorldSession not valid");
|
|
DEF_RETURN_ERROR;
|
|
}
|
|
uint64 id = DefScriptTools::toUint64(Set.defaultarg);
|
|
std::string source = DefScriptTools::stringToLower(Set.arg[0]);
|
|
|
|
// "guid" type can be everything - item, player, unit, gameobject... whatever has this guid.
|
|
if(source.empty() || source == "guid")
|
|
{
|
|
Object *o = ws->objmgr.GetObj(id);
|
|
if(o)
|
|
return o->GetName();
|
|
else
|
|
{
|
|
// fallback if that guid is player guid, its maybe stored, so check that
|
|
if(IS_PLAYER_GUID(id))
|
|
{
|
|
if(ws->plrNameCache.IsKnown(id))
|
|
return ws->plrNameCache.GetName(id);
|
|
}
|
|
}
|
|
}
|
|
else if(source == "player")
|
|
{
|
|
if(ws->plrNameCache.IsKnown(id))
|
|
return ws->plrNameCache.GetName(id);
|
|
else
|
|
return "";
|
|
|
|
}
|
|
else if(source == "item")
|
|
{
|
|
ItemProto *iproto = ws->objmgr.GetItemProto((uint32)id);
|
|
return iproto ? iproto->Name : "";
|
|
}
|
|
else if(source == "unit")
|
|
{
|
|
CreatureTemplate *ct = ws->objmgr.GetCreatureTemplate((uint32)id);
|
|
return ct ? ct->name : "";
|
|
}
|
|
// TODO: add gameobject, dynamicobject
|
|
|
|
return "";
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCGetEntry(CmdSet& Set)
|
|
{
|
|
if(!(((PseuInstance*)parentMethod)->GetWSession()))
|
|
{
|
|
logerror("Invalid Script call: SCGetEntry: WorldSession not valid");
|
|
DEF_RETURN_ERROR;
|
|
}
|
|
DefReturnResult r;
|
|
uint64 guid=DefScriptTools::toNumber(Set.defaultarg);
|
|
r.ret="0";
|
|
Object *o=((PseuInstance*)parentMethod)->GetWSession()->objmgr.GetObj(guid);
|
|
if(o)
|
|
{
|
|
r.ret=DefScriptTools::toString((uint64)o->GetEntry());
|
|
}
|
|
else
|
|
{
|
|
logerror("SCGetEntry: Object "I64FMT" not known",guid);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCGetObjectType(CmdSet& Set)
|
|
{
|
|
if(!(((PseuInstance*)parentMethod)->GetWSession()))
|
|
{
|
|
logerror("Invalid Script call: SCGetObjectType: WorldSession not valid");
|
|
DEF_RETURN_ERROR;
|
|
}
|
|
DefReturnResult r;
|
|
uint64 guid=DefScriptTools::toNumber(Set.defaultarg);
|
|
r.ret="0";
|
|
Object *o=((PseuInstance*)parentMethod)->GetWSession()->objmgr.GetObj(guid);
|
|
if(o)
|
|
{
|
|
r.ret=DefScriptTools::toString((uint64)o->GetTypeId());
|
|
}
|
|
else
|
|
{
|
|
logerror("SCGetObjectType: Object "I64FMT" not known",guid);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCObjectKnown(CmdSet& Set)
|
|
{
|
|
if(!(((PseuInstance*)parentMethod)->GetWSession()))
|
|
{
|
|
logerror("Invalid Script call: SCObjectIsKnown: WorldSession not valid");
|
|
DEF_RETURN_ERROR;
|
|
}
|
|
uint64 guid=DefScriptTools::toNumber(Set.defaultarg);
|
|
Object *o=((PseuInstance*)parentMethod)->GetWSession()->objmgr.GetObj(guid);
|
|
return o!=NULL;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCGetPlayerPerm(CmdSet& Set)
|
|
{
|
|
DefReturnResult r;
|
|
uint8 perm=0;
|
|
for (std::map<std::string,unsigned char>::iterator i = my_usrPermissionMap.begin(); i != my_usrPermissionMap.end(); i++)
|
|
if(i->first == Set.defaultarg)
|
|
perm = i->second;
|
|
r.ret = toString(perm);
|
|
return r;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCGetScriptPerm(CmdSet& Set)
|
|
{
|
|
DefReturnResult r;
|
|
uint8 perm=0;
|
|
for (std::map<std::string,unsigned char>::iterator i = scriptPermissionMap.begin(); i != scriptPermissionMap.end(); i++)
|
|
if(i->first == Set.defaultarg)
|
|
perm = i->second;
|
|
r.ret = toString(perm);
|
|
return r;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCGetItemProtoValue(CmdSet& Set)
|
|
{
|
|
if(!(((PseuInstance*)parentMethod)->GetWSession()))
|
|
{
|
|
logerror("Invalid Script call: SCGetItemProtoValue: WorldSession not valid");
|
|
DEF_RETURN_ERROR;
|
|
}
|
|
DefReturnResult r;
|
|
uint32 entry=DefScriptTools::toNumber(Set.arg[0]);
|
|
ItemProto *proto=((PseuInstance*)parentMethod)->GetWSession()->objmgr.GetItemProto(entry);
|
|
if(proto)
|
|
{
|
|
std::string t=stringToLower(Set.defaultarg);
|
|
uint32 tmp=0;
|
|
if(t=="class") r.ret=toString(proto->Class);
|
|
else if(t=="subclass") r.ret=toString(proto->SubClass);
|
|
else if(t=="name1" || t=="name") r.ret=proto->Name[0];
|
|
else if(t=="name2") r.ret=proto->Name[1];
|
|
else if(t=="name3") r.ret=proto->Name[2];
|
|
else if(t=="name4") r.ret=proto->Name[3];
|
|
else if(t=="model" || t=="displayid") r.ret=toString(proto->DisplayInfoID);
|
|
else if(t=="quality") r.ret=toString(proto->Quality);
|
|
else if(t=="flags") r.ret=toString(proto->Flags);
|
|
else if(t=="buycount") r.ret=toString(proto->BuyCount);
|
|
else if(t=="buyprice") r.ret=toString(proto->BuyPrice);
|
|
else if(t=="sellprice") r.ret=toString(proto->SellPrice);
|
|
else if(t=="inventorytype") r.ret=toString(proto->InventoryType);
|
|
else if(t=="allowableclass") r.ret=toString(proto->AllowableClass);
|
|
else if(t=="allowablerace") r.ret=toString(proto->AllowableRace);
|
|
else if(t=="itemlevel") r.ret=toString(proto->ItemLevel);
|
|
else if(t=="reqlevel") r.ret=toString(proto->RequiredLevel);
|
|
else if(t=="reqskill") r.ret=toString(proto->RequiredSkill);
|
|
else if(t=="reqskillrank") r.ret=toString(proto->RequiredSkillRank);
|
|
else if(t=="reqspell") r.ret=toString(proto->RequiredSpell);
|
|
else if(t=="reqhonorrank") r.ret=toString(proto->RequiredHonorRank);
|
|
else if(t=="reqcityrank") r.ret=toString(proto->RequiredCityRank);
|
|
else if(t=="reqrepfaction") r.ret=toString(proto->RequiredReputationFaction);
|
|
else if(t=="reqreprank") r.ret=toString(proto->RequiredReputationRank);
|
|
else if(t=="maxcount") r.ret=toString(proto->MaxCount);
|
|
else if(t=="stackable") r.ret=toString(proto->Stackable);
|
|
else if(t=="slots") r.ret=toString(proto->ContainerSlots);
|
|
else if(t=="str")
|
|
{
|
|
for(uint32 i=0;i<10;i++)
|
|
if(proto->ItemStat[i].ItemStatType==ITEM_STAT_STRENGTH)
|
|
tmp+=proto->ItemStat[i].ItemStatValue;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="agi")
|
|
{
|
|
for(uint32 i=0;i<10;i++)
|
|
if(proto->ItemStat[i].ItemStatType==ITEM_STAT_AGILITY)
|
|
tmp+=proto->ItemStat[i].ItemStatValue;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="sta")
|
|
{
|
|
for(uint32 i=0;i<10;i++)
|
|
if(proto->ItemStat[i].ItemStatType==ITEM_STAT_STAMINA)
|
|
tmp+=proto->ItemStat[i].ItemStatValue;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="int")
|
|
{
|
|
for(uint32 i=0;i<10;i++)
|
|
if(proto->ItemStat[i].ItemStatType==ITEM_STAT_INTELLECT)
|
|
tmp+=proto->ItemStat[i].ItemStatValue;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="spi")
|
|
{
|
|
for(uint32 i=0;i<10;i++)
|
|
if(proto->ItemStat[i].ItemStatType==ITEM_STAT_SPIRIT)
|
|
tmp+=proto->ItemStat[i].ItemStatValue;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="hp" || t=="health")
|
|
{
|
|
for(uint32 i=0;i<10;i++)
|
|
if(proto->ItemStat[i].ItemStatType==ITEM_STAT_HEALTH)
|
|
tmp+=proto->ItemStat[i].ItemStatValue;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="mindmg")
|
|
{
|
|
for(uint32 i=0;i<5;i++)
|
|
if(proto->Damage[i].DamageType==NORMAL_DAMAGE)
|
|
tmp+=proto->Damage[i].DamageMin;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="maxdmg")
|
|
{
|
|
for(uint32 i=0;i<5;i++)
|
|
if(proto->Damage[i].DamageType==NORMAL_DAMAGE)
|
|
tmp+=proto->Damage[i].DamageMax;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="mindmg_holy")
|
|
{
|
|
for(uint32 i=0;i<5;i++)
|
|
if(proto->Damage[i].DamageType==HOLY_DAMAGE)
|
|
tmp+=proto->Damage[i].DamageMin;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="maxdmg_holy")
|
|
{
|
|
for(uint32 i=0;i<5;i++)
|
|
if(proto->Damage[i].DamageType==HOLY_DAMAGE)
|
|
tmp+=proto->Damage[i].DamageMax;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="mindmg_fire")
|
|
{
|
|
for(uint32 i=0;i<5;i++)
|
|
if(proto->Damage[i].DamageType==FIRE_DAMAGE)
|
|
tmp+=proto->Damage[i].DamageMin;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="maxdmg_fire")
|
|
{
|
|
for(uint32 i=0;i<5;i++)
|
|
if(proto->Damage[i].DamageType==FIRE_DAMAGE)
|
|
tmp+=proto->Damage[i].DamageMax;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="mindmg_nature")
|
|
{
|
|
for(uint32 i=0;i<5;i++)
|
|
if(proto->Damage[i].DamageType==NATURE_DAMAGE)
|
|
tmp+=proto->Damage[i].DamageMin;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="maxdmg_nature")
|
|
{
|
|
for(uint32 i=0;i<5;i++)
|
|
if(proto->Damage[i].DamageType==NATURE_DAMAGE)
|
|
tmp+=proto->Damage[i].DamageMax;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="mindmg_frost")
|
|
{
|
|
for(uint32 i=0;i<5;i++)
|
|
if(proto->Damage[i].DamageType==FROST_DAMAGE)
|
|
tmp+=proto->Damage[i].DamageMin;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="maxdmg_frost")
|
|
{
|
|
for(uint32 i=0;i<5;i++)
|
|
if(proto->Damage[i].DamageType==FROST_DAMAGE)
|
|
tmp+=proto->Damage[i].DamageMax;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="mindmg_shadow")
|
|
{
|
|
for(uint32 i=0;i<5;i++)
|
|
if(proto->Damage[i].DamageType==SHADOW_DAMAGE)
|
|
tmp+=proto->Damage[i].DamageMin;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="maxdmg_shadow")
|
|
{
|
|
for(uint32 i=0;i<5;i++)
|
|
if(proto->Damage[i].DamageType==SHADOW_DAMAGE)
|
|
tmp+=proto->Damage[i].DamageMax;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="mindmg_arcane")
|
|
{
|
|
for(uint32 i=0;i<5;i++)
|
|
if(proto->Damage[i].DamageType==ARCANE_DAMAGE)
|
|
tmp+=proto->Damage[i].DamageMin;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="maxdmg_arcane")
|
|
{
|
|
for(uint32 i=0;i<5;i++)
|
|
if(proto->Damage[i].DamageType==ARCANE_DAMAGE)
|
|
tmp+=proto->Damage[i].DamageMax;
|
|
r.ret = toString((uint64)tmp);
|
|
}
|
|
else if(t=="armor") r.ret=toString(proto->Armor);
|
|
else if(t=="holyres") r.ret=toString(proto->HolyRes);
|
|
else if(t=="fireres") r.ret=toString(proto->FireRes);
|
|
else if(t=="natureres") r.ret=toString(proto->NatureRes);
|
|
else if(t=="frostres") r.ret=toString(proto->FrostRes);
|
|
else if(t=="shadowres") r.ret=toString(proto->ShadowRes);
|
|
else if(t=="arcaneres") r.ret=toString(proto->ArcaneRes);
|
|
else if(t=="delay") r.ret=toString(proto->Delay);
|
|
else if(t=="ammotype") r.ret=toString(proto->Ammo_type);
|
|
else if(t=="range") r.ret=toString(proto->RangedModRange);
|
|
else if(t=="bonding") r.ret=toString(proto->Bonding);
|
|
else if(t=="desc") r.ret=proto->Description;
|
|
else if(t=="pagetext") r.ret=toString(proto->PageText);
|
|
else if(t=="languageid") r.ret=toString(proto->LanguageID);
|
|
else if(t=="pagematerial") r.ret=toString(proto->PageMaterial);
|
|
else if(t=="startquest") r.ret=toString(proto->StartQuest);
|
|
else if(t=="lockid") r.ret=toString(proto->LockID);
|
|
else if(t=="material") r.ret=toString(proto->Material);
|
|
else if(t=="sheath") r.ret=toString(proto->Sheath);
|
|
else if(t=="extra") r.ret=toString(proto->Extra);
|
|
else if(t=="block") r.ret=toString(proto->Block);
|
|
else if(t=="itemset") r.ret=toString(proto->ItemSet);
|
|
else if(t=="maxdur") r.ret=toString(proto->MaxDurability);
|
|
else if(t=="area") r.ret=toString(proto->Area);
|
|
else if(t=="bagfamily") r.ret=toString(proto->BagFamily);
|
|
// TODO: add item spells
|
|
else
|
|
{
|
|
logerror("SCGetItemProtoValue: Unknown property \"%s\" for Item Prototype %u",t.c_str(),entry);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
logerror("SCGetItemProtoValue: Item Prototype %u not known",entry);
|
|
}
|
|
return r;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCGetFileList(CmdSet& Set)
|
|
{
|
|
DefList *l = lists.Get(_NormalizeVarName(Set.arg[0],Set.myname));
|
|
l->clear();
|
|
*l = (DefList)GetFileList(Set.defaultarg);
|
|
if(Set.arg[1].length())
|
|
{
|
|
std::string ext = ".";
|
|
ext += Set.arg[1];
|
|
ext = stringToLower(ext);
|
|
for(DefList::iterator i = l->begin(); i != l->end(); )
|
|
{
|
|
std::string tmp = stringToLower(i->c_str() + (i->length() - ext.length()));
|
|
if( tmp != ext )
|
|
{
|
|
i = l->erase(i);
|
|
continue;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
return toString((uint64)l->size());
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCPrintScript(CmdSet &Set)
|
|
{
|
|
DefScript *sc = GetScript(DefScriptTools::stringToLower(Set.defaultarg));
|
|
if(sc)
|
|
{
|
|
logcustom(0,GREEN,"== DefScript \"%s\", %u lines: ==",sc->GetName().c_str(),sc->GetLines());
|
|
for(uint32 i = 0; i < sc->GetLines(); i++)
|
|
{
|
|
logcustom(0,GREEN,sc->GetLine(i).c_str());
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCGetObjectValue(CmdSet &Set)
|
|
{
|
|
WorldSession *ws = ((PseuInstance*)parentMethod)->GetWSession();
|
|
if(!ws)
|
|
{
|
|
logerror("Invalid Script call: SCGetObjectValue: WorldSession not valid");
|
|
DEF_RETURN_ERROR;
|
|
}
|
|
|
|
uint64 guid = DefScriptTools::toNumber(Set.defaultarg);
|
|
Object *o = ws->objmgr.GetObj(guid);
|
|
if(o)
|
|
{
|
|
uint32 v = (uint32)DefScriptTools::toNumber(Set.arg[0]);
|
|
if(v > o->GetValuesCount())
|
|
{
|
|
logerror("SCGetObjectValue ["I64FMTD", type %u]: invalid value index: %u",guid,o->GetTypeId(),v);
|
|
return "";
|
|
}
|
|
else
|
|
{
|
|
if(DefScriptTools::stringToLower(Set.arg[1]) == "f")
|
|
return toString((ldbl)o->GetFloatValue(v));
|
|
else if(DefScriptTools::stringToLower(Set.arg[1]) == "i64")
|
|
return toString(o->GetUInt64Value(v));
|
|
else
|
|
return toString((uint64)o->GetUInt32Value(v));
|
|
}
|
|
}
|
|
return "";
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCGetRace(CmdSet &Set)
|
|
{
|
|
WorldSession *ws = ((PseuInstance*)parentMethod)->GetWSession();
|
|
if(!ws)
|
|
{
|
|
logerror("Invalid Script call: SCGetObjectValue: WorldSession not valid");
|
|
DEF_RETURN_ERROR;
|
|
}
|
|
|
|
uint64 guid = DefScriptTools::toNumber(Set.defaultarg);
|
|
Object *o = ws->objmgr.GetObj(guid);
|
|
if(o && (o->GetTypeId() == TYPEID_UNIT || o->GetTypeId() == TYPEID_PLAYER))
|
|
{
|
|
return DefScriptTools::toString((uint64)((Unit*)o)->GetRace());
|
|
}
|
|
return "";
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCGetClass(CmdSet &Set)
|
|
{
|
|
WorldSession *ws = ((PseuInstance*)parentMethod)->GetWSession();
|
|
if(!ws)
|
|
{
|
|
logerror("Invalid Script call: SCGetObjectValue: WorldSession not valid");
|
|
DEF_RETURN_ERROR;
|
|
}
|
|
|
|
uint64 guid = DefScriptTools::toNumber(Set.defaultarg);
|
|
Object *o = ws->objmgr.GetObj(guid);
|
|
if(o && (o->GetTypeId() == TYPEID_UNIT || o->GetTypeId() == TYPEID_PLAYER))
|
|
{
|
|
return DefScriptTools::toString((uint64)((Unit*)o)->GetClass());
|
|
}
|
|
return "";
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCSendWorldPacket(CmdSet &Set)
|
|
{
|
|
WorldSession *ws = ((PseuInstance*)parentMethod)->GetWSession();
|
|
if(!ws)
|
|
{
|
|
logerror("Invalid Script call: SCSendWorldPacket: WorldSession not valid");
|
|
DEF_RETURN_ERROR;
|
|
}
|
|
ByteBuffer *bb = bytebuffers.GetNoCreate(_NormalizeVarName(Set.defaultarg,Set.myname));
|
|
if(bb)
|
|
{
|
|
uint32 opcode = (uint32)DefScriptTools::toNumber(Set.arg[0]);
|
|
if(opcode) // prevent sending CMSG_NULL_ACTION
|
|
{
|
|
WorldPacket wp(opcode, bb->size());
|
|
if(bb->size())
|
|
wp.append(bb->contents(), bb->size());
|
|
ws->SendWorldPacket(wp);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCGetOpcodeID(CmdSet &Set)
|
|
{
|
|
uint32 id = GetOpcodeID(Set.defaultarg.c_str());
|
|
return id != (uint32)(-1) ? toString(id) : "";
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCGetOpcodeName(CmdSet &Set)
|
|
{
|
|
return GetOpcodeName((uint32)DefScriptTools::toUint64(Set.defaultarg));
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCBBGetPackedGuid(CmdSet &Set)
|
|
{
|
|
ByteBuffer *bb = bytebuffers.GetNoCreate(_NormalizeVarName(Set.defaultarg,Set.myname));
|
|
if (!bb)
|
|
return false;
|
|
|
|
if (bb->size() - bb->rpos() < sizeof(uint8))
|
|
return false;
|
|
|
|
uint8 mask;
|
|
*bb >> mask;
|
|
uint64 guid=0;
|
|
for(uint8 i=0;i<8;i++)
|
|
{
|
|
if(mask & (1<<i) )
|
|
{
|
|
if (bb->size() - bb->rpos() < sizeof(uint8))
|
|
return false;
|
|
|
|
*bb >> ((uint8*)&guid)[i];
|
|
}
|
|
}
|
|
|
|
return toString(guid);
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCBBPutPackedGuid(CmdSet &Set)
|
|
{
|
|
ByteBuffer *bb = bytebuffers.Get(_NormalizeVarName(Set.arg[0],Set.myname));
|
|
|
|
uint64 guid = DefScriptTools::toUint64(Set.defaultarg);
|
|
if (!guid) // fast check if guid is empty (in this case mask must be 0 with no extra data)
|
|
{
|
|
*bb << uint8(0);
|
|
return false;
|
|
}
|
|
|
|
ByteBuffer bbmask;
|
|
uint8 mask = 0;
|
|
|
|
for(uint8 i = 0; i < 8; i++)
|
|
{
|
|
if(guid & 0xFF)
|
|
{
|
|
mask |= (1<<i);
|
|
bbmask << ((uint8)(guid & 0xFF));
|
|
}
|
|
guid >>= 8;
|
|
}
|
|
|
|
*bb << mask;
|
|
bb->append(bbmask);
|
|
|
|
return true;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCGui(CmdSet &Set)
|
|
{
|
|
PseuInstance *ins = (PseuInstance*)parentMethod;
|
|
if(ins->InitGUI())
|
|
logdebug("SCGui: gui created");
|
|
else
|
|
{
|
|
logerror("SCGui: failed");
|
|
return false;
|
|
}
|
|
while(!ins->GetGUI() && !ins->GetGUI()->IsInitialized())
|
|
Sleep(1);
|
|
|
|
// TODO: not sure if this piece of code will work as intended, needs some testing
|
|
if(ins->GetWSession() && ins->GetWSession()->InWorld())
|
|
ins->GetGUI()->SetSceneState(SCENESTATE_WORLD);
|
|
else
|
|
ins->GetGUI()->SetSceneState(SCENESTATE_GUISTART);
|
|
|
|
return true;
|
|
}
|
|
|
|
DefReturnResult DefScriptPackage::SCSendWho(CmdSet &Set)
|
|
{
|
|
WorldSession *ws = ((PseuInstance*)parentMethod)->GetWSession();
|
|
if(!ws)
|
|
{
|
|
logerror("Invalid Script call: SCSendWhoListRequest: WorldSession not valid");
|
|
DEF_RETURN_ERROR;
|
|
}
|
|
uint32 minlvl = (uint32)DefScriptTools::toUint64(Set.arg[0]);
|
|
uint32 maxlvl = (uint32)DefScriptTools::toUint64(Set.arg[1]);
|
|
uint32 racemask = (uint32)DefScriptTools::toUint64(Set.arg[2]);
|
|
uint32 classmask = (uint32)DefScriptTools::toUint64(Set.arg[3]);
|
|
std::string name = Set.arg[4];
|
|
std::string guildname = Set.arg[5];
|
|
// TODO: implement zonelist
|
|
|
|
// convert empty string (default: 0) to default expected by server (-1 = 0xFFFFFFFF = all)
|
|
// and do some values cleanup
|
|
if(!racemask)
|
|
racemask = -1;
|
|
if(!classmask)
|
|
classmask = -1;
|
|
if(!maxlvl)
|
|
maxlvl = 100;
|
|
else if(maxlvl > 255)
|
|
maxlvl = 255;
|
|
if(minlvl > 255)
|
|
minlvl = 255;
|
|
if(minlvl > maxlvl)
|
|
minlvl = maxlvl;
|
|
|
|
ws->SendWhoListRequest(minlvl,maxlvl,racemask,classmask,name,guildname);
|
|
return "";
|
|
}
|
|
|
|
|
|
void DefScriptPackage::My_LoadUserPermissions(VarSet &vs)
|
|
{
|
|
static char *prefix = "USERS::";
|
|
std::string sub,usr;
|
|
for(uint32 i=0;i<variables.Size();i++)
|
|
{
|
|
sub = variables[i].name.substr(0,strlen(prefix));
|
|
if(sub == prefix)
|
|
{
|
|
usr = variables[i].name.substr(strlen(prefix), variables[i].name.length() - strlen(prefix));
|
|
my_usrPermissionMap[usr] = atoi(variables[i].value.c_str());
|
|
DEBUG( logdebug("Player '%s' permission = %u",usr.c_str(),atoi(variables[i].value.c_str())); )
|
|
}
|
|
}
|
|
}
|
|
|
|
void DefScriptPackage::My_Run(std::string line, std::string username)
|
|
{
|
|
int16 scperm = -1; // builtin functions that have no explicit req. permission level assigned should be secure from beeing called from ingame
|
|
uint8 usrperm=0; // users/players that have no explicit permission assigned should have minimal permission
|
|
|
|
for (std::map<std::string,unsigned char>::iterator i = my_usrPermissionMap.begin(); i != my_usrPermissionMap.end(); i++)
|
|
{
|
|
if(i->first == username)
|
|
{
|
|
usrperm = i->second;
|
|
}
|
|
}
|
|
|
|
DefXChgResult final;
|
|
if(usrperm < 255 && line.find("?{")!=std::string::npos)
|
|
{
|
|
logerror("WARNING: %s wanted to exec \"%s\"",username.c_str(),line.c_str());
|
|
final=ReplaceVars(line,NULL,0,false); // prevent execution of embedded scripts (= using return values) that could trigger dangerous stuff.
|
|
}
|
|
else
|
|
final=ReplaceVars(line,NULL,0,true); // exec as usual
|
|
|
|
|
|
CmdSet curSet;
|
|
SplitLine(curSet,final.str);
|
|
|
|
for (std::map<std::string,unsigned char>::iterator i = scriptPermissionMap.begin(); i != scriptPermissionMap.end(); i++)
|
|
{
|
|
if(i->first == curSet.cmd)
|
|
{
|
|
scperm = i->second;
|
|
}
|
|
}
|
|
|
|
|
|
if(scperm > 0) // skip "invisible" scripts (without any permission set) completely.
|
|
{
|
|
if(usrperm < scperm)
|
|
{
|
|
CmdSet Set;
|
|
Set.arg[0] = username;
|
|
Set.arg[1] = toString(usrperm);
|
|
Set.arg[2] = toString(scperm);
|
|
Set.arg[3] = curSet.cmd;
|
|
RunScript("_nopermission",&Set);
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
Interpret(curSet);
|
|
}
|
|
|
|
|
|
|
|
|
|
|