void ListUiStats(json::Value& value, json::Value& data) {
TransformJson(value, data, FormatTag);
std::string pane = "$StatsPane/";
for (auto& cat : value["uiStats"]) {
for (auto& stat : cat["stats"]) {
if (!stat.has("tooltip") || !stat.has("name")) continue;
std::string tip = stat["tooltip"].getString();
if (tip.find(pane) == 0) {
std::string alt = stat["name"].getString();
if (alt.find(pane) == 0) {
alt = alt.substr(pane.length(), alt.length() - pane.length() - 1);
}
alt.append(" - Tip");
data["stringlist"]["StatsPane"][alt]["text"] = tip.substr(pane.length(), tip.length() - pane.length() - 1);
stat["tooltip"] = fmtstring("$StatsPane/%s$", alt.c_str());
}
std::string suffix = stat["suffix"].getString();
if (suffix.find(pane) == 0) {
std::string alt = stat["name"].getString();
if (alt.find(pane) == 0) {
alt = alt.substr(pane.length(), alt.length() - pane.length() - 1);
}
alt.append(" - Extra tip");
data["stringlist"]["StatsPane"][alt]["text"] = tip.substr(pane.length(), tip.length() - pane.length() - 1);
stat["suffix"] = fmtstring("$StatsPane/%s$", alt.c_str());
}
}
}
TransformJson(value, data, StoreTag);
}
void DumpActorLook(json::Value& value, uint32 aid) {
SnoFile<Actor> actor(Actor::name(aid));
if (!actor) return;
SnoFile<Appearance> app(actor->x014_AppearanceSno.name());
if (!app) return;
auto& val = value[fmtstring("%d", aid)]["looks"];
uint32 index = 0;
for (auto& look : app->x1C0_AppearanceLooks) {
val[fmtstring("%u", HashName(look.x00_Text))] = index++;
}
}
std::string FormulaParser::Value::format() {
if (!text.empty()) {
if (text == "%") {
std::string res = (digits ? fmtstring("%%.%df", digits) : "%d");
if (plus) res.insert(res.begin(), '+');
return res;
}
return text;
} else if (min == max) {
return fmtstring(plus ? "%+.*lf" : "%.*lf", digits, max);
} else {
return fmtstring(plus ? "%+.*lf-%.*lf" : "%.*lf-%.*lf", digits, min, digits, max);
}
}
static int dnsrequest(u_short id, const char *name, int type, char *data, int *namelen)
{
u_char buf[256];
dnshdr dh;
int dlen = sizeof(dnshdr);
int i;
memset(&dh, 0, sizeof(dnshdr));
dh.id = id;
dh.flags = 0x0001; /* QR|OC|AA|TC|RD - RA|Z|RCODE */
dh.query = htons(0x0001); /* one query */
memcpy(data, (void *)&dh, sizeof(dnshdr));
/* query name */
memset(buf, 0, sizeof(buf));
i = fmtstring(name, (char *)buf);
if (i == 0)
return 0;
*namelen = i;
memcpy(data + dlen, buf, i);
dlen += i;
/* A record */
data[dlen++] = 0x00;
data[dlen++] = type;
/* IN class */
data[dlen++] = 0x00;
data[dlen++] = 0x01;
return dlen;
}
Dictionary PowerTag::formulas() {
auto& tags = PowerTags::instance().reverse_;
Dictionary values;
for (auto& kv : formulas_) {
values.emplace(tags[kv.first], kv.second.state == sDone ? fmtstring("%d", kv.second.value) : kv.second.text);
}
return values;
}
void AddActorInfo(json::Value& values, uint32 aid, bool hair, bool fixEmitter, uint32 orig = 0) {
SnoFile<Actor> actor(Actor::name(aid));
if (!actor) return;
uint32 emitId = (fixEmitter ? FixEmitter(actor) : aid);
if (emitId != actor->x000_Header.id) {
AddActorInfo(values, emitId, hair, false, aid);
return;
}
auto& value = values[fmtstring("%d", orig ? orig : aid)];
if (hair) {
std::map<uint32, uint32> tags;
for (uint32 i = 1; i + 3 <= actor->x060_TagMap.size(); i += 3) {
tags[actor->x060_TagMap[i + 1]] = actor->x060_TagMap[i + 2];
}
value["hair"] = tags[66564];
}
SnoFile<AnimSet> animSet(actor->x068_AnimSetSno.name());
if (animSet) {
uint32 anim = 0;
for (auto& tm : animSet->x010_AnimSetTagMaps) {
if (!tm.x08_TagMap.size() || tm.x08_TagMap.size() != tm.x08_TagMap[0] * 3 + 1) continue;
for (uint32 i = 1; i + 3 <= tm.x08_TagMap.size(); i += 3) {
if (Anim::name(tm.x08_TagMap[i + 2])) {
anim = tm.x08_TagMap[i + 2];
}
}
}
if (anim) {
value["animation"] = anim;
}
}
SnoFile<Appearance> app(actor->x014_AppearanceSno.name());
if (app) {
json::Value enable(json::Value::tObject);
uint32 index = 0;
for (auto& object : app->x010_Structure.x088_GeoSets[0].x10_SubObjects) {
if (strcmp(object.x05C_Text, "FX_EMIT")) {
enable[fmtstring("%d", index)] = 0;
}
++index;
}
value["enable"] = enable;
}
}
bool ChatHandler::HandleLearnCommand(const char* args)
{
WorldPacket data;
if (!*args)
return false;
if (!strcmp(args, "all"))
{
int loop = 0;
FillSystemMessageData(&data, m_session, fmtstring("%s - Learning default GM spells/skills.", m_session->GetPlayer()->GetName()));
m_session->SendPacket(&data);
while (strcmp(gmSpellList[loop], "0"))
{
uint32 spell = atol((char*)gmSpellList[loop]);
if (m_session->GetPlayer()->HasSpell(spell))
{
loop++;
continue;
}
data.Initialize( SMSG_LEARNED_SPELL );
data << (uint32)spell;
m_session->SendPacket( &data );
m_session->GetPlayer()->addSpell((uint16)spell);
loop++;
}
return true;
}
uint32 spell = atol((char*)args);
if (m_session->GetPlayer()->HasSpell(spell))
{
FillSystemMessageData(&data, m_session, "You already know that spell.");
m_session->SendPacket(&data);
return true;
}
data.Initialize( SMSG_LEARNED_SPELL );
data << (uint32)spell;
m_session->SendPacket( &data );
m_session->GetPlayer()->addSpell((uint16)spell);
return true;
}
bool ChatHandler::HandleCreateGuildCommand(const char* args)
{
WorldPacket data;
Guild *guild;
Player * player;
std::string lname,gname;
if (!*args)
return false;
lname = strtok((char*)args, " ");
gname = strtok(NULL, " ");
if(!gname.c_str())
{
FillSystemMessageData(&data, m_session, fmtstring("You need to insert a Guild Name!"));
m_session->SendPacket(&data);
return true;
}
player = ObjectAccessor::Instance().FindPlayerByName(lname.c_str());
if(!player)
{
FillSystemMessageData(&data, m_session, fmtstring("Player not found!"));
m_session->SendPacket(&data);
return true;
}
if(!player->GetGuildId())
{
guild = new Guild;
guild->create(player->GetGUID(),gname);
objmgr.AddGuild(guild);
}
else
{
FillSystemMessageData(&data, m_session, fmtstring("Player already have a guild!"));
m_session->SendPacket(&data);
}
return true;
}
ChunkQueue::ChunkQueue(json::Value const& config)
: config_(config)
, vod_(Video::open(config))
, path_(config["path"].getString())
, ctx_(cv::Size(vod_->width(), vod_->height() / 5))
, last_index_(0)
{
double factor = vod_->width() / 1920.0;
assemble_ = cv::imread(path::root() / "heroes/assemble.png");
prepare_ = cv::imread(path::root() / "heroes/prepare.png");
cv::cvtColor(assemble_, assemble_, cv::COLOR_BGR2GRAY);
cv::cvtColor(prepare_, prepare_, cv::COLOR_BGR2GRAY);
cv::resize(assemble_, assemble_, cv::Size(), factor, factor, cv::INTER_LANCZOS4);
cv::resize(prepare_, prepare_, cv::Size(), factor, factor, cv::INTER_LANCZOS4);
json::Value hero_list;
json::parse(File(path::root() / "heroes/list.js"), hero_list, json::mJS, nullptr, true);
std::vector<Sprite> sprites;
for (auto const& kv : hero_list.getMap()) {
cv::Mat icon = cv::imread(path::root() / fmtstring("heroes/%s.png", kv.first.c_str()), -1);
if (icon.empty()) continue;
if (icon.rows > 30) {
icon = icon(cv::Rect(0, icon.rows - 30, icon.cols, 30));
}
sprites_.emplace_back(kv.first, icon, kv.second.getNumber(), ctx_);
}
size_t current = 0;
if (!json::parse(File(path_ / "status.json"), result_)) {
result_.clear();
result_["config"] = config;
json::write(File(path_ / "status.json", "wb"), result_);
} else {
if (result_.has("current")) {
current = result_["current"].getInteger();
}
}
double start_time = config["start_time"].getNumber();
double end_time = config["end_time"].getNumber();
for (size_t index = current; index < vod_->size(); ++index) {
if (vod_->duration(index + 1) <= start_time) continue;
if (vod_->duration(index) >= end_time) break;
push(index);
last_index_ = index + 1;
}
finish();
consumer_.reset(new std::thread(consume, this));
}
bool ChatHandler::HandleCreatureDistanceCommand(const char* args)
{
WorldPacket data;
if (!*args)
return false;
max_creature_distance = (float)atof((char*)args);
FillSystemMessageData(&data, m_session, fmtstring("Creature max think distance set to %f (units from nearest player).", max_creature_distance));
m_session->SendPacket(&data);
return true;
}
// wrapper around cmd_plan, fork here
static int start_plan(struct myfile *req,int do_fork)
{
int rv;
char logname[1024];
char filename[1024];
char *file,*ext;
int pid;
search src;
oclear(src);
file = strrchr(req->name,'/');
if (file) file++; else file = req->name;
ext = strrchr(req->name,'.');
if (ext) fmtstring(filename,"%.*s",(ub4)(ext - file),file);
else strcopy(filename,file);
if (do_fork) {
pid = fork();
if (pid == -1) { oserror(0,"Cannot fork from %u for %s",globs.pid,filename); return -1; }
else if (pid) { info(0,"create process %u for %s",pid,filename); return pid; }
globs.pid = getpid();
fmtstring(logname,"log/%s_%u.log",filename,globs.pid);
setmsglog(globs.netdir,logname,1);
}
gnet *net = getgnet();
rv = cmd_plan(net,req,&src);
if (rv) info(0,"plan returned %d",rv);
if (do_fork) {
eximsg(0);
exit(rv);
} else return rv;
}
json::Value MakeActor(SnoFile<Actor>& actor, std::map<uint32, uint32>& tags, json::Value& actors, bool fixEmitter, bool right = false, bool hair = false) {
static int charActors[] = {3301, 3285, 6544, 6526, 6485, 6481, 4721, 4717, 75207, 74706, 238284, 238286};
if (tags[94240]) {
json::Value res(json::Value::tObject);
for (uint32 id = (right ? 94720 : 94208), idx = 0; idx < 12; ++id, ++idx) {
if (Actor::name(tags[id])) {
res[fmtstring("%d", charActors[idx])] = tags[id];
AddActorInfo(actors, tags[id], hair, fixEmitter);
}
}
return res;
} else {
AddActorInfo(actors, actor->x000_Header.id, hair, fixEmitter);
return actor->x000_Header.id;
}
}
static bool HandleTausendwinterWechselnCmd(ChatHandler* handler, const char* /*args*/)
{
Tausendwinter * pTW = (Tausendwinter*)sOutdoorPvPMgr->GetOutdoorPvPToZoneId(NORDEND_TAUSENDWINTER);
if (!pTW)
{
handler->SendSysMessage(LANG_TAUSENDWINTER_VAR_INIT_FEHLER);
handler->SetSentErrorMessage(true);
return false;
}
else
{
pTW->ErzwingeTeamwechsel();
sWorld->SendZoneText(NORDEND_TAUSENDWINTER, fmtstring(sObjectMgr->GetTrinityStringForDBCLocale(LANG_TAUSENDWINTER_WECHSEL_DES_BESITZERS),
pTW->HoleAngreiferTeamId() == TEAM_ALLIANCE ? sObjectMgr->GetTrinityStringForDBCLocale(LANG_BG_AB_ALLY) : sObjectMgr->GetTrinityStringForDBCLocale(LANG_BG_AB_HORDE)));
return true;
}
}
static bool HandleTausendwinterZeitCmd(ChatHandler* handler, const char* args)
{
if (!args)
{
handler->SendSysMessage(LANG_TAUSENDWINTER_KEINE_ZEIT);
handler->SetSentErrorMessage(true);
return false;
}
Tausendwinter * pTW = (Tausendwinter*)sOutdoorPvPMgr->GetOutdoorPvPToZoneId(NORDEND_TAUSENDWINTER);
if (!pTW)
{
handler->SendSysMessage(LANG_TAUSENDWINTER_VAR_INIT_FEHLER);
handler->SetSentErrorMessage(true);
return false;
}
int32 Zeit = atoi(args);
if (Zeit < 1)
Zeit = 1;
if (pTW->IstKampf() && Zeit > 60)
{
handler->SendSysMessage(LANG_TAUSENDWINTER_IM_KAMPF_MAX_60);
handler->SetSentErrorMessage(true);
return false;
}
else if (Zeit > 1440)
{
handler->SendSysMessage(LANG_TAUSENDWINTER_MAX_1440);
handler->SetSentErrorMessage(true);
return false;
}
pTW->SetzeZeit(uint32(Zeit *= IN_MILLISECONDS * MINUTE));
sWorld->SendZoneText(NORDEND_TAUSENDWINTER, fmtstring(sObjectMgr->GetTrinityStringForDBCLocale(LANG_TAUSENDWINTER_ZEIT_GEAENDERT), handler->GetSession()->GetPlayerName(),
secsToTimeString(pTW->HoleZeitInSekunden(), true).c_str()));
return true;
}
json::Value PowerTag::dump() const {
auto& rawnames = PowerTags::instance().rawnames_;
json::Value dst;
for (auto& kv : formulas_) {
auto& cur = dst[rawnames[kv.first]];
if (kv.second.state == sDone) {
cur = (uint32) kv.second.value;
} else {
cur.append(kv.second.text);
std::string fmt;
for (uint32 val : kv.second.formula) {
if (!fmt.empty()) fmt.push_back(',');
fmt.append(fmtstring("%08x", val));
}
cur.append(fmt);
if (!kv.second.comment.empty()) {
cur.append(kv.second.comment);
}
}
}
return dst;
}
static bool HandleTausendwinterStopCmd(ChatHandler* handler, const char* /*args*/)
{
Tausendwinter * pTW = (Tausendwinter*)sOutdoorPvPMgr->GetOutdoorPvPToZoneId(NORDEND_TAUSENDWINTER);
if (!pTW)
{
handler->SendSysMessage(LANG_TAUSENDWINTER_VAR_INIT_FEHLER);
handler->SetSentErrorMessage(true);
return false;
}
else if (!sWorld->getBoolConfig(CONFIG_TW_AKTIVIERT))
{
handler->SendSysMessage(LANG_TAUSENDWINTER_DEAKTIVIERT);
handler->SetSentErrorMessage(true);
return false;
}
else
{
pTW->ErzwingeKampfBeenden();
sWorld->SendZoneText(NORDEND_TAUSENDWINTER, fmtstring(sObjectMgr->GetTrinityStringForDBCLocale(LANG_TAUSENDWINTER_KAMPF_WURDE_BEENDET), handler->GetSession()->GetPlayerName()));
return true;
}
}
void GenerateItems(json::Value& value, json::Value& data) {
auto names = Strings::list("Items");
auto powers = Strings::list("ItemPassivePowerDescriptions");
uint32 powId = fixAttrId(1270, true);
std::map<std::string, std::string> powerFix;
powerFix.emplace("Unique_Amulet_109_x1_210", "ItemPassive_x1_Amulet_norm_unique_25_DemonHunter");
std::map<uint32, GameBalance::Type::AffixTableEntry*> affixes;
SnoFile<GameBalance> affixFile("1xx_AffixList");
for (auto& afx : affixFile->x078_AffixTable) {
affixes.emplace(HashNameLower(afx.x000_Text), &afx);
}
for (auto& rcp : SnoLoader::All<Recipe>()) {
std::string item = rcp->x0C_ItemSpecifierData.x00_ItemsGameBalanceId.name();
if (item.empty()) continue;
uint32 power = 0;
for (auto& id : rcp->x0C_ItemSpecifierData.x08_GameBalanceIds) {
if (affixes.count(id)) {
for (auto& attr : affixes[id]->x260_AttributeSpecifiers) {
if (attr.x00_Type == powId) {
power = attr.x04_Param;
break;
}
}
}
if (power) break;
}
char const* pname = (power ? Power::name(power) : nullptr);
if (pname) powerFix.emplace(item, pname);
}
for (auto& kv : data["itemById"].getMap()) {
if (kv.second.has("required")) {
std::string key = kv.second["required"]["custom"]["id"].getString();
data["legendaryMap"][key] = kv.first;
}
auto* item = ItemLibrary::get(kv.first);
if (!names.has(kv.first) || !item) {
if (kv.first != "Unique_Ring_017_p4") {
Logger::log("Item not found: %s", kv.first.c_str());
continue;
}
}
auto& dst = value["itemById"][kv.first];
dst["name"] = names[kv.first == "Unique_Ring_017_p4" ? "Unique_Ring_017_p2" : kv.first];
if (kv.second.has("required")) {
std::string key = kv.second["required"]["custom"]["id"].getString();
data["stringlist"]["Items"][key]["text"] = kv.second["required"]["custom"]["name"];
data["stringlist"]["Items"][key]["tip"] = names[kv.first] + " (short effect name)";
dst["required"]["custom"]["name"] = fmtstring("$Items/%s$", key.c_str());
bool found = false;
for (auto& attr : item->x1F8_AttributeSpecifiers) {
if (attr.x00_Type != powId) continue;
char const* name = Power::name(attr.x04_Param);
auto* tag = PowerTags::getraw(attr.x04_Param);
if (!name || !tag || !powers.has(name)) {
Logger::log("Power not found for %s", kv.first.c_str());
continue;
}
auto values = GameAffixes::defaultMap();
AttributeValue value = ExecFormula(
reinterpret_cast<uint32 const*>(attr.x08_Data.begin()),
reinterpret_cast<uint32 const*>(attr.x08_Data.end()),
values);
if (value.min != value.max) {
values["value1"] = AttributeValue("%");
} else {
values["value1"] = value;
}
dst["required"]["custom"]["format"] = FormatDescription(powers[name], FormatTags, values, tag);
found = true;
break;
}
if (!found) {
if (powerFix.count(kv.first)) {
auto* tag = PowerTags::get(powerFix[kv.first]);
auto values = GameAffixes::defaultMap();
values["value1"] = AttributeValue("%");
dst["required"]["custom"]["format"] = FormatDescription(powers[powerFix[kv.first]], FormatTags, values, tag);
} else if (kv.first == "x1_Amulet_norm_unique_25") {
// hellfire
std::string x = powers["ItemPassive_Unique_Ring_770_x1"];
std::string y = Strings::get("Powers", "Trait_PoundOfFlesh");
size_t pos = x.find(y);
if (pos != std::string::npos) {
x.replace(pos, y.length(), "%p");
dst["required"]["custom"]["format"] = x;
}
} else {
Logger::log("Power not found for %s", kv.first.c_str());
}
}
if (dst["required"]["custom"].has("format")) {
data["locale_tips"]["Items"][key] = dst["required"]["custom"]["format"];
}
}
}
}
FormulaParser::Value FormulaParser::eval() {
int digits = 0;
bool plus = false;
EvalStack stack;
stack.ops.push('{');
while (int type = fnext()) {
if (type == tChar && chr == ']') break;
if (type == tChar && chr == '|') {
type = fnext();
if (type == tNum) {
digits = static_cast<int>(val);
} else if (type == tChar && chr == '+') {
plus = true;
}
fnext();
} else if (type == tName) {
std::vector<std::string> parts;
bool isfunc = false;
while (type == tName) {
parts.push_back(tag);
size_t prev = pos;
if ((type = fnext()) != tChar || chr != '.') {
if (type == tChar && chr == '(') {
isfunc = true;
} else {
pos = prev;
}
break;
}
type = fnext();
}
std::string result = "";
for (auto& part : parts) {
if (!result.empty()) result.push_back('.');
result.append(part);
}
if (isfunc) {
char funcId = getFunction(result);
OpInfo const& op = opInfo(funcId);
while (stack.ops.size() && opInfo(stack.ops.top()).rprio >= op.lprio) {
stack.exec(stack.ops.top());
stack.ops.pop();
}
stack.ops.push(funcId);
stack.needval = op.rval;
} else if (!stack.ops.empty() && stack.ops.top() == funcTable) {
stack.vals.push(AttributeValue(PowerTags::table(result)));
} else {
static re::Prog sfid("sf_(\\d+)", -1, re::Prog::CaseInsensitive);
static re::Prog sftag(R"/(powertag.(\w+)."(.*)")/", -1, re::Prog::CaseInsensitive);
//static re::Prog lookup(R"(table.(\w+).(\w+))", -1, re::Prog::CaseInsensitive);
std::vector<std::string> match;
if (context && sfid.match(result, &match)) {
stack.vals.emplace(context->get(atoi(match[1].c_str()), values));
} else if (sftag.match(result, &match)) {
stack.vals.emplace(PowerTags::get(match[1], match[2], values));
} else {
auto it = values.find(result);
stack.vals.push(it == values.end() ? 0.0 : it->second);
}
}
stack.needval = 0;
} else if (type == tTag) {
auto it = values.find(tag);
if (it != values.end()) {
prevtag = it->second;
} else if (context) {
prevtag = context->get(tag, values);
} else {
prevtag = 0.0;
}
stack.vals.push(prevtag);
stack.needval = 0;
} else if (type == tNum) {
stack.vals.push(val);
stack.needval = 0;
} else if (type == tChar) {
if (chr == '-' && stack.needval) chr = '~';
OpInfo const& op = opInfo(chr);
while (stack.ops.size() && opInfo(stack.ops.top()).rprio >= op.lprio) {
char top = stack.ops.top();
stack.exec(top);
stack.ops.pop();
if (opInfo(top).rprio == 0) break;
}
if (chr != ')') stack.ops.push(chr);
stack.needval = op.rval;
}
}
OpInfo const& op = opInfo('}');
while (stack.ops.size() && opInfo(stack.ops.top()).rprio >= op.lprio) {
stack.exec(stack.ops.top());
stack.ops.pop();
}
AttributeValue res;
if (stack.vals.size()) res = stack.vals.top();
return Value(res, digits, plus);
}
std::string FormulaParser::parse() {
std::string result;
int newlines = 0;
while (int type = next()) {
if ((flags & FormatHTML) && newlines && (type != tChar || chr != '\n')) {
if (newlines == 1) {
result.append("<br/>");
} else {
result.append("</p><p>");
}
newlines = 0;
}
switch (type) {
case tChar:
if (chr == '[') {
result.append(eval().format());
} else if (chr == '|') {
next(); // 4
std::string lhs, rhs;
while (next() == tChar && chr != ':') {
lhs.push_back(chr);
}
while (next() == tChar && chr != ';') {
rhs.push_back(chr);
}
if (prevtag.min != 1 || prevtag.max != 1) {
result.append(rhs);
} else {
result.append(lhs);
}
} else if (chr == '\n' && (flags & FormatHTML)) {
++newlines;
} else {
if (flags & FormatTags) {
if (chr == ' ' && (result.empty() || result.back() == '\n')) {
break;
}
if (chr == '%') {
result.push_back('%');
}
}
result.push_back(chr);
}
break;
case tTag:
if (tag.substr(0, 2) == "/c" || tag.substr(0, 2) == "c:" || pretags.find(tag) != pretags.end()) {
if (flags & FormatHTML) {
if (tag.substr(0, 2) == "/c") {
result.append("</span>");
} else if (tag.substr(0, 2) == "c:") {
result.append(fmtstring("<span style=\"color: #%s\">", tag.substr(4).c_str()));
} else {
result.append(pretags[tag]);
}
} else if ((flags & FormatTags) && tag == "icon:bullet") {
result.push_back('*');
}
} else {
auto it = values.find(tag);
if (it != values.end()) {
prevtag = it->second;
} else if (context) {
prevtag = context->get(tag, values);
} else {
prevtag = 0.0;
}
result.append(Value(prevtag).format());
}
break;
}
// parse parameters and invoke actual planning. Runs in separate process
// to be elaborated: temporary simple interface
static int cmd_plan(gnet *net,struct myfile *req,search *src)
{
struct myfile rep;
char *vp,*lp = req->buf;
ub4 n,pos = 0,len = (ub4)req->len;
ub4 ival;
ub4 varstart,varend,varlen,valstart,valend,type;
ub4 portcnt = net->portcnt;
ub4 sportcnt = net->sportcnt;
ub4 dep = 0,arr = 0,lostop = 0,histop = 3,tdep = 0,ttdep = 0,utcofs=2200;
ub4 plusday = 1,minday = 0;
ub4 costperstop = 1;
ub4 mintt = globs.mintt;
ub4 maxtt = globs.maxtt;
ub4 walklimit = globs.walklimit;
ub4 sumwalklimit = globs.sumwalklimit;
ub4 nethistop = hi32;
ub4 delay = 0;
ub4 testiter = 0;
int rv;
enum Vars {
Cnone,
Cdep,
Carr,
Ctdep,
Cttdep,
Cplusday,
Cminday,
Clostop,
Chistop,
Cmintt,
Cmaxtt,
Ccostperstop,
Cwalklimit,
Csumwalklimit,
Cnethistop,
Cutcofs,
Cdelay,
Ctestiter
} var;
ub4 *evpool;
if (len == 0) return 1;
oclear(rep);
while (pos < len && lp[pos] >= 'a' && lp[pos] <= 'z') {
ival = 0;
varstart = varend = pos;
while (varend < len && lp[varend] >= 'a' && lp[varend] <= 'z') varend++;
varlen = varend - varstart; pos = varend;
if (varlen == 0) break;
while (pos < len && lp[pos] == ' ') pos++;
if (pos == len) break;
type = lp[pos++];
if (type == '\n' || pos == len) break;
while (pos < len && lp[pos] == ' ') pos++;
lp[varend] = 0;
valstart = valend = pos;
while (valend < len && lp[valend] != '\n') valend++;
if (valend == len) break;
pos = valend;
while (pos < len && lp[pos] != '\n') pos++;
if (lp[pos] == '\n') pos++;
if (pos == len) break;
lp[valend] = 0;
if (type == 'i') {
n = str2ub4(lp + valstart,&ival);
if (n == 0) return error(0,"expected integer for %s, found '%.*s'",lp + varstart,valend - valstart,lp + valstart);
}
vp = lp + varstart;
if (varlen == 3 && memeq(vp,"dep",3)) var = Cdep;
else if (varlen == 3 && memeq(vp,"arr",3)) var = Carr;
else if (varlen == 7 && memeq(vp,"deptmin",7)) var = Ctdep;
else if (varlen == 8 && memeq(vp,"depttmin",8)) var = Cttdep;
else if (varlen == 7 && memeq(vp,"plusday",7)) var = Cplusday;
else if (varlen == 6 && memeq(vp,"minday",6)) var = Cminday;
else if (varlen == 6 && memeq(vp,"lostop",6)) var = Clostop;
else if (varlen == 6 && memeq(vp,"histop",6)) var = Chistop;
else if (varlen == 5 && memeq(vp,"mintt",5)) var = Cmintt;
else if (varlen == 5 && memeq(vp,"maxtt",5)) var = Cmaxtt;
else if (varlen == 11 && memeq(vp,"costperstop",11)) var = Ccostperstop;
else if (varlen == 9 && memeq(vp,"walklimit",9)) var = Cwalklimit;
else if (varlen == 12 && memeq(vp,"sumwalklimit",12)) var = Csumwalklimit;
else if (varlen == 9 && memeq(vp,"nethistop",9)) var = Cnethistop;
else if (varlen == 6 && memeq(vp,"utcofs",6)) var = Cutcofs;
else if (varlen == 5 && memeq(vp,"delay",5)) var = Cdelay;
else if (varlen == 8 && memeq(vp,"testiter",8)) var = Ctestiter;
else {
warn(0,"ignoring unknown var '%s'",vp);
var = Cnone;
}
switch (var) {
case Cnone: break;
case Cdep: dep = ival; break;
case Carr: arr = ival; break;
case Ctdep: tdep = ival; break;
case Cttdep: ttdep = ival; break;
case Cplusday: plusday = ival; break;
case Cminday: minday = ival; break;
case Clostop: lostop = ival; break;
case Chistop: histop = ival; break;
case Cmintt: mintt = ival; break;
case Cmaxtt: maxtt = ival; break;
case Ccostperstop: costperstop = ival; break;
case Cwalklimit: walklimit = ival; break;
case Csumwalklimit: sumwalklimit = ival; break;
case Cnethistop: nethistop = ival; break;
case Cutcofs: utcofs = ival; break;
case Cdelay: delay = ival; break;
case Ctestiter: testiter = ival; break;
}
}
if (mintt > maxtt) {
warn(0,"min transfer time %u cannot be above max %u",mintt,maxtt);
maxtt = mintt + 2;
}
if (sumwalklimit < walklimit) {
warn(0,"max distance for single go walk %u above summed max %u",walklimit,sumwalklimit);
sumwalklimit = walklimit;
}
if (dep > portcnt && dep - portcnt >= sportcnt) return error(0,"dep %u not in %u member net",dep - portcnt,sportcnt);
if (arr > portcnt && arr - portcnt >= sportcnt) return error(0,"arr %u not in %u member net",arr - portcnt,sportcnt);
if (dep == arr) warning(0,"dep %u equal to arr",dep);
evpool = src->evpool;
clear(src);
src->evpool = evpool;
src->depttmin_cd = ttdep;
src->deptmin_cd = tdep;
src->utcofs12 = utcofs;
src->plusday = plusday;
src->minday = minday;
src->nethistop = min(nethistop,histop);
src->mintt = mintt;
src->maxtt = maxtt;
src->costperstop = costperstop;
src->walklimit = m2geo(walklimit);
src->sumwalklimit = m2geo(sumwalklimit);
// invoke actual plan here
info(0,"plan %u to %u in %u to %u stop\as from %u.%u for +%u -%u days",dep,arr,lostop,histop,tdep,ttdep,plusday,minday);
info(0,"mintt %u maxtt %u maxwalk %u costperstop %u",mintt,maxtt,walklimit,costperstop);
info(0,"utcofs %u",utcofs);
rv = plantrip(src,req->name,dep,arr,lostop,histop);
// prepare reply
rep.buf = rep.localbuf;
if (rv) len = fmtstring(rep.localbuf,"reply plan %u-%u error code %d\n",dep,arr,rv);
else if (src->reslen) {
len = min(src->reslen,sizeof(rep.localbuf));
memcpy(rep.localbuf,src->resbuf,len);
} else len = fmtstring(rep.localbuf,"reply plan %u-%u : no trip found\n",dep,arr);
vrb0(0,"reply len %u",len);
rep.len = len;
if (delay) osmillisleep(delay);
rv |= setqentry(req,&rep,".rep");
if (testiter == 0 || dep == arr) return rv;
ub4 iter = 0;
while (iter < testiter) {
if (++arr == portcnt) {
arr = 0;
if (++dep == portcnt) dep = 0;
}
if (dep == arr) continue;
iter++;
rv = plantrip(src,req->name,dep,arr,lostop,histop);
if (rv) return rv;
}
ub4 iv,cnt,cumcnt = 0;
cnt = src->notrips;
infocc(cnt,0,"%u of %u trips not found",cnt,testiter);
info(0,"max dur %lu msec for dep %u arr %u",src->querymaxdur / 1000,src->querymaxdep,src->querymaxarr);
info(0,"query times in msec for %u iters",testiter);
for (iv = 0; iv < Elemcnt(src->querydurs); iv++) {
cnt = src->querydurs[iv];
cumcnt += cnt;
infocc(cnt,0,"%02u: %u %u",iv,cnt,cumcnt);
}
return 0;
}
ChatCommand * ChatHandler::getCommandTable()
{
static ChatCommand modifyCommandTable[] =
{
{ "hp", SEC_MODERATOR, &ChatHandler::HandleModifyHPCommand, "", NULL },
{ "mana", SEC_MODERATOR, &ChatHandler::HandleModifyManaCommand, "", NULL },
{ "rage", SEC_MODERATOR, &ChatHandler::HandleModifyRageCommand, "", NULL },
{ "energy", SEC_MODERATOR, &ChatHandler::HandleModifyEnergyCommand, "", NULL },
{ "money", SEC_MODERATOR, &ChatHandler::HandleModifyMoneyCommand, "", NULL },
{ "speed", SEC_MODERATOR, &ChatHandler::HandleModifySpeedCommand, "", NULL },
{ "swim", SEC_MODERATOR, &ChatHandler::HandleModifySwimCommand, "", NULL },
{ "scale", SEC_MODERATOR, &ChatHandler::HandleModifyScaleCommand, "", NULL },
{ "bit", SEC_MODERATOR, &ChatHandler::HandleModifyBitCommand, "", NULL },
{ "bwalk", SEC_MODERATOR, &ChatHandler::HandleModifyBWalkCommand, "", NULL },
{ "fly", SEC_MODERATOR, &ChatHandler::HandleModifyFlyCommand, "", NULL },
{ "aspeed", SEC_MODERATOR, &ChatHandler::HandleModifyASpeedCommand, "", NULL },
{ "faction", SEC_MODERATOR, &ChatHandler::HandleModifyFactionCommand, "", NULL },
{ "spell", SEC_MODERATOR, &ChatHandler::HandleModifySpellCommand, "", NULL },
{ "tp", SEC_MODERATOR, &ChatHandler::HandleModifyTalentCommand, "", NULL },
{ "titles", SEC_MODERATOR, &ChatHandler::HandleModifyKnownTitlesCommand, "", NULL },
{ "mount", SEC_MODERATOR, &ChatHandler::HandleModifyMountCommand, "", NULL },
{ "honor", SEC_MODERATOR, &ChatHandler::HandleModifyHonorCommand, "", NULL },
{ NULL, 0, NULL, "", NULL }
};
static ChatCommand wpCommandTable[] =
{
{ "show", SEC_GAMEMASTER, &ChatHandler::HandleWpShowCommand, "", NULL },
{ "add", SEC_GAMEMASTER, &ChatHandler::HandleWpAddCommand, "", NULL },
{ "modify", SEC_GAMEMASTER, &ChatHandler::HandleWpModifyCommand, "", NULL },
{ NULL, 0, NULL, "", NULL }
};
static ChatCommand debugCommandTable[] =
{
{ "inarc", SEC_ADMINISTRATOR, &ChatHandler::HandleDebugInArcCommand, "", NULL },
{ "spellfail", SEC_ADMINISTRATOR, &ChatHandler::HandleDebugSpellFailCommand, "", NULL },
{ "setpoi", SEC_ADMINISTRATOR, &ChatHandler::HandleSetPoiCommand, "", NULL },
{ "qpartymsg", SEC_ADMINISTRATOR, &ChatHandler::HandleSendQuestPartyMsgCommand, "", NULL },
{ "qinvalidmsg", SEC_ADMINISTRATOR, &ChatHandler::HandleSendQuestInvalidMsgCommand,"", NULL },
{ "itemmsg", SEC_ADMINISTRATOR, &ChatHandler::HandleSendItemErrorMsg, "", NULL },
{ "getitemstate",SEC_ADMINISTRATOR, &ChatHandler::HandleGetItemState, "", NULL },
{ NULL, 0, NULL, "", NULL }
};
static ChatCommand learnCommandTable[] =
{
{ "all", SEC_ADMINISTRATOR, &ChatHandler::HandleLearnAllCommand, "", NULL },
{ "all_gm", SEC_GAMEMASTER, &ChatHandler::HandleLearnAllGMCommand, "", NULL },
{ "all_crafts", SEC_GAMEMASTER, &ChatHandler::HandleLearnAllCraftsCommand, "", NULL },
{ "all_lang", SEC_MODERATOR, &ChatHandler::HandleLearnAllLangCommand, "", NULL },
{ "all_myclass", SEC_ADMINISTRATOR, &ChatHandler::HandleLearnAllMyClassCommand, "", NULL },
{ "all_myspells",SEC_ADMINISTRATOR, &ChatHandler::HandleLearnAllMySpellsCommand, "", NULL },
{ "all_mytalents",SEC_ADMINISTRATOR,&ChatHandler::HandleLearnAllMyTalentsCommand,"", NULL },
{ "", SEC_ADMINISTRATOR, &ChatHandler::HandleLearnCommand, "", NULL },
{ NULL, 0, NULL, "", NULL }
};
static ChatCommand reloadCommandTable[] =
{
{ "all", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadAllCommand, "", NULL },
{ "all_quest", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadAllQuestCommand, "", NULL },
{ "all_loot", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadAllLootCommand, "", NULL },
{ "all_scripts", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadAllSpellCommand, "", NULL },
{ "all_spell", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadAllSpellCommand, "", NULL },
{ "areatrigger_tavern", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadAreaTriggerTavernCommand, "", NULL },
{ "areatrigger_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadAreaTriggerTemplateCommand, "", NULL },
{ "areatrigger_involvedrelation",SEC_ADMINISTRATOR, &ChatHandler::HandleReloadQuestAreaTriggersCommand, "", NULL },
{ "button_scripts", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadButtonScriptsCommand, "", NULL },
{ "command", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadCommandCommand, "", NULL },
{ "creature_involvedrelation", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadCreatureQuestInvRelationsCommand,"",NULL },
{ "creature_loot_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLootTemplatesCreatureCommand, "", NULL },
{ "creature_questrelation", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadCreatureQuestRelationsCommand, "", NULL },
{ "disenchant_loot_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLootTemplatesDisenchantCommand, "", NULL },
{ "fishing_loot_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLootTemplatesFishingCommand, "", NULL },
{ "game_graveyard_zone", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadGameGraveyardZoneCommand, "", NULL },
{ "gameobject_involvedrelation", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadGOQuestInvRelationsCommand, "", NULL },
{ "gameobject_questrelation", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadGOQuestRelationsCommand, "", NULL },
{ "gameobject_loot_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLootTemplatesGameobjectCommand, "", NULL },
{ "item_loot_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLootTemplatesItemCommand, "", NULL },
{ "pickpocketing_loot_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLootTemplatesPickpocketingCommand,"",NULL},
{ "prospecting_loot_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLootTemplatesProspectingCommand,"", NULL },
{ "prospecting_loot_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLootTemplatesProspectingCommand,"", NULL },
{ "quest_end_scripts", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadQuestEndScriptsCommand, "", NULL },
{ "quest_start_scripts", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadQuestStartScriptsCommand, "", NULL },
{ "quest_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadQuestTemplateCommand, "", NULL },
{ "reserved_name", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadReservedNameCommand, "", NULL },
{ "spell_affect", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSpellAffectCommand, "", NULL },
{ "spell_chain", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSpellChainCommand, "", NULL },
{ "spell_learn_skill", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSpellLearnSkillCommand, "", NULL },
{ "spell_learn_spell", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSpellLearnSpellCommand, "", NULL },
{ "spell_proc_event", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSpellProcEventCommand, "", NULL },
{ "spell_script_target", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSpellScriptTargetCommand, "", NULL },
{ "spell_scripts", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSpellScriptsCommand, "", NULL },
{ "", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadCommand, "", NULL },
{ NULL, 0, NULL, "", NULL }
};
static ChatCommand honorCommandTable[] =
{
{ "add", SEC_GAMEMASTER, &ChatHandler::HandleAddHonorCommand, "", NULL },
{ "addkill", SEC_GAMEMASTER, &ChatHandler::HandleHonorAddKillCommand, "", NULL },
{ "flushkills", SEC_GAMEMASTER, &ChatHandler::HandleHonorFlushKillsCommand, "", NULL },
{ "update", SEC_GAMEMASTER, &ChatHandler::HandleUpdateHonorFieldsCommand, "", NULL },
{ NULL, 0, NULL, "", NULL }
};
static ChatCommand resetCommandTable[] =
{
{ "honor", SEC_ADMINISTRATOR, &ChatHandler::HandleResetHonorCommand, "", NULL },
{ "level", SEC_ADMINISTRATOR, &ChatHandler::HandleResetLevelCommand, "", NULL },
{ "spells", SEC_ADMINISTRATOR, &ChatHandler::HandleResetSpellsCommand, "", NULL },
{ "stats", SEC_ADMINISTRATOR, &ChatHandler::HandleResetStatsCommand, "", NULL },
{ "talents", SEC_ADMINISTRATOR, &ChatHandler::HandleResetTalentsCommand, "", NULL },
{ NULL, 0, NULL, "", NULL }
};
static ChatCommand commandTable[] =
{
{ "acct", SEC_PLAYER, &ChatHandler::HandleAcctCommand, "", NULL },
{ "addmove", SEC_GAMEMASTER, &ChatHandler::HandleAddMoveCommand, "", NULL },
{ "setmovetype", SEC_GAMEMASTER, &ChatHandler::HandleSetMoveTypeCommand, "", NULL },
{ "anim", SEC_GAMEMASTER, &ChatHandler::HandleAnimCommand, "", NULL },
{ "announce", SEC_MODERATOR, &ChatHandler::HandleAnnounceCommand, "", NULL },
{ "notify", SEC_MODERATOR, &ChatHandler::HandleNotifyCommand, "", NULL },
{ "go", SEC_MODERATOR, &ChatHandler::HandleGoXYZCommand, "", NULL },
{ "goxy", SEC_MODERATOR, &ChatHandler::HandleGoXYCommand, "", NULL },
{ "goxyz", SEC_MODERATOR, &ChatHandler::HandleGoXYZCommand, "", NULL },
{ "goname", SEC_MODERATOR, &ChatHandler::HandleGonameCommand, "", NULL },
{ "namego", SEC_MODERATOR, &ChatHandler::HandleNamegoCommand, "", NULL },
{ "groupgo", SEC_MODERATOR, &ChatHandler::HandleGroupgoCommand, "", NULL },
{ "aura", SEC_ADMINISTRATOR, &ChatHandler::HandleAuraCommand, "", NULL },
{ "unaura", SEC_ADMINISTRATOR, &ChatHandler::HandleUnAuraCommand, "", NULL },
{ "changelevel", SEC_GAMEMASTER, &ChatHandler::HandleChangeLevelCommand, "", NULL },
{ "commands", SEC_PLAYER, &ChatHandler::HandleCommandsCommand, "", NULL },
{ "delete", SEC_GAMEMASTER, &ChatHandler::HandleDeleteCommand, "", NULL },
{ "demorph", SEC_GAMEMASTER, &ChatHandler::HandleDeMorphCommand, "", NULL },
{ "die", SEC_ADMINISTRATOR, &ChatHandler::HandleDieCommand, "", NULL },
{ "revive", SEC_ADMINISTRATOR, &ChatHandler::HandleReviveCommand, "", NULL },
{ "dismount", SEC_PLAYER, &ChatHandler::HandleDismountCommand, "", NULL },
{ "setmodel", SEC_GAMEMASTER, &ChatHandler::HandleSetModelCommand, "", NULL },
{ "factionid", SEC_GAMEMASTER, &ChatHandler::HandleFactionIdCommand, "", NULL },
{ "listgm", SEC_PLAYER, &ChatHandler::HandleGMListCommand, "", NULL },
{ "gm", SEC_MODERATOR, &ChatHandler::HandleGMmodeCommand, "", NULL },
{ "gps", SEC_MODERATOR, &ChatHandler::HandleGPSCommand, "", NULL },
{ "guid", SEC_GAMEMASTER, &ChatHandler::HandleGUIDCommand, "", NULL },
{ "help", SEC_PLAYER, &ChatHandler::HandleHelpCommand, "", NULL },
{ "info", SEC_PLAYER, &ChatHandler::HandleInfoCommand, "", NULL },
{ "npcinfo", SEC_ADMINISTRATOR, &ChatHandler::HandleNpcInfoCommand, "", NULL },
{ "npcinfoset", SEC_ADMINISTRATOR, &ChatHandler::HandleNpcInfoSetCommand, "", NULL },
{ "addvendoritem",SEC_GAMEMASTER, &ChatHandler::HandleAddVendorItemCommand, "", NULL },
{ "delvendoritem",SEC_GAMEMASTER, &ChatHandler::HandleDelVendorItemCommand, "", NULL },
{ "itemmove", SEC_GAMEMASTER, &ChatHandler::HandleItemMoveCommand, "", NULL },
{ "kick", SEC_GAMEMASTER, &ChatHandler::HandleKickPlayerCommand, "", NULL },
{ "learn", SEC_MODERATOR, NULL, "", learnCommandTable },
{ "cooldown", SEC_ADMINISTRATOR, &ChatHandler::HandleCooldownCommand, "", NULL },
{ "unlearn", SEC_ADMINISTRATOR, &ChatHandler::HandleUnLearnCommand, "", NULL },
{ "modify", SEC_MODERATOR, NULL, "", modifyCommandTable },
{ "debug", SEC_MODERATOR, NULL, "", debugCommandTable },
{ "morph", SEC_GAMEMASTER, &ChatHandler::HandleMorphCommand, "", NULL },
{ "name", SEC_GAMEMASTER, &ChatHandler::HandleNameCommand, "", NULL },
{ "subname", SEC_GAMEMASTER, &ChatHandler::HandleSubNameCommand, "", NULL },
{ "npcflag", SEC_GAMEMASTER, &ChatHandler::HandleNPCFlagCommand, "", NULL },
{ "distance", SEC_ADMINISTRATOR, &ChatHandler::HandleGetDistanceCommand, "", NULL },
{ "addgo", SEC_GAMEMASTER, &ChatHandler::HandleGameObjectCommand, "", NULL },
{ "recall", SEC_MODERATOR, &ChatHandler::HandleRecallCommand, "", NULL },
{ "save", SEC_PLAYER, &ChatHandler::HandleSaveCommand, "", NULL },
{ "saveall", SEC_MODERATOR, &ChatHandler::HandleSaveAllCommand, "", NULL },
{ "security", SEC_ADMINISTRATOR, &ChatHandler::HandleSecurityCommand, "", NULL },
{ "ban", SEC_ADMINISTRATOR, &ChatHandler::HandleBanCommand, "", NULL },
{ "unban", SEC_ADMINISTRATOR, &ChatHandler::HandleUnBanCommand, "", NULL },
{ "baninfo", SEC_ADMINISTRATOR, &ChatHandler::HandleBanInfoCommand, "", NULL },
{ "banlist", SEC_ADMINISTRATOR, &ChatHandler::HandleBanListCommand, "", NULL },
{ "standstate", SEC_GAMEMASTER, &ChatHandler::HandleStandStateCommand, "", NULL },
{ "start", SEC_PLAYER, &ChatHandler::HandleStartCommand, "", NULL },
{ "taxicheat", SEC_MODERATOR, &ChatHandler::HandleTaxiCheatCommand, "", NULL },
{ "gogrid", SEC_MODERATOR, &ChatHandler::HandleGoGridCommand, "", NULL },
{ "addweapon", SEC_ADMINISTRATOR, &ChatHandler::HandleAddWeaponCommand, "", NULL },
{ "allowmove", SEC_ADMINISTRATOR, &ChatHandler::HandleAllowMovementCommand, "", NULL },
{ "linkgrave", SEC_ADMINISTRATOR, &ChatHandler::HandleLinkGraveCommand, "", NULL },
{ "neargrave", SEC_ADMINISTRATOR, &ChatHandler::HandleNearGraveCommand, "", NULL },
{ "transport", SEC_ADMINISTRATOR, &ChatHandler::HandleSpawnTransportCommand, "", NULL },
{ "explorecheat",SEC_ADMINISTRATOR, &ChatHandler::HandleExploreCheatCommand, "", NULL },
{ "hover", SEC_ADMINISTRATOR, &ChatHandler::HandleHoverCommand, "", NULL },
{ "levelup", SEC_ADMINISTRATOR, &ChatHandler::HandleLevelUpCommand, "", NULL },
{ "playemote", SEC_ADMINISTRATOR, &ChatHandler::HandlePlayEmoteCommand, "", NULL },
{ "showarea", SEC_ADMINISTRATOR, &ChatHandler::HandleShowAreaCommand, "", NULL },
{ "hidearea", SEC_ADMINISTRATOR, &ChatHandler::HandleHideAreaCommand, "", NULL },
{ "addspw", SEC_GAMEMASTER, &ChatHandler::HandleAddSpwCommand, "", NULL },
{ "spawndist", SEC_GAMEMASTER, &ChatHandler::HandleSpawnDistCommand, "", NULL },
{ "spawntime", SEC_GAMEMASTER, &ChatHandler::HandleSpawnTimeCommand, "", NULL },
{ "additem", SEC_ADMINISTRATOR, &ChatHandler::HandleAddItemCommand, "", NULL },
{ "additemset", SEC_ADMINISTRATOR, &ChatHandler::HandleAddItemSetCommand, "", NULL },
{ "createguild", SEC_ADMINISTRATOR, &ChatHandler::HandleCreateGuildCommand, "", NULL },
{ "update", SEC_ADMINISTRATOR, &ChatHandler::HandleUpdate, "", NULL },
{ "bank", SEC_ADMINISTRATOR, &ChatHandler::HandleBankCommand, "", NULL },
{ "wchange", SEC_ADMINISTRATOR, &ChatHandler::HandleChangeWeather, "", NULL },
{ "reload", SEC_ADMINISTRATOR, NULL, "", reloadCommandTable },
{ "loadscripts", SEC_ADMINISTRATOR, &ChatHandler::HandleLoadScriptsCommand, "", NULL },
{ "tele", SEC_MODERATOR, &ChatHandler::HandleTeleCommand, "", NULL },
{ "lookuptele", SEC_MODERATOR, &ChatHandler::HandleLookupTeleCommand, "", NULL },
{ "addtele", SEC_ADMINISTRATOR, &ChatHandler::HandleAddTeleCommand, "", NULL },
{ "deltele", SEC_ADMINISTRATOR, &ChatHandler::HandleDelTeleCommand, "", NULL },
{ "listauras", SEC_ADMINISTRATOR, &ChatHandler::HandleListAurasCommand, "", NULL },
{ "reset", SEC_ADMINISTRATOR, NULL, "", resetCommandTable },
{ "resetall", SEC_ADMINISTRATOR, &ChatHandler::HandleResetAllCommand, "", NULL },
{ "ticket", SEC_GAMEMASTER, &ChatHandler::HandleTicketCommand, "", NULL },
{ "delticket", SEC_GAMEMASTER, &ChatHandler::HandleDelTicketCommand, "", NULL },
{ "maxskill", SEC_ADMINISTRATOR, &ChatHandler::HandleMaxSkillCommand, "", NULL },
{ "setskill", SEC_ADMINISTRATOR, &ChatHandler::HandleSetSkillCommand, "", NULL },
{ "whispers", SEC_MODERATOR, &ChatHandler::HandleWhispersCommand, "", NULL },
{ "say", SEC_MODERATOR, &ChatHandler::HandleSayCommand, "", NULL },
{ "npcwhisper", SEC_MODERATOR, &ChatHandler::HandleNpcWhisperCommand, "", NULL },
{ "yell", SEC_MODERATOR, &ChatHandler::HandleYellCommand, "", NULL },
{ "textemote", SEC_MODERATOR, &ChatHandler::HandleTextEmoteCommand, "", NULL },
{ "gocreature", SEC_GAMEMASTER, &ChatHandler::HandleGoCreatureCommand, "", NULL },
{ "goobject", SEC_GAMEMASTER, &ChatHandler::HandleGoObjectCommand, "", NULL },
{ "targetobject",SEC_GAMEMASTER, &ChatHandler::HandleTargetObjectCommand, "", NULL },
{ "delobject", SEC_GAMEMASTER, &ChatHandler::HandleDelObjectCommand, "", NULL },
{ "turnobject", SEC_GAMEMASTER, &ChatHandler::HandleTurnObjectCommand, "", NULL },
{ "movecreature",SEC_GAMEMASTER, &ChatHandler::HandleMoveCreatureCommand, "", NULL },
{ "moveobject", SEC_GAMEMASTER, &ChatHandler::HandleMoveObjectCommand, "", NULL },
{ "idleshutdown",SEC_ADMINISTRATOR, &ChatHandler::HandleIdleShutDownCommand, "", NULL },
{ "shutdown", SEC_ADMINISTRATOR, &ChatHandler::HandleShutDownCommand, "", NULL },
{ "pinfo", SEC_GAMEMASTER, &ChatHandler::HandlePInfoCommand, "", NULL },
{ "plimit", SEC_ADMINISTRATOR, &ChatHandler::HandlePLimitCommand, "", NULL },
{ "visible", SEC_MODERATOR, &ChatHandler::HandleVisibleCommand, "", NULL },
{ "playsound", SEC_MODERATOR, &ChatHandler::HandlePlaySoundCommand, "", NULL },
{ "listcreature",SEC_ADMINISTRATOR, &ChatHandler::HandleListCreatureCommand, "", NULL },
{ "listitem", SEC_ADMINISTRATOR, &ChatHandler::HandleListItemCommand, "", NULL },
{ "listobject", SEC_ADMINISTRATOR, &ChatHandler::HandleListObjectCommand, "", NULL },
{ "lookupitem", SEC_ADMINISTRATOR, &ChatHandler::HandleLookupItemCommand, "", NULL },
{ "lookupitemset",SEC_ADMINISTRATOR,&ChatHandler::HandleLookupItemSetCommand, "", NULL },
{ "lookupskill", SEC_ADMINISTRATOR, &ChatHandler::HandleLookupSkillCommand, "", NULL },
{ "lookupspell", SEC_ADMINISTRATOR, &ChatHandler::HandleLookupSpellCommand, "", NULL },
{ "lookupquest", SEC_ADMINISTRATOR, &ChatHandler::HandleLookupQuestCommand, "", NULL },
{ "lookupcreature",SEC_ADMINISTRATOR,&ChatHandler::HandleLookupCreatureCommand, "", NULL },
{ "lookupobject",SEC_ADMINISTRATOR, &ChatHandler::HandleLookupObjectCommand, "", NULL },
{ "money", SEC_MODERATOR, &ChatHandler::HandleModifyMoneyCommand, "", NULL },
{ "titles", SEC_MODERATOR, &ChatHandler::HandleModifyKnownTitlesCommand, "", NULL },
{ "speed", SEC_MODERATOR, &ChatHandler::HandleModifySpeedCommand, "", NULL },
{ "addquest", SEC_ADMINISTRATOR, &ChatHandler::HandleAddQuest, "", NULL },
{ "removequest", SEC_ADMINISTRATOR, &ChatHandler::HandleRemoveQuest, "", NULL },
{ "password", SEC_PLAYER, &ChatHandler::HandlePasswordCommand, "", NULL },
{ "lockaccount", SEC_PLAYER, &ChatHandler::HandleLockAccountCommand, "", NULL },
{ "respawn", SEC_ADMINISTRATOR, &ChatHandler::HandleRespawnCommand, "", NULL },
{ "wp", SEC_GAMEMASTER, NULL, "", wpCommandTable },
{ "flymode", SEC_ADMINISTRATOR, &ChatHandler::HandleFlyModeCommand, "", NULL },
{ "sendopcode", SEC_ADMINISTRATOR, &ChatHandler::HandleSendOpcodeCommand, "", NULL },
{ "sellerr", SEC_ADMINISTRATOR, &ChatHandler::HandleSellErrorCommand, "", NULL },
{ "buyerr", SEC_ADMINISTRATOR, &ChatHandler::HandleBuyErrorCommand, "", NULL },
{ "uws", SEC_ADMINISTRATOR, &ChatHandler::HandleUpdateWorldStateCommand, "", NULL },
{ "ps", SEC_ADMINISTRATOR, &ChatHandler::HandlePlaySound2Command, "", NULL },
{ "scn", SEC_MODERATOR, &ChatHandler::HandleSendChannelNotifyCommand,"", NULL },
{ "scm", SEC_MODERATOR, &ChatHandler::HandleSendChatMsgCommand, "", NULL },
{ "sendmail", SEC_MODERATOR, &ChatHandler::HandleSendMailCommand, "", NULL },
{ "rename", SEC_GAMEMASTER, &ChatHandler::HandleRenameCommand, "", NULL },
{ "nametele", SEC_MODERATOR, &ChatHandler::HandleNameTeleCommand, "", NULL },
{ "grouptele", SEC_MODERATOR, &ChatHandler::HandleGroupTeleCommand, "", NULL },
{ "loadpdump", SEC_ADMINISTRATOR, &ChatHandler::HandleLoadPDumpCommand, "", NULL },
{ "writepdump", SEC_ADMINISTRATOR, &ChatHandler::HandleWritePDumpCommand, "", NULL },
{ "mute", SEC_GAMEMASTER, &ChatHandler::HandleMuteCommand, "", NULL },
{ "unmute", SEC_GAMEMASTER, &ChatHandler::HandleUnmuteCommand, "", NULL },
{ "honor", SEC_GAMEMASTER, NULL, "", honorCommandTable },
{ "movegens", SEC_ADMINISTRATOR, &ChatHandler::HandleMovegensCommand, "", NULL },
{ "cast", SEC_ADMINISTRATOR, &ChatHandler::HandleCastCommand, "", NULL },
{ "castback", SEC_ADMINISTRATOR, &ChatHandler::HandleCastBackCommand, "", NULL },
//! Development Commands
{ "setvalue", SEC_ADMINISTRATOR, &ChatHandler::HandleSetValue, "", NULL },
{ "getvalue", SEC_ADMINISTRATOR, &ChatHandler::HandleGetValue, "", NULL },
{ "Mod32Value", SEC_ADMINISTRATOR, &ChatHandler::HandleMod32Value, "", NULL },
{ NULL, 0, NULL, "", NULL }
};
if(load_command_table)
{
load_command_table = false;
QueryResult *result = sDatabase.Query("SELECT `name`,`security`,`help` FROM `command`");
if (result)
{
do
{
Field *fields = result->Fetch();
std::string name = fields[0].GetCppString();
for(uint32 i = 0; commandTable[i].Name != NULL; i++)
{
if (name == commandTable[i].Name)
{
commandTable[i].SecurityLevel = (uint16)fields[1].GetUInt16();
commandTable[i].Help = fields[2].GetCppString();
}
if(commandTable[i].ChildCommands != NULL)
{
ChatCommand *ptable = commandTable[i].ChildCommands;
for(uint32 j = 0; ptable[j].Name != NULL; j++)
{
// first case for "" named subcommand
if (ptable[j].Name == "" && name == commandTable[i].Name ||
name == fmtstring("%s %s", commandTable[i].Name, ptable[j].Name) )
{
ptable[j].SecurityLevel = (uint16)fields[1].GetUInt16();
ptable[j].Help = fields[2].GetCppString();
}
}
}
}
} while(result->NextRow());
delete result;
}
}
return commandTable;
}
void GenerateSimBuffs(json::Value& value, json::Value& data) {
TransformJson(value, data, FormatTag);
auto powers = Strings::list("Powers");
auto attrs = Strings::list("AttributeDescriptions");
auto powersEn = Strings::list("Powers", SnoLoader::default);
auto attrsEn = Strings::list("AttributeDescriptions", SnoLoader::default);
auto sets = Strings::list("ItemSets");
auto setsEn = Strings::list("ItemSets", SnoLoader::default);
auto items = Strings::list("Items");
auto itemsEn = Strings::list("Items", SnoLoader::default);
for (auto& kv : data["simMapping"]["buffs"].getMap()) {
std::string type = kv.second["category"].getString();
auto& dst = value["simMapping"]["buffs"][kv.first];
dst["category"] = fmtstring("$Simulator/%s$", type.c_str());
if (type == "Status") {
dst["name"] = value["simMapping"]["status"][kv.first];
} else {
std::string name, repl;
std::string realname = kv.second["name"].getString();
if (kv.second.has("skill")) {
auto& skill = kv.second["skill"];
std::string id = skill[0].getString();
if (!data["skillMap"].has(id)) {
Logger::log("Unknown skill: %s", id.c_str());
} else {
std::string power = data["skillMap"][id].getString();
name = powersEn[power + "_name"];
repl = powers[power + "_name"];
if (skill.length() > 1) {
char rune = skill[1].getString()[0];
name.append(" - ");
name.append(attrsEn.getfmt("NameRune_%c#%s", rune - 'a' + 'A', power.c_str()));
repl.append(" - ");
repl.append(attrs.getfmt("NameRune_%c#%s", rune - 'a' + 'A', power.c_str()));
}
}
} else if (kv.second.has("passive")) {
std::string id = kv.second["passive"].getString();
if (!data["skillMap"].has(id)) {
Logger::log("Unknown passive: %s", id.c_str());
} else {
std::string power = data["skillMap"][id].getString();
name = powersEn[power + "_name"];
repl = powers[power + "_name"];
}
} else if (kv.second.has("set")) {
std::string id = kv.second["set"][0].getString();
int count = kv.second["set"][1].getInteger();
if (!data["setMap"].has(id)) {
Logger::log("Unknown item set: %s", id.c_str());
} else {
id = data["setMap"][id].getString();
name = setsEn[id];
repl = sets[id];
if (name != realname) {
std::string suffix = fmtstring(" (%d)", count);
name.append(suffix);
repl.append(suffix);
}
}
} else if (kv.second.has("stat")) {
std::string id;
if (kv.second["stat"].type() == json::Value::tString) {
id = kv.second["stat"].getString();
} else {
id = kv.second["stat"][0].getString();
}
if (!data["legendaryMap"].has(id)) {
Logger::log("Unknown item: %s", id.c_str());
} else {
id = data["legendaryMap"][id].getString();
name = itemsEn[id];
repl = (items.has(id) ? items[id] : name);
}
} else if (kv.second.has("gem")) {
std::string id = kv.second["gem"][0].getString();
if (!data["legendaryGems"].has(id)) {
Logger::log("Unknown gem: %s", id.c_str());
} else {
id = data["legendaryGems"][id]["id"].getString();
name = itemsEn[id];
repl = items[id];
}
}
if (realname == "Boots of Disregard") {
int adsf = 0;
}
if (realname == name) {
dst["name"] = repl;
} else {
dst["name"] = fmtstring("$Simulator/%s$", realname.c_str());
data["stringlist"]["Simulator"][realname]["text"] = realname;
data["stringlist"]["Simulator"][realname]["tip"] = type + " buff";
}
}
}
StoreJson(value, data);
}
void FormulaParser::addcolor(char const* color, char const* val) {
if (!val) val = color;
pretags.emplace(fmtstring("c_%s", color), fmtstring("<span class=\"d3-color-%s\">", val));
pretags.emplace(fmtstring("/c_%s", color), "</span>");
}
std::string FormatTag(std::string const& src, json::Value& data) {
if (src.empty()) return src;
if (src[0] == '$' && src.back() == '$') return src;
size_t slash = src.find('/');
if (slash == std::string::npos) return src;
auto list = Strings::list(src.substr(0, slash));
if (!list) {
Logger::log("StringList not found: %s", src.substr(0, slash).c_str());
return src;
}
size_t at = src.find('@', slash);
std::string text = src.substr(slash + 1, at == std::string::npos ? at : at - slash - 1);
if (!list.has(text)) {
Logger::log("String not found: %s", src.substr(0, at).c_str());
return src;
}
text = list[text];
if (at != std::string::npos) {
size_t quest = src.find('?', at);
if (quest == std::string::npos) quest = src.length();
FormatFlags flags = FormatTags;
PowerTag* context = nullptr;
AttributeMap values = GameAffixes::defaultMap();
if (quest > at + 1) {
flags = FormatHTML;
context = PowerTags::get(src.substr(at + 1, quest - at - 1));
if (!context) {
Logger::log("PowerTag not found: %s", src.substr(at + 1, quest - at - 1).c_str());
}
} else {
values["value"] = AttributeValue("%");
values["value1"] = AttributeValue("%");
values["value2"] = AttributeValue("%");
values["value3"] = AttributeValue("%");
}
std::map<std::string, std::string> replace;
if (quest < src.length()) {
std::vector<std::string> parts = split(src.substr(quest + 1), '&');
for (auto& p : parts) {
size_t eq = p.find('=');
if (eq == std::string::npos) continue;
std::string key = p.substr(0, eq);
std::string value = p.substr(eq + 1);
if (!testString(key, isalnum)) {
size_t pos = text.find(key);
if (pos == std::string::npos) continue;
std::string rval = fmtstring("@%d", replace.size() + 1);
replace.emplace(rval, value);
text.replace(pos, key.length(), rval);
continue;
}
if (testString(value, isdigit)) {
values.emplace(key, atof(value.c_str()));
continue;
}
size_t ss = value.find('/');
if (ss == std::string::npos) {
values[key] = AttributeValue(value);
} else {
std::string listname = value.substr(0, ss);
if (!testString(listname, isalpha)) {
values[key] = AttributeValue(value); continue;
}
auto sublist = Strings::list(listname);
if (!sublist) {
Logger::log("StringList not found: %s", listname.c_str());
continue;
}
std::string subtext = value.substr(ss + 1);
if (!sublist.has(subtext)) {
Logger::log("String not found: %s", value.c_str());
continue;
}
values[key] = AttributeValue(sublist[subtext]);
}
}
}
text = FormatDescription(text, flags, values, context);
for (auto& kv : replace) {
size_t pos = text.find(kv.first);
if (pos == std::string::npos) continue;
text.replace(pos, kv.first.length(), kv.second);
}
}
return text;
}
