pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2026-04-25 18:42:27 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merge 46918cdbec59001d0c624210171b1d96d933c9e7 into 39426789f4070aaece74ce9cef5759873a2b81c1

Browse Source
This commit is contained in:
Arthur Ice 2013-06-03 16:26:37 -07:00
commit c99f78ee69
62 changed files with 5532 additions and 5140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
common/Item.h
View File

@ -47,7 +47,7 @@ namespace ItemField {
enum {
source=0,
#define F(x) x,
#include "item_fieldlist.h"
#include "item_fieldlist.h"
#undef F
updated
};

31
common/StringUtil.cpp
View File

@ -56,10 +56,10 @@ void vStringFormat(std::string& output, const char* format, va_list args)
throw std::runtime_error(errorMessage);
}
else if ((unsigned int)characters_used > output.capacity()) {
output.resize(characters_used+1);
if ((unsigned int)characters_used > output.capacity()) {
output.resize(characters_used);
va_copy(tmpargs,args);
characters_used = vsnprintf(&output[0], output.capacity(), format, tmpargs);
characters_used = vsnprintf(&output[0], output.capacity()+1, format, tmpargs);
va_end(tmpargs);
if (characters_used < 0) {
@ -70,24 +70,23 @@ void vStringFormat(std::string& output, const char* format, va_list args)
throw std::runtime_error(errorMessage);
}
return;
}
else {
output.resize(characters_used + 1);
output.resize(characters_used+1);
va_copy(tmpargs,args);
characters_used = vsnprintf(&output[0], output.capacity(), format, tmpargs);
va_end(tmpargs);
va_copy(tmpargs,args);
characters_used = vsnprintf(&output[0], output.capacity()+1, format, tmpargs);
va_end(tmpargs);
if (characters_used < 0) {
// We shouldn't have a format error by this point, but I can't imagine what error we
// could have by this point. still error out and report it.
std::string errorMessage("Invalid format string or unknown vsnprintf error; vsnprintf returned negative with format string: ");
errorMessage.append(format);
throw std::runtime_error(errorMessage);
}
if (characters_used < 0) {
// We shouldn't have a format error by this point, but I can't imagine what error we
// could have by this point. still error out and report it.
std::string errorMessage("Invalid format string or unknown vsnprintf error; vsnprintf returned negative with format string: ");
errorMessage.append(format);
throw std::runtime_error(errorMessage);
}
return;
}
void StringFormat(std::string& output, const char* format, ...)

1276
common/database.cpp
View File

File diff suppressed because it is too large Load Diff

2
common/database.h
View File

@ -221,7 +221,7 @@ public:
bool GetVariable(const char* varname, char* varvalue, uint16 varvalue_len);
bool SetVariable(const char* varname, const char* varvalue);
bool LoadVariables();
uint32 LoadVariables_MQ(char** query);
void LoadVariables_MQ(std::string& query);
bool LoadVariables_result(MYSQL_RES* result);
/*

30
common/dbasync.cpp
View File

@ -29,9 +29,11 @@ bool DBAsyncCB_LoadVariables(DBAsyncWork* iWork) {
}
void AsyncLoadVariables(DBAsync *dba, Database *db) {
char* query = 0;
std::string query;
DBAsyncWork* dbaw = new DBAsyncWork(db, &DBAsyncCB_LoadVariables, 0, DBAsync::Read);
dbaw->AddQuery(0, &query, db->LoadVariables_MQ(&query));
db->LoadVariables_MQ(query);
dbaw->AddQuery(0, query);
dba->AddWork(&dbaw);
}
@ -466,8 +468,8 @@ bool DBAsyncWork::AddQuery(DBAsyncQuery** iDBAQ) {
return ret;
}
bool DBAsyncWork::AddQuery(uint32 iQPT, char** iQuery, uint32 iQueryLen, bool iGetResultSet, bool iGetErrbuf) {
DBAsyncQuery* DBAQ = new DBAsyncQuery(iQPT, iQuery, iQueryLen, iGetResultSet, iGetErrbuf);
bool DBAsyncWork::AddQuery(uint32 iQPT, std::string iQuery, bool iGetResultSet, bool iGetErrbuf) {
DBAsyncQuery* DBAQ = new DBAsyncQuery(iQPT, iQuery, iGetResultSet, iGetErrbuf);
if (AddQuery(&DBAQ))
return true;
else {
@ -587,24 +589,11 @@ void DBAsyncWork::PushAnswer(DBAsyncQuery* iDBAQ) {
}
DBAsyncQuery::DBAsyncQuery(uint32 iQPT, char** iQuery, uint32 iQueryLen, bool iGetResultSet, bool iGetErrbuf) {
if (iQueryLen == 0xFFFFFFFF)
pQueryLen = strlen(*iQuery);
else
pQueryLen = iQueryLen;
pQuery = *iQuery;
*iQuery = 0;
DBAsyncQuery::DBAsyncQuery(uint32 iQPT, std::string iQuery, bool iGetResultSet, bool iGetErrbuf) {
pQuery = iQuery;
Init(iQPT, iGetResultSet, iGetErrbuf);
}
DBAsyncQuery::DBAsyncQuery(uint32 iQPT, const char* iQuery, uint32 iQueryLen, bool iGetResultSet, bool iGetErrbuf) {
if (iQueryLen == 0xFFFFFFFF)
pQueryLen = strlen(iQuery);
else
pQueryLen = iQueryLen;
pQuery = strn0cpy(new char[pQueryLen+1], iQuery, pQueryLen+1);
Init(iQPT, iGetResultSet, iGetErrbuf);
}
void DBAsyncQuery::Init(uint32 iQPT, bool iGetResultSet, bool iGetErrbuf) {
pstatus = DBAsync::AddingWork;
@ -622,7 +611,6 @@ void DBAsyncQuery::Init(uint32 iQPT, bool iGetResultSet, bool iGetErrbuf) {
DBAsyncQuery::~DBAsyncQuery() {
safe_delete_array(perrbuf);
safe_delete_array(pQuery);
if (presult)
mysql_free_result(presult);
}
@ -663,7 +651,7 @@ void DBAsyncQuery::Process(DBcore* iDBC) {
MYSQL_RES** resultPP = 0;
if (pGetResultSet)
resultPP = &presult;
pmysqlsuccess = iDBC->RunQuery(pQuery, pQueryLen, perrbuf, resultPP, &paffected_rows, &plast_insert_id, &perrnum);
pmysqlsuccess = iDBC->RunQuery(pQuery, perrbuf, resultPP, &paffected_rows, &plast_insert_id, &perrnum);
pstatus = DBAsync::Finished;
}

8
common/dbasync.h
View File

@ -96,7 +96,7 @@ public:
~DBAsyncWork();
bool AddQuery(DBAsyncQuery** iDBAQ);
bool AddQuery(uint32 iQPT, char** iQuery, uint32 iQueryLen = 0xFFFFFFFF, bool iGetResultSet = true, bool iGetErrbuf = true);
bool AddQuery(uint32 iQPT, std::string iQuery, bool iGetResultSet = true, bool iGetErrbuf = true);
uint32 WPT();
DBAsync::Type Type();
@ -140,8 +140,7 @@ private:
// Container class for the query information
class DBAsyncQuery {
public:
DBAsyncQuery(uint32 iQPT, char** iQuery, uint32 iQueryLen = 0xFFFFFFFF, bool iGetResultSet = true, bool iGetErrbuf = true);
DBAsyncQuery(uint32 iQPT, const char* iQuery, uint32 iQueryLen = 0xFFFFFFFF, bool iGetResultSet = true, bool iGetErrbuf = true);
DBAsyncQuery(uint32 iQPT, std::string iQuery, bool iGetResultSet = true, bool iGetErrbuf = true);
~DBAsyncQuery();
bool GetAnswer(char* errbuf = 0, MYSQL_RES** result = 0, uint32* affected_rows = 0, uint32* last_insert_id = 0, uint32* errnum = 0);
@ -155,8 +154,7 @@ protected:
void Init(uint32 iQPT, bool iGetResultSet, bool iGetErrbuf);
DBAsync::Status pstatus;
char* pQuery;
uint32 pQueryLen;
std::string pQuery;
bool pGetResultSet;
bool pGetErrbuf;

16
common/dbcore.cpp
View File

@ -12,6 +12,7 @@
#include <string.h>
#include "../common/MiscFunctions.h"
#include <cstdlib>
#include <string>
#ifdef _WINDOWS
#define snprintf _snprintf
@ -58,7 +59,7 @@ void DBcore::ping() {
MDatabase.unlock();
}
bool DBcore::RunQuery(const char* query, uint32 querylen, char* errbuf, MYSQL_RES** result, uint32* affected_rows, uint32* last_insert_id, uint32* errnum, bool retry) {
bool DBcore::RunQuery(const std::string& query, char* errbuf, MYSQL_RES** result, uint32* affected_rows, uint32* last_insert_id, uint32* errnum, bool retry) {
_CP(DBcore_RunQuery);
if (errnum)
*errnum = 0;
@ -70,16 +71,16 @@ bool DBcore::RunQuery(const char* query, uint32 querylen, char* errbuf, MYSQL_RE
Open();
#if DEBUG_MYSQL_QUERIES >= 1
char tmp[120];
strn0cpy(tmp, query, sizeof(tmp));
strn0cpy(tmp, query.c_str(), sizeof(tmp));
std::cout << "QUERY: " << tmp << std::endl;
#endif
if (mysql_real_query(&mysql, query, querylen)) {
if (mysql_real_query(&mysql, query.c_str(), query.length())) {
if (mysql_errno(&mysql) == CR_SERVER_GONE_ERROR)
pStatus = Error;
if (mysql_errno(&mysql) == CR_SERVER_LOST || mysql_errno(&mysql) == CR_SERVER_GONE_ERROR) {
if (retry) {
std::cout << "Database Error: Lost connection, attempting to recover...." << std::endl;
ret = RunQuery(query, querylen, errbuf, result, affected_rows, last_insert_id, errnum, false);
ret = RunQuery(query, errbuf, result, affected_rows, last_insert_id, errnum, false);
if (ret)
std::cout << "Reconnection to database successful." << std::endl;
}
@ -152,10 +153,13 @@ bool DBcore::RunQuery(const char* query, uint32 querylen, char* errbuf, MYSQL_RE
return ret;
}
uint32 DBcore::DoEscapeString(char* tobuf, const char* frombuf, uint32 fromlen) {
void DBcore::DoEscapeString(std::string& outString, const char* frombuf, uint32 fromlen) {
// No good reason to lock the DB, we only need it in the first place to check char encoding.
// LockMutex lock(&MDatabase);
return mysql_real_escape_string(&mysql, tobuf, frombuf, fromlen);
char* tobuf = new char[sizeof(frombuf)*fromlen*2]();
unsigned long length = mysql_real_escape_string(&mysql, tobuf, frombuf, fromlen);
outString.assign(tobuf,length);
safe_delete_array(tobuf);
}
bool DBcore::Open(const char* iHost, const char* iUser, const char* iPassword, const char* iDatabase,uint32 iPort, uint32* errnum, char* errbuf, bool iCompress, bool iSSL) {

5
common/dbcore.h
View File

@ -7,6 +7,7 @@
//#include <winsock.h>
#endif
#include <mysql.h>
#include <string>
#include "../common/types.h"
#include "../common/Mutex.h"
#include "../common/linked_list.h"
@ -21,8 +22,8 @@ public:
DBcore();
~DBcore();
eStatus GetStatus() { return pStatus; }
bool RunQuery(const char* query, uint32 querylen, char* errbuf = 0, MYSQL_RES** result = 0, uint32* affected_rows = 0, uint32* last_insert_id = 0, uint32* errnum = 0, bool retry = true);
uint32 DoEscapeString(char* tobuf, const char* frombuf, uint32 fromlen);
bool RunQuery(const std::string& query, char* errbuf = 0, MYSQL_RES** result = 0, uint32* affected_rows = 0, uint32* last_insert_id = 0, uint32* errnum = 0, bool retry = true);
void DoEscapeString(std::string& outString, const char* frombuf, uint32 fromlen);
void ping();
MYSQL* getMySQL(){ return &mysql; }

6
common/debug.cpp
View File

@ -5,12 +5,6 @@
#ifdef _WINDOWS
#include <process.h>
#define snprintf _snprintf
#define vsnprintf _vsnprintf
#define strncasecmp _strnicmp
#define strcasecmp _stricmp
#else
#include <sys/types.h>

421
common/guild_base.cpp
View File

@ -50,32 +50,32 @@ bool BaseGuildManager::LoadGuilds() {
}
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
std::map<uint32, GuildInfo *>::iterator res;
StringFormat(query, "SELECT id, name, leader, minstatus, motd, motd_setter,channel, url FROM guilds");
// load up all the guilds
if (!m_db->RunQuery(query, MakeAnyLenString(&query,
"SELECT id, name, leader, minstatus, motd, motd_setter,channel,url FROM guilds"), errbuf, &result)) {
_log(GUILDS__ERROR, "Error loading guilds '%s': %s", query, errbuf);
safe_delete_array(query);
if (!m_db->RunQuery(query, errbuf, &result)) {
_log(GUILDS__ERROR, "Error loading guilds '%s': %s", query.c_str(), errbuf);
return(false);
}
safe_delete_array(query);
while ((row = mysql_fetch_row(result))) {
_CreateGuild(atoi(row[0]), row[1], atoi(row[2]), atoi(row[3]), row[4], row[5], row[6], row[7]);
}
mysql_free_result(result);
StringFormat(query,"SELECT guild_id, rank, title, can_hear, can_speak, can_invite, can_remove, can_promote,"
"can_demote, can_motd, can_warpeace FROM guild_ranks");
//load up the rank info for each guild.
if (!m_db->RunQuery(query, MakeAnyLenString(&query,
"SELECT guild_id,rank,title,can_hear,can_speak,can_invite,can_remove,can_promote,can_demote,can_motd,can_warpeace FROM guild_ranks"), errbuf, &result)) {
_log(GUILDS__ERROR, "Error loading guild ranks '%s': %s", query, errbuf);
safe_delete_array(query);
if (!m_db->RunQuery(query, errbuf, &result)) {
_log(GUILDS__ERROR, "Error loading guild ranks '%s': %s", query.c_str(), errbuf);
return(false);
}
safe_delete_array(query);
while ((row = mysql_fetch_row(result))) {
uint32 guild_id = atoi(row[0]);
uint8 rankn = atoi(row[1]);
@ -114,20 +114,21 @@ bool BaseGuildManager::RefreshGuild(uint32 guild_id) {
}
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
std::map<uint32, GuildInfo *>::iterator res;
GuildInfo *info;
// load up all the guilds
if (!m_db->RunQuery(query, MakeAnyLenString(&query,
"SELECT name, leader, minstatus, motd, motd_setter, channel,url FROM guilds WHERE id=%lu", (unsigned long)guild_id), errbuf, &result)) {
_log(GUILDS__ERROR, "Error reloading guilds '%s': %s", query, errbuf);
safe_delete_array(query);
StringFormat(query,"SELECT name, leader, minstatus, motd, motd_setter, channel, url"
" FROM guilds WHERE id=%lu", (unsigned long)guild_id);
if (!m_db->RunQuery(query, errbuf, &result)) {
_log(GUILDS__ERROR, "Error reloading guilds '%s': %s", query.c_str(), errbuf);
return(false);
}
safe_delete_array(query);
if ((row = mysql_fetch_row(result))) {
//delete the old entry and create the new one.
info = _CreateGuild(guild_id, row[0], atoi(row[1]), atoi(row[2]), row[3], row[4], row[5], row[6]);
@ -138,14 +139,13 @@ bool BaseGuildManager::RefreshGuild(uint32 guild_id) {
mysql_free_result(result);
//load up the rank info for each guild.
if (!m_db->RunQuery(query, MakeAnyLenString(&query,
"SELECT guild_id,rank,title,can_hear,can_speak,can_invite,can_remove,can_promote,can_demote,can_motd,can_warpeace "
"FROM guild_ranks WHERE guild_id=%lu", (unsigned long)guild_id), errbuf, &result)) {
_log(GUILDS__ERROR, "Error reloading guild ranks '%s': %s", query, errbuf);
safe_delete_array(query);
StringFormat(query,"SELECT guild_id,rank,title,can_hear,can_speak,can_invite,can_remove,can_promote,can_demote,can_motd,can_warpeace "
"FROM guild_ranks WHERE guild_id=%lu", (unsigned long)guild_id);
if (!m_db->RunQuery(query, errbuf, &result)) {
_log(GUILDS__ERROR, "Error reloading guild ranks '%s': %s", query.c_str(), errbuf);
return(false);
}
safe_delete_array(query);
while((row = mysql_fetch_row(result))) {
uint8 rankn = atoi(row[1]);
@ -232,77 +232,62 @@ bool BaseGuildManager::_StoreGuildDB(uint32 guild_id) {
GuildInfo *info = res->second;
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
//clear out old `guilds` entry
if (!m_db->RunQuery(query, MakeAnyLenString(&query,
"DELETE FROM guilds WHERE id=%lu", (unsigned long)guild_id), errbuf))
{
_log(GUILDS__ERROR, "Error clearing old guild record when storing %d '%s': %s", guild_id, query, errbuf);
StringFormat(query, "DELETE FROM guilds WHERE id=%lu", (unsigned long)guild_id);
if (!m_db->RunQuery(query, errbuf)) {
_log(GUILDS__ERROR, "Error clearing old guild record when storing %d '%s': %s", guild_id, query.c_str(), errbuf);
}
safe_delete_array(query);
//clear out old `guild_ranks` entries
if (!m_db->RunQuery(query, MakeAnyLenString(&query,
"DELETE FROM guild_ranks WHERE guild_id=%lu", (unsigned long)guild_id), errbuf))
{
_log(GUILDS__ERROR, "Error clearing old guild_ranks records when storing %d '%s': %s", guild_id, query, errbuf);
StringFormat(query, "DELETE FROM guild_ranks WHERE guild_id=%lu", (unsigned long)guild_id);
if (!m_db->RunQuery(query, errbuf)) {
_log(GUILDS__ERROR, "Error clearing old guild_ranks records when storing %d '%s': %s", guild_id, query.c_str(), errbuf);
}
safe_delete_array(query);
//escape our strings.
char *name_esc = new char[info->name.length()*2+1];
char *motd_esc = new char[info->motd.length()*2+1];
char *motd_set_esc = new char[info->motd_setter.length()*2+1];
std::string name_esc;
std::string motd_esc;
std::string motd_set_esc;
m_db->DoEscapeString(name_esc, info->name.c_str(), info->name.length());
m_db->DoEscapeString(motd_esc, info->motd.c_str(), info->motd.length());
m_db->DoEscapeString(motd_set_esc, info->motd_setter.c_str(), info->motd_setter.length());
//insert the new `guilds` entry
if (!m_db->RunQuery(query, MakeAnyLenString(&query,
"INSERT INTO guilds (id,name,leader,minstatus,motd,motd_setter) VALUES(%lu,'%s',%lu,%d,'%s', '%s')",
(unsigned long)guild_id, name_esc, (unsigned long)info->leader_char_id, info->minstatus, motd_esc, motd_set_esc), errbuf))
StringFormat(query, "INSERT INTO guilds (id,name,leader,minstatus,motd,motd_setter) VALUES(%lu,'%s',%lu,%d,'%s', '%s')",
(unsigned long)guild_id, name_esc.c_str(), (unsigned long)info->leader_char_id, info->minstatus, motd_esc.c_str(), motd_set_esc.c_str());
if (!m_db->RunQuery(query, errbuf))
{
_log(GUILDS__ERROR, "Error inserting new guild record when storing %d. Giving up. '%s': %s", guild_id, query, errbuf);
safe_delete_array(query);
safe_delete_array(name_esc);
safe_delete_array(motd_esc);
safe_delete_array(motd_set_esc);
_log(GUILDS__ERROR, "Error inserting new guild record when storing %d. Giving up. '%s': %s", guild_id, query.c_str(), errbuf);
return(false);
}
safe_delete_array(query);
safe_delete_array(name_esc);
safe_delete_array(motd_esc);
safe_delete_array(motd_set_esc);
//now insert the new ranks
uint8 rank;
for(rank = 0; rank <= GUILD_MAX_RANK; rank++) {
const RankInfo &r = info->ranks[rank];
char *title_esc = new char[r.name.length()*2+1];
std::string title_esc;
m_db->DoEscapeString(title_esc, r.name.c_str(), r.name.length());
if (!m_db->RunQuery(query, MakeAnyLenString(&query,
"INSERT INTO guild_ranks (guild_id,rank,title,can_hear,can_speak,can_invite,can_remove,can_promote,can_demote,can_motd,can_warpeace)"
" VALUES(%d,%d,'%s',%d,%d,%d,%d,%d,%d,%d,%d)",
guild_id, rank, title_esc,
r.permissions[GUILD_HEAR],
r.permissions[GUILD_SPEAK],
r.permissions[GUILD_INVITE],
r.permissions[GUILD_REMOVE],
r.permissions[GUILD_PROMOTE],
r.permissions[GUILD_DEMOTE],
r.permissions[GUILD_MOTD],
r.permissions[GUILD_WARPEACE]), errbuf))
{
_log(GUILDS__ERROR, "Error inserting new guild rank record when storing %d for %d. Giving up. '%s': %s", rank, guild_id, query, errbuf);
safe_delete_array(query);
safe_delete_array(title_esc);
StringFormat(query,"INSERT INTO guild_ranks (guild_id,rank,title,can_hear,can_speak,can_invite,can_remove,can_promote,can_demote,can_motd,can_warpeace)"
" VALUES(%d,%d,'%s',%d,%d,%d,%d,%d,%d,%d,%d)",
guild_id, rank, title_esc.c_str(),
r.permissions[GUILD_HEAR],
r.permissions[GUILD_SPEAK],
r.permissions[GUILD_INVITE],
r.permissions[GUILD_REMOVE],
r.permissions[GUILD_PROMOTE],
r.permissions[GUILD_DEMOTE],
r.permissions[GUILD_MOTD],
r.permissions[GUILD_WARPEACE]);
if (!m_db->RunQuery(query, errbuf)) {
_log(GUILDS__ERROR, "Error inserting new guild rank record when storing %d for %d. Giving up. '%s': %s", rank, guild_id, query.c_str(), errbuf);
return(false);
}
safe_delete_array(query);
safe_delete_array(title_esc);
}
_log(GUILDS__DB, "Stored guild %d in the database", guild_id);
@ -317,7 +302,7 @@ uint32 BaseGuildManager::_GetFreeGuildID() {
}
char errbuf[MYSQL_ERRMSG_SIZE];
char query[100];
std::string query;
MYSQL_RES *result;
//this has got to be one of the more retarded things I have seen.
@ -325,9 +310,9 @@ uint32 BaseGuildManager::_GetFreeGuildID() {
uint16 x;
for (x = 1; x < MAX_NUMBER_GUILDS; x++) {
snprintf(query, 100, "SELECT id FROM guilds where id=%i;", x);
StringFormat(query,"SELECT id FROM guilds where id=%i;", x);
if (m_db->RunQuery(query, strlen(query), errbuf, &result)) {
if (m_db->RunQuery(query, errbuf, &result)) {
if (mysql_num_rows(result) == 0) {
mysql_free_result(result);
_log(GUILDS__DB, "Located free guild ID %d in the database", x);
@ -336,7 +321,7 @@ uint32 BaseGuildManager::_GetFreeGuildID() {
mysql_free_result(result);
}
else {
LogFile->write(EQEMuLog::Error, "Error in _GetFreeGuildID query '%s': %s", query, errbuf);
LogFile->write(EQEMuLog::Error, "Error in _GetFreeGuildID query '%s': %s", query.c_str(), errbuf);
}
}
@ -529,23 +514,23 @@ bool BaseGuildManager::DBDeleteGuild(uint32 guild_id) {
return(false);
}
char *query = 0;
std::string query;
//clear out old `guilds` entry
_RunQuery(query, MakeAnyLenString(&query,
"DELETE FROM guilds WHERE id=%lu", (unsigned long)guild_id), "clearing old guild record");
StringFormat(query,"DELETE FROM guilds WHERE id=%lu", (unsigned long)guild_id);
_RunQuery(query, "clearing old guild record");
//clear out old `guild_ranks` entries
_RunQuery(query, MakeAnyLenString(&query,
"DELETE FROM guild_ranks WHERE guild_id=%lu", (unsigned long)guild_id), "clearing old guild_ranks records");
StringFormat(query,"DELETE FROM guild_ranks WHERE guild_id=%lu", (unsigned long)guild_id);
_RunQuery(query, "clearing old guild_ranks records");
//clear out people belonging to this guild.
_RunQuery(query, MakeAnyLenString(&query,
"DELETE FROM guild_members WHERE guild_id=%lu", (unsigned long)guild_id), "clearing chars in guild");
StringFormat(query,"DELETE FROM guild_members WHERE guild_id=%lu", (unsigned long)guild_id);
_RunQuery(query, "clearing chars in guild");
// Delete the guild bank
_RunQuery(query, MakeAnyLenString(&query,
"DELETE FROM guild_bank WHERE guildid=%lu", (unsigned long)guild_id), "deleting guild bank");
StringFormat(query,"DELETE FROM guild_bank WHERE guildid=%lu", (unsigned long)guild_id);
_RunQuery(query, "deleting guild bank");
_log(GUILDS__DB, "Deleted guild %d from the database.", guild_id);
@ -565,25 +550,22 @@ bool BaseGuildManager::DBRenameGuild(uint32 guild_id, const char* name) {
GuildInfo *info = res->second;
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
//escape our strings.
uint32 len = strlen(name);
char *esc = new char[len*2+1];
std::string esc;
m_db->DoEscapeString(esc, name, len);
//insert the new `guilds` entry
if (!m_db->RunQuery(query, MakeAnyLenString(&query,
"UPDATE guilds SET name='%s' WHERE id=%d",
esc, guild_id), errbuf))
StringFormat(query, "UPDATE guilds SET name='%s' WHERE id=%d",
esc.c_str(), guild_id);
if (!m_db->RunQuery(query, errbuf))
{
_log(GUILDS__ERROR, "Error renaming guild %d '%s': %s", guild_id, query, errbuf);
safe_delete_array(query);
safe_delete_array(esc);
_log(GUILDS__ERROR, "Error renaming guild %d '%s': %s", guild_id, query.c_str(), errbuf);
return(false);
}
safe_delete_array(query);
safe_delete_array(esc);
_log(GUILDS__DB, "Renamed guild %s (%d) to %s in database.", info->name.c_str(), guild_id, name);
@ -605,18 +587,16 @@ bool BaseGuildManager::DBSetGuildLeader(uint32 guild_id, uint32 leader) {
GuildInfo *info = res->second;
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
//insert the new `guilds` entry
if (!m_db->RunQuery(query, MakeAnyLenString(&query,
"UPDATE guilds SET leader='%d' WHERE id=%d",
leader, guild_id), errbuf))
{
_log(GUILDS__ERROR, "Error changing leader on guild %d '%s': %s", guild_id, query, errbuf);
safe_delete_array(query);
StringFormat(query, "UPDATE guilds SET leader='%d' WHERE id=%d",
leader, guild_id);
if (!m_db->RunQuery(query, errbuf)) {
_log(GUILDS__ERROR, "Error changing leader on guild %d '%s': %s", guild_id, query.c_str(), errbuf);
return(false);
}
safe_delete_array(query);
//set the old leader to officer
if(!DBSetGuildRank(info->leader_char_id, GUILD_OFFICER))
@ -645,30 +625,24 @@ bool BaseGuildManager::DBSetGuildMOTD(uint32 guild_id, const char* motd, const c
GuildInfo *info = res->second;
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
//escape our strings.
uint32 len = strlen(motd);
uint32 len2 = strlen(setter);
char *esc = new char[len*2+1];
char *esc_set = new char[len2*2+1];
std::string esc;
std::string esc_set;
m_db->DoEscapeString(esc, motd, len);
m_db->DoEscapeString(esc_set, setter, len2);
//insert the new `guilds` entry
if (!m_db->RunQuery(query, MakeAnyLenString(&query,
"UPDATE guilds SET motd='%s',motd_setter='%s' WHERE id=%d",
esc, esc_set, guild_id), errbuf))
{
_log(GUILDS__ERROR, "Error setting MOTD for guild %d '%s': %s", guild_id, query, errbuf);
safe_delete_array(query);
safe_delete_array(esc);
safe_delete_array(esc_set);
StringFormat(query,"UPDATE guilds SET motd='%s',motd_setter='%s' WHERE id=%d",
esc.c_str(), esc_set.c_str(), guild_id);
if (!m_db->RunQuery(query, errbuf)) {
_log(GUILDS__ERROR, "Error setting MOTD for guild %d '%s': %s", guild_id, query.c_str(), errbuf);
return(false);
}
safe_delete_array(query);
safe_delete_array(esc);
safe_delete_array(esc_set);
_log(GUILDS__DB, "Set MOTD for guild %d in the database", guild_id);
@ -693,24 +667,23 @@ bool BaseGuildManager::DBSetGuildURL(uint32 GuildID, const char* URL)
GuildInfo *info = res->second;
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
//escape our strings.
uint32 len = strlen(URL);
char *esc = new char[len*2+1];
std::string esc;
m_db->DoEscapeString(esc, URL, len);
if (!m_db->RunQuery(query, MakeAnyLenString(&query, "UPDATE guilds SET url='%s' WHERE id=%d", esc, GuildID), errbuf))
StringFormat(query, "UPDATE guilds SET url='%s' WHERE id=%d",
esc.c_str(), GuildID);
if (!m_db->RunQuery(query, errbuf))
{
_log(GUILDS__ERROR, "Error setting URL for guild %d '%s': %s", GuildID, query, errbuf);
safe_delete_array(query);
safe_delete_array(esc);
_log(GUILDS__ERROR, "Error setting URL for guild %d '%s': %s", GuildID, query.c_str(), errbuf);
return(false);
}
safe_delete_array(query);
safe_delete_array(esc);
_log(GUILDS__DB, "Set URL for guild %d in the database", GuildID);
@ -734,24 +707,21 @@ bool BaseGuildManager::DBSetGuildChannel(uint32 GuildID, const char* Channel)
GuildInfo *info = res->second;
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
//escape our strings.
uint32 len = strlen(Channel);
char *esc = new char[len*2+1];
std::string esc;
m_db->DoEscapeString(esc, Channel, len);
if (!m_db->RunQuery(query, MakeAnyLenString(&query, "UPDATE guilds SET channel='%s' WHERE id=%d", esc, GuildID), errbuf))
{
_log(GUILDS__ERROR, "Error setting Channel for guild %d '%s': %s", GuildID, query, errbuf);
safe_delete_array(query);
safe_delete_array(esc);
StringFormat(query,"UPDATE guilds SET channel='%s' WHERE id=%d", esc.c_str(), GuildID);
if (!m_db->RunQuery(query, errbuf)) {
_log(GUILDS__ERROR, "Error setting Channel for guild %d '%s': %s", GuildID, query.c_str(), errbuf);
return(false);
}
safe_delete_array(query);
safe_delete_array(esc);
_log(GUILDS__DB, "Set Channel for guild %d in the database", GuildID);
@ -767,28 +737,25 @@ bool BaseGuildManager::DBSetGuild(uint32 charid, uint32 guild_id, uint8 rank) {
}
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
if(guild_id != GUILD_NONE) {
if (!m_db->RunQuery(query, MakeAnyLenString(&query,
"REPLACE INTO guild_members (char_id,guild_id,rank) VALUES(%d,%d,%d)",
charid, guild_id, rank), errbuf))
{
_log(GUILDS__ERROR, "Error Changing char %d to guild %d '%s': %s", charid, guild_id, query, errbuf);
safe_delete_array(query);
StringFormat(query, "REPLACE INTO guild_members (char_id,guild_id,rank) VALUES(%d,%d,%d)",
charid, guild_id, rank);
if (!m_db->RunQuery(query, errbuf)) {
_log(GUILDS__ERROR, "Error Changing char %d to guild %d '%s': %s", charid, guild_id, query.c_str(), errbuf);
return(false);
}
} else {
if (!m_db->RunQuery(query, MakeAnyLenString(&query,
"DELETE FROM guild_members WHERE char_id=%d",
charid), errbuf))
{
_log(GUILDS__ERROR, "Error removing char %d from guild '%s': %s", charid, guild_id, query, errbuf);
safe_delete_array(query);
}
else {
StringFormat(query, "DELETE FROM guild_members WHERE char_id=%d", charid);
if (!m_db->RunQuery(query, errbuf)) {
_log(GUILDS__ERROR, "Error removing char %d from guild '%s': %s", charid, guild_id, query.c_str(), errbuf);
return(false);
}
}
safe_delete_array(query);
_log(GUILDS__DB, "Set char %d to guild %d and rank %d in the database.", charid, guild_id, rank);
@ -796,40 +763,38 @@ bool BaseGuildManager::DBSetGuild(uint32 charid, uint32 guild_id, uint8 rank) {
}
bool BaseGuildManager::DBSetGuildRank(uint32 charid, uint8 rank) {
char *query = 0;
return(_RunQuery(query, MakeAnyLenString(&query,
"UPDATE guild_members SET rank=%d WHERE char_id=%d",
rank, charid), "setting a guild member's rank"));
std::string query;
StringFormat(query, "UPDATE guild_members SET rank=%d WHERE char_id=%d", rank, charid);
return(_RunQuery(query, "setting a guild member's rank"));
}
bool BaseGuildManager::DBSetBankerFlag(uint32 charid, bool is_banker) {
char *query = 0;
return(_RunQuery(query, MakeAnyLenString(&query,
"UPDATE guild_members SET banker=%d WHERE char_id=%d",
is_banker?1:0, charid), "setting a guild member's banker flag"));
std::string query;
StringFormat(query, "UPDATE guild_members SET banker=%d WHERE char_id=%d",
is_banker?1:0, charid);
return(_RunQuery(query, "setting a guild member's banker flag"));
}
bool BaseGuildManager::GetBankerFlag(uint32 CharID)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if(!m_db)
return false;
if(!m_db->RunQuery(query, MakeAnyLenString(&query, "select `banker` from `guild_members` where char_id=%i LIMIT 1", CharID), errbuf, &result))
{
_log(GUILDS__ERROR, "Error retrieving banker flag '%s': %s", query, errbuf);
StringFormat(query,"select `banker` from `guild_members` where char_id=%i LIMIT 1", CharID);
safe_delete_array(query);
if(!m_db->RunQuery(query, errbuf, &result))
{
_log(GUILDS__ERROR, "Error retrieving banker flag '%s': %s", query.c_str(), errbuf);
return false;
}
safe_delete_array(query);
if(mysql_num_rows(result) != 1)
return false;
@ -844,34 +809,31 @@ bool BaseGuildManager::GetBankerFlag(uint32 CharID)
bool BaseGuildManager::DBSetAltFlag(uint32 charid, bool is_alt)
{
char *query = 0;
std::string query;
return(_RunQuery(query, MakeAnyLenString(&query,
"UPDATE guild_members SET alt=%d WHERE char_id=%d",
is_alt?1:0, charid), "setting a guild member's alt flag"));
StringFormat(query,"UPDATE guild_members SET alt=%d WHERE char_id=%d",
is_alt?1:0, charid);
return(_RunQuery(query, "setting a guild member's alt flag"));
}
bool BaseGuildManager::GetAltFlag(uint32 CharID)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if(!m_db)
return false;
if(!m_db->RunQuery(query, MakeAnyLenString(&query, "select `alt` from `guild_members` where char_id=%i LIMIT 1", CharID), errbuf, &result))
{
_log(GUILDS__ERROR, "Error retrieving alt flag '%s': %s", query, errbuf);
StringFormat(query, "select `alt` from `guild_members` where char_id=%i LIMIT 1", CharID);
safe_delete_array(query);
if(!m_db->RunQuery(query, errbuf, &result)) {
_log(GUILDS__ERROR, "Error retrieving alt flag '%s': %s", query.c_str(), errbuf);
return false;
}
safe_delete_array(query);
if(mysql_num_rows(result) != 1)
return false;
@ -885,10 +847,11 @@ bool BaseGuildManager::GetAltFlag(uint32 CharID)
}
bool BaseGuildManager::DBSetTributeFlag(uint32 charid, bool enabled) {
char *query = 0;
return(_RunQuery(query, MakeAnyLenString(&query,
"UPDATE guild_members SET tribute_enable=%d WHERE char_id=%d",
enabled?1:0, charid), "setting a guild member's tribute flag"));
std::string query;
StringFormat(query, "UPDATE guild_members SET tribute_enable=%d WHERE char_id=%d",
enabled?1:0, charid);
return(_RunQuery(query,"setting a guild member's tribute flag"));
}
bool BaseGuildManager::DBSetPublicNote(uint32 charid, const char* note) {
@ -896,44 +859,38 @@ bool BaseGuildManager::DBSetPublicNote(uint32 charid, const char* note) {
return(false);
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
//escape our strings.
uint32 len = strlen(note);
char *esc = new char[len*2+1];
std::string esc;
m_db->DoEscapeString(esc, note, len);
//insert the new `guilds` entry
if (!m_db->RunQuery(query, MakeAnyLenString(&query,
"UPDATE guild_members SET public_note='%s' WHERE char_id=%d",
esc, charid), errbuf))
{
_log(GUILDS__ERROR, "Error setting public note for char %d '%s': %s", charid, query, errbuf);
safe_delete_array(query);
safe_delete_array(esc);
StringFormat(query,"UPDATE guild_members SET public_note='%s' WHERE char_id=%d",
esc.c_str(), charid);
if (!m_db->RunQuery(query, errbuf)) {
_log(GUILDS__ERROR, "Error setting public note for char %d '%s': %s", charid, query.c_str(), errbuf);
return(false);
}
safe_delete_array(query);
safe_delete_array(esc);
_log(GUILDS__DB, "Set public not for char %d", charid);
return(true);
}
bool BaseGuildManager::_RunQuery(char *&query, int len, const char *errmsg) {
bool BaseGuildManager::_RunQuery(const std::string query, const char *errmsg) {
if(m_db == nullptr)
return(false);
char errbuf[MYSQL_ERRMSG_SIZE];
if (!m_db->RunQuery(query, len, errbuf))
if (!m_db->RunQuery(query, errbuf))
{
_log(GUILDS__ERROR, "Error %s: '%s': %s", errmsg, query, errbuf);
safe_delete_array(query);
_log(GUILDS__ERROR, "Error %s: '%s': %s", errmsg, query.c_str(), errbuf);
return(false);
}
safe_delete_array(query);
return(true);
}
@ -986,19 +943,17 @@ bool BaseGuildManager::GetEntireGuild(uint32 guild_id, std::vector<CharGuildInfo
return(false);
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
//load up the rank info for each guild.
if (!m_db->RunQuery(query, MakeAnyLenString(&query,
GuildMemberBaseQuery " WHERE g.guild_id=%d", guild_id
), errbuf, &result)) {
_log(GUILDS__ERROR, "Error loading guild member list '%s': %s", query, errbuf);
safe_delete_array(query);
StringFormat(query,GuildMemberBaseQuery " WHERE g.guild_id=%d", guild_id);
if (!m_db->RunQuery(query, errbuf, &result)) {
_log(GUILDS__ERROR, "Error loading guild member list '%s': %s", query.c_str(), errbuf);
return(false);
}
safe_delete_array(query);
while ((row = mysql_fetch_row(result))) {
CharGuildInfo *ci = new CharGuildInfo;
@ -1019,26 +974,22 @@ bool BaseGuildManager::GetCharInfo(const char *char_name, CharGuildInfo &into) {
}
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
//escape our strings.
uint32 nl = strlen(char_name);
char *esc = new char[nl*2+1];
std::string esc;
m_db->DoEscapeString(esc, char_name, nl);
StringFormat(query, GuildMemberBaseQuery " WHERE c.name='%s'", esc.c_str());
//load up the rank info for each guild.
if (!m_db->RunQuery(query, MakeAnyLenString(&query,
GuildMemberBaseQuery " WHERE c.name='%s'", esc
), errbuf, &result)) {
_log(GUILDS__ERROR, "Error loading guild member '%s': %s", query, errbuf);
safe_delete_array(query);
safe_delete_array(esc);
if (!m_db->RunQuery(query, errbuf, &result)) {
_log(GUILDS__ERROR, "Error loading guild member '%s': %s", query.c_str(), errbuf);
return(false);
}
safe_delete_array(query);
safe_delete_array(esc);
bool ret = true;
if ((row = mysql_fetch_row(result))) {
@ -1061,23 +1012,21 @@ bool BaseGuildManager::GetCharInfo(uint32 char_id, CharGuildInfo &into) {
}
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
//load up the rank info for each guild.
if (!m_db->RunQuery(query, MakeAnyLenString(&query,
#ifdef BOTS
GuildMemberBaseQuery " WHERE c.id=%d AND c.mobtype = 'C'", char_id
StringFormat(query, GuildMemberBaseQuery " WHERE c.id=%d AND c.mobtype = 'C'", char_id);
#else
GuildMemberBaseQuery " WHERE c.id=%d", char_id
StringFormat(query, GuildMemberBaseQuery " WHERE c.id=%d", char_id);
#endif
), errbuf, &result)) {
_log(GUILDS__ERROR, "Error loading guild member '%s': %s", query, errbuf);
safe_delete_array(query);
if (!m_db->RunQuery(query, errbuf, &result)) {
_log(GUILDS__ERROR, "Error loading guild member '%s': %s", query.c_str(), errbuf);
return(false);
}
safe_delete_array(query);
bool ret = true;
if ((row = mysql_fetch_row(result))) {
@ -1317,19 +1266,17 @@ BaseGuildManager::GuildInfo::GuildInfo() {
uint32 BaseGuildManager::DoesAccountContainAGuildLeader(uint32 AccountID)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
if (!m_db->RunQuery(query,
MakeAnyLenString(&query,
"select guild_id from guild_members where char_id in (select id from character_ where account_id = %i) and rank = 2",
AccountID), errbuf, &result))
{
_log(GUILDS__ERROR, "Error executing query '%s': %s", query, errbuf);
safe_delete_array(query);
StringFormat(query, "SELECT guild_id FROM guild_members WHERE char_id in "
"(SELECT id FROM character_ WHERE account_id = %i) AND rank = 2",
AccountID);
if (!m_db->RunQuery(query, errbuf, &result)) {
_log(GUILDS__ERROR, "Error executing query '%s': %s", query.c_str(), errbuf);
return 0;
}
safe_delete_array(query);
uint32 Rows = mysql_num_rows(result);
mysql_free_result(result);
@ -1342,7 +1289,7 @@ uint32 BaseGuildManager::DoesAccountContainAGuildLeader(uint32 AccountID)
bool Database::LoadGuilds(GuildRanks_Struct* guilds) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
// int i;
MYSQL_RES *result;
MYSQL_ROW row;
@ -1377,10 +1324,11 @@ bool Database::LoadGuilds(GuildRanks_Struct* guilds) {
Sleep(0);
}
StringFormat(query, "SELECT id, eqid, name, leader, minstatus, rank0title, rank1, rank1title, rank2, "
"rank2title, rank3, rank3title, rank4, rank4title, rank5, rank5title FROM guilds");
if (RunQuery(query, MakeAnyLenString(&query, "SELECT id, eqid, name, leader, minstatus, rank0title, rank1, rank1title, rank2, rank2title, rank3, rank3title, rank4, rank4title, rank5, rank5title from guilds"), errbuf, &result)) {
if (RunQuery(query,errbuf, &result)) {
safe_delete_array(query);
uint32 guildeqid = 0xFFFFFFFF;
while ((row = mysql_fetch_row(result))) {
guildeqid = atoi(row[1]);
@ -1436,7 +1384,6 @@ bool Database::LoadGuilds(GuildRanks_Struct* guilds) {
else
{
cerr << "Error in LoadGuilds query '" << query << "' " << errbuf << endl;
safe_delete_array(query);
return false;
}
@ -1446,13 +1393,13 @@ bool Database::LoadGuilds(GuildRanks_Struct* guilds) {
void Database::SetPublicNote(uint32 guild_id,char* charname, char* note){
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
char* notebuf = new char[(strlen(note)*2)+3];
DoEscapeString(notebuf, note, strlen(note)) ;
if (!RunQuery(query, MakeAnyLenString(&query, "update character_ set publicnote='%s' where name='%s' and guild=%i", notebuf,charname,guild_id), errbuf)) {
StringFormat(query,"update character_ set publicnote='%s' where name='%s' and guild=%i", notebuf,charname,guild_id);
if (!RunQuery(query, errbuf)) {
cerr << "Error running SetPublicNote query: " << errbuf << endl;
}
safe_delete_array(query);
safe_delete_array(notebuf);
}
@ -1460,13 +1407,16 @@ void Database::SetPublicNote(uint32 guild_id,char* charname, char* note){
bool Database::GetGuildRanks(uint32 guildeqid, GuildRanks_Struct* gr) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT id, eqid, name, leader, minstatus, rank0title, rank1, rank1title, rank2, rank2title, rank3, rank3title, rank4, rank4title, rank5, rank5title from guilds where eqid=%i;", guildeqid), errbuf, &result))
StringFormat(query, "SELECT id, eqid, name, leader, minstatus, rank0title, rank1, rank1title, "
"rank2, rank2title, rank3, rank3title, rank4, rank4title, rank5, rank5title "
"FROM guilds WHERE eqid=%i;", guildeqid);
if (RunQuery(query, errbuf, &result))
{
safe_delete_array(query);
if (mysql_num_rows(result) == 1) {
row = mysql_fetch_row(result);
gr->leader = atoi(row[3]);
@ -1545,7 +1495,6 @@ bool Database::GetGuildRanks(uint32 guildeqid, GuildRanks_Struct* gr) {
}
else {
cerr << "Error in GetGuildRank query '" << query << "' " << errbuf << endl;
safe_delete_array(query);
return false;
}

2
common/guild_base.h
View File

@ -108,7 +108,7 @@ protected:
bool DBSetAltFlag(uint32 charid, bool is_alt);
bool DBSetTributeFlag(uint32 charid, bool enabled);
bool DBSetPublicNote(uint32 charid, const char *note);
bool _RunQuery(char *&query, int len, const char *errmsg);
bool _RunQuery(const std::string query, const char *errmsg);
// void DBSetPublicNote(uint32 guild_id,char* charname, char* note);
bool LocalDeleteGuild(uint32 guild_id);

71
common/ptimer.cpp
View File

@ -130,25 +130,24 @@ bool PersistentTimer::Load(Database *db) {
char errbuf[MYSQL_ERRMSG_SIZE];
MYSQL_RES *result;
MYSQL_ROW row;
char *query = 0;
std::string query;
uint32 qlen = 0;
uint32 qcount = 0;
qlen = MakeAnyLenString(&query, "SELECT start,duration,enable "
" FROM timers WHERE char_id=%lu AND type=%u", (unsigned long)_char_id, _type);
StringFormat(query, "SELECT start,duration,enable "
" FROM timers WHERE char_id=%lu AND type=%u",
(unsigned long)_char_id, _type);
#ifdef DEBUG_PTIMERS
printf("Loading timer: char %lu of type %u\n", (unsigned long)_char_id, _type);
#endif
if (!db->RunQuery(query, qlen, errbuf, &result)) {
safe_delete_array(query);
if (!db->RunQuery(query, errbuf, &result)) {
#if EQDEBUG > 5
LogFile->write(EQEMuLog::Error, "Error in PersistentTimer::Load, error: %s", errbuf);
#endif
return(false);
}
safe_delete_array(query);
bool res = false;
qcount = mysql_num_rows(result);
@ -169,55 +168,51 @@ bool PersistentTimer::Store(Database *db) {
return(true);
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
uint32 qlen = 0;
qlen = MakeAnyLenString(&query, "REPLACE INTO timers "
" (char_id,type,start,duration,enable) "
" VALUES(%lu,%u,%lu,%lu,%d)",
(unsigned long)_char_id, _type, (unsigned long)start_time, (unsigned long)timer_time, enabled?1:0);
StringFormat(query, "REPLACE INTO timers "
"(char_id, type, start, duration, enable) "
"VALUES (%lu, %u, %lu, %lu, %d) ",
(unsigned long)_char_id, _type, (unsigned long)start_time,
(unsigned long)timer_time, enabled?1:0);
#ifdef DEBUG_PTIMERS
printf("Storing timer: char %lu of type %u: '%s'\n", (unsigned long)_char_id, _type, query);
#endif
if (!db->RunQuery(query, qlen, errbuf)) {
safe_delete_array(query);
if (!db->RunQuery(query, errbuf)) {
#if EQDEBUG > 5
LogFile->write(EQEMuLog::Error, "Error in PersistentTimer::Store, error: %s", errbuf);
#endif
return(false);
}
safe_delete_array(query);
return(true);
}
bool PersistentTimer::Clear(Database *db) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
uint32 qlen = 0;
qlen = MakeAnyLenString(&query, "DELETE FROM timers "
" WHERE char_id=%lu AND type=%u ",
(unsigned long)_char_id, _type);
StringFormat(query, "DELETE FROM timers "
" WHERE char_id=%lu AND type=%u ",
(unsigned long)_char_id, _type);
#ifdef DEBUG_PTIMERS
printf("Clearing timer: char %lu of type %u: '%s'\n", (unsigned long)_char_id, _type, query);
#endif
if (!db->RunQuery(query, qlen, errbuf)) {
safe_delete_array(query);
if (!db->RunQuery(query, errbuf)) {
#if EQDEBUG > 5
LogFile->write(EQEMuLog::Error, "Error in PersistentTimer::Clear, error: %s", errbuf);
#endif
return(false);
}
safe_delete_array(query);
return(true);
}
/* This function checks if the timer triggered */
@ -312,25 +307,24 @@ bool PTimerList::Load(Database *db) {
char errbuf[MYSQL_ERRMSG_SIZE];
MYSQL_RES *result;
MYSQL_ROW row;
char *query = 0;
std::string query;
uint32 qlen = 0;
uint32 qcount = 0;
qlen = MakeAnyLenString(&query, "SELECT type,start,duration,enable "
" FROM timers WHERE char_id=%lu", (unsigned long)_char_id);
StringFormat(query, "SELECT type,start,duration,enable "
"FROM timers WHERE char_id=%lu",
(unsigned long)_char_id);
#ifdef DEBUG_PTIMERS
printf("Loading all timers for char %lu\n", (unsigned long)_char_id);
#endif
if (!db->RunQuery(query, qlen, errbuf, &result)) {
safe_delete_array(query);
if (!db->RunQuery(query, errbuf, &result)) {
#if EQDEBUG > 5
LogFile->write(EQEMuLog::Error, "Error in PersistentTimer::Load, error: %s", errbuf);
#endif
return(false);
}
safe_delete_array(query);
pTimerType type;
uint32 start_time, timer_time;
@ -382,24 +376,23 @@ bool PTimerList::Clear(Database *db) {
_list.clear();
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
uint32 qlen = 0;
qlen = MakeAnyLenString(&query, "DELETE FROM timers "
" WHERE char_id=%lu ", (unsigned long)_char_id);
StringFormat(query, "DELETE FROM timers "
"WHERE char_id=%lu ",
(unsigned long)_char_id);
#ifdef DEBUG_PTIMERS
printf("Storing all timers for char %lu: '%s'\n", (unsigned long)_char_id, query);
#endif
if (!db->RunQuery(query, qlen, errbuf)) {
safe_delete_array(query);
if (!db->RunQuery(query, errbuf)) {
#if EQDEBUG > 5
LogFile->write(EQEMuLog::Error, "Error in PersistentTimer::Clear, error: %s", errbuf);
#endif
return(false);
}
safe_delete_array(query);
return(true);
}
@ -480,23 +473,21 @@ void PTimerList::ToVector(std::vector< std::pair<pTimerType, PersistentTimer *>
bool PTimerList::ClearOffline(Database *db, uint32 char_id, pTimerType type) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
uint32 qlen = 0;
std::string query;
qlen = MakeAnyLenString(&query, "DELETE FROM timers WHERE char_id=%lu AND type=%u ",(unsigned long)char_id, type);
StringFormat(query, "DELETE FROM timers WHERE char_id=%lu AND type=%u ",
(unsigned long)char_id, type);
#ifdef DEBUG_PTIMERS
printf("Clearing timer (offline): char %lu of type %u: '%s'\n", (unsigned long)char_id, type, query);
#endif
if (!db->RunQuery(query, qlen, errbuf)) {
safe_delete_array(query);
if (!db->RunQuery(query, errbuf)) {
#if EQDEBUG > 5
LogFile->write(EQEMuLog::Error, "Error in PTimerList::ClearOffline, error: %s", errbuf);
#endif
return(false);
}
safe_delete_array(query);
return(true);

90
common/rulesys.cpp
View File

@ -267,7 +267,7 @@ void RuleManager::SaveRules(Database *db, const char *ruleset) {
bool RuleManager::LoadRules(Database *db, const char *ruleset) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
@ -282,20 +282,20 @@ bool RuleManager::LoadRules(Database *db, const char *ruleset) {
m_activeRuleset = rsid;
m_activeName = ruleset;
if (db->RunQuery(query, MakeAnyLenString(&query,
StringFormat(query,
"SELECT rule_name, rule_value"
" FROM rule_values"
" WHERE ruleset_id=%d", rsid), errbuf, &result))
" WHERE ruleset_id=%d", rsid);
if (db->RunQuery(query, errbuf, &result))
{
safe_delete_array(query);
while((row = mysql_fetch_row(result))) {
if(!SetRule(row[0], row[1], nullptr, false))
_log(RULES__ERROR, "Unable to interpret rule record for %s", row[0]);
}
mysql_free_result(result);
} else {
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in LoadRules query %s: %s", query, errbuf);
LogFile->write(EQEMuLog::Error, "Error in LoadRules query %s: %s", query.c_str(), errbuf);
return(false);
}
@ -318,44 +318,44 @@ void RuleManager::_SaveRule(Database *db, RuleType type, uint16 index) {
}
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
if (!db->RunQuery(query, MakeAnyLenString(&query,
"REPLACE INTO rule_values (ruleset_id, rule_name, rule_value) "
std::string query;
StringFormat(query,"REPLACE INTO rule_values (ruleset_id, rule_name, rule_value) "
" VALUES(%d, '%s', '%s')",
m_activeRuleset, _GetRuleName(type, index), vstr),errbuf))
m_activeRuleset, _GetRuleName(type, index), vstr);
if (!db->RunQuery(query, errbuf))
{
_log(RULES__ERROR, "Fauled to set rule in the database: %s: %s", query,errbuf);
_log(RULES__ERROR, "Fauled to set rule in the database: %s: %s", query.c_str(),errbuf);
}
safe_delete_array(query);
}
int RuleManager::GetRulesetID(Database *db, const char *rulesetname) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
uint32 len = strlen(rulesetname);
char* rst = new char[2*len+1];
std::string rst;
db->DoEscapeString(rst, rulesetname, len);
int res = -1;
if (db->RunQuery(query, MakeAnyLenString(&query,
"SELECT ruleset_id"
" FROM rule_sets"
" WHERE name='%s'", rst), errbuf, &result))
StringFormat(query,"SELECT ruleset_id"
" FROM rule_sets"
" WHERE name='%s'", rst.c_str());
if (db->RunQuery(query, errbuf, &result))
{
if((row = mysql_fetch_row(result))) {
res = atoi(row[0]);
}
mysql_free_result(result);
} else {
LogFile->write(EQEMuLog::Error, "Error in LoadRules query %s: %s", query, errbuf);
LogFile->write(EQEMuLog::Error, "Error in LoadRules query %s: %s", query.c_str(), errbuf);
}
safe_delete_array(query);
safe_delete_array(rst);
return(res);
}
@ -368,73 +368,69 @@ int RuleManager::_FindOrCreateRuleset(Database *db, const char *ruleset) {
return(res); //found and existing one...
uint32 len = strlen(ruleset);
char* rst = new char[2*len+1];
std::string rst;
db->DoEscapeString(rst, ruleset, len);
uint32 new_id;
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
if (!db->RunQuery(query, MakeAnyLenString(&query,
"INSERT INTO rule_sets (ruleset_id, name) "
" VALUES(0, '%s')",
rst),errbuf,nullptr,nullptr,&new_id))
std::string query;
StringFormat(query,"INSERT INTO rule_sets (ruleset_id, name) "
" VALUES(0, '%s')",rst.c_str());
if (!db->RunQuery(query,errbuf,nullptr,nullptr,&new_id))
{
_log(RULES__ERROR, "Fauled to create rule set in the database: %s: %s", query,errbuf);
_log(RULES__ERROR, "Failed to create rule set in the database: %s: %s", query.c_str(),errbuf);
res = -1;
} else {
res = new_id;
}
safe_delete_array(query);
return(res);
}
std::string RuleManager::GetRulesetName(Database *db, int id) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
std::string res;
if (db->RunQuery(query, MakeAnyLenString(&query,
"SELECT name"
" FROM rule_sets"
" WHERE ruleset_id=%d", id), errbuf, &result))
{
StringFormat(query,"SELECT name"
" FROM rule_sets"
" WHERE ruleset_id=%d", id);
if (db->RunQuery(query, errbuf, &result)){
if((row = mysql_fetch_row(result))) {
res = row[0];
}
mysql_free_result(result);
} else {
LogFile->write(EQEMuLog::Error, "Error in LoadRules query %s: %s", query, errbuf);
}
else {
LogFile->write(EQEMuLog::Error, "Error in LoadRules query %s: %s", query.c_str(), errbuf);
}
safe_delete_array(query);
return(res);
}
bool RuleManager::ListRulesets(Database *db, std::map<int, std::string> &into) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
//start out with the default set which is always present.
into[0] = "default";
StringFormat(query,"SELECT ruleset_id , name FROM rule_sets");
if (db->RunQuery(query, MakeAnyLenString(&query,
"SELECT ruleset_id,name"
" FROM rule_sets"), errbuf, &result))
{
if (db->RunQuery(query, errbuf, &result)) {
while((row = mysql_fetch_row(result))) {
into[ atoi(row[0]) ] = row[1];
}
mysql_free_result(result);
safe_delete_array(query);
} else {
LogFile->write(EQEMuLog::Error, "Error in ListRulesets query %s: %s", query, errbuf);
safe_delete_array(query);
}
else {
LogFile->write(EQEMuLog::Error, "Error in ListRulesets query %s: %s", query.c_str(), errbuf);
return(false);
}
return(true);

544
common/shareddb.cpp
View File

File diff suppressed because it is too large Load Diff

2
common/shareddb.h
View File

@ -41,7 +41,7 @@ public:
bool SetHideMe(uint32 account_id, uint8 hideme);
bool GetPlayerProfile(uint32 account_id, char* name, PlayerProfile_Struct* pp, Inventory* inv, ExtendedProfile_Struct *ext, char* current_zone = 0, uint32 *current_instance = 0);
bool SetPlayerProfile(uint32 account_id, uint32 charid, PlayerProfile_Struct* pp, Inventory* inv, ExtendedProfile_Struct *ext, uint32 current_zone, uint32 current_instance, uint8 MaxXTargets);
uint32 SetPlayerProfile_MQ(char** query, uint32 account_id, uint32 charid, PlayerProfile_Struct* pp, Inventory* inv, ExtendedProfile_Struct *ext, uint32 current_zone, uint32 current_instance, uint8 MaxXTargets);
uint32 SetPlayerProfile_MQ(std::string& query, uint32 account_id, uint32 charid, PlayerProfile_Struct* pp, Inventory* inv, ExtendedProfile_Struct *ext, uint32 current_zone, uint32 current_instance, uint8 MaxXTargets);
int32 DeleteStalePlayerCorpses();
int32 DeleteStalePlayerBackups();
void GetPlayerInspectMessage(char* playername, InspectMessage_Struct* message);

238
queryserv/database.cpp
View File

@ -99,21 +99,19 @@ Database::~Database()
bool Database::GetVariable(const char* varname, char* varvalue, uint16 varvalue_len) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (!RunQuery(query,MakeAnyLenString(&query, "select `value` from `variables` where `varname`='%s'", varname), errbuf, &result)) {
StringFormat(query,"select `value` from `variables` where `varname`='%s'", varname);
_log(UCS__ERROR, "Unable to get message count from database. %s %s", query, errbuf);
if (!RunQuery(query, errbuf, &result)) {
safe_delete_array(query);
_log(UCS__ERROR, "Unable to get message count from database. %s %s", query.c_str(), errbuf);
return false;
}
safe_delete_array(query);
if (mysql_num_rows(result) != 1) {
mysql_free_result(result);
@ -133,51 +131,59 @@ bool Database::GetVariable(const char* varname, char* varvalue, uint16 varvalue_
void Database::AddSpeech(const char* from, const char* to, const char* message, uint16 minstatus, uint32 guilddbid, uint8 type) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query, speechFrom, speechTo, speechMeesage;
DoEscapeString(speechFrom, from, strlen(from));
DoEscapeString(speechTo, to, strlen(to));
DoEscapeString(speechMeesage, message, strlen(message));
char *S1 = new char[strlen(from) * 2 + 1];
char *S2 = new char[strlen(to) * 2 + 1];
char *S3 = new char[strlen(message) * 2 + 1];
DoEscapeString(S1, from, strlen(from));
DoEscapeString(S2, to, strlen(to));
DoEscapeString(S3, message, strlen(message));
StringFormat(query, "INSERT INTO `qs_player_speech` SET "
"`from`='%s', `to`='%s', `message`='%s', "
"`minstatus`='%i', `guilddbid`='%i', `type`='%i'",
speechFrom.c_str(), speechTo.c_str(), speechMeesage.c_str(), minstatus, guilddbid, type);
if(!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO `qs_player_speech` SET `from`='%s', `to`='%s', `message`='%s', `minstatus`='%i', `guilddbid`='%i', `type`='%i'", S1, S2, S3, minstatus, guilddbid, type), errbuf, 0, 0)) {
if(!RunQuery(query, errbuf, 0, 0)) {
_log(NET__WORLD, "Failed Speech Entry Insert: %s", errbuf);
_log(NET__WORLD, "%s", query);
_log(NET__WORLD, "%s", query.c_str());
}
safe_delete_array(query);
safe_delete_array(S1);
safe_delete_array(S2);
safe_delete_array(S3);
}
void Database::LogPlayerTrade(QSPlayerLogTrade_Struct* QS, uint32 Items) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
uint32 lastid = 0;
if(!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO `qs_player_trade_record` SET `time`=NOW(), "
"`char1_id`='%i', `char1_pp`='%i', `char1_gp`='%i', `char1_sp`='%i', `char1_cp`='%i', `char1_items`='%i', "
"`char2_id`='%i', `char2_pp`='%i', `char2_gp`='%i', `char2_sp`='%i', `char2_cp`='%i', `char2_items`='%i'",
QS->char1_id, QS->char1_money.platinum, QS->char1_money.gold, QS->char1_money.silver, QS->char1_money.copper, QS->char1_count,
QS->char2_id, QS->char2_money.platinum, QS->char2_money.gold, QS->char2_money.silver, QS->char2_money.copper, QS->char2_count),
errbuf, 0, 0, &lastid)) {
StringFormat(query,"INSERT INTO `qs_player_trade_record` SET `time`=NOW(), "
"`char1_id`='%i', `char1_pp`='%i', `char1_gp`='%i', "
"`char1_sp`='%i', `char1_cp`='%i', `char1_items`='%i', "
"`char2_id`='%i', `char2_pp`='%i', `char2_gp`='%i', "
"`char2_sp`='%i', `char2_cp`='%i', `char2_items`='%i'",
QS->char1_id, QS->char1_money.platinum, QS->char1_money.gold,
QS->char1_money.silver, QS->char1_money.copper, QS->char1_count,
QS->char2_id, QS->char2_money.platinum, QS->char2_money.gold,
QS->char2_money.silver, QS->char2_money.copper, QS->char2_count);
if(!RunQuery(query, errbuf, nullptr, nullptr, &lastid)) {
_log(NET__WORLD, "Failed Trade Log Record Insert: %s", errbuf);
_log(NET__WORLD, "%s", query);
_log(NET__WORLD, "%s", query.c_str());
}
if(Items > 0) {
for(int i = 0; i < Items; i++) {
if(!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO `qs_player_trade_record_entries` SET `event_id`='%i', "
"`from_id`='%i', `from_slot`='%i', `to_id`='%i', `to_slot`='%i', `item_id`='%i', "
"`charges`='%i', `aug_1`='%i', `aug_2`='%i', `aug_3`='%i', `aug_4`='%i', `aug_5`='%i'",
lastid, QS->items[i].from_id, QS->items[i].from_slot, QS->items[i].to_id, QS->items[i].to_slot, QS->items[i].item_id,
QS->items[i].charges, QS->items[i].aug_1, QS->items[i].aug_2, QS->items[i].aug_3, QS->items[i].aug_4, QS->items[i].aug_5,
errbuf, 0, 0))) {
StringFormat(query, "INSERT INTO `qs_player_trade_record_entries` SET `event_id`='%i', "
"`from_id`='%i', `from_slot`='%i', `to_id`='%i', `to_slot`='%i', "
"`item_id`='%i', `charges`='%i', `aug_1`='%i', `aug_2`='%i', "
"`aug_3`='%i', `aug_4`='%i', `aug_5`='%i'",
lastid, QS->items[i].from_id, QS->items[i].from_slot, QS->items[i].to_id,
QS->items[i].to_slot, QS->items[i].item_id, QS->items[i].charges,
QS->items[i].aug_1, QS->items[i].aug_2, QS->items[i].aug_3,
QS->items[i].aug_4, QS->items[i].aug_5);
if(!RunQuery(query, errbuf, 0, 0)) {
_log(NET__WORLD, "Failed Trade Log Record Entry Insert: %s", errbuf);
_log(NET__WORLD, "%s", query);
_log(NET__WORLD, "%s", query.c_str());
}
}
}
@ -186,28 +192,36 @@ void Database::LogPlayerTrade(QSPlayerLogTrade_Struct* QS, uint32 Items) {
void Database::LogPlayerHandin(QSPlayerLogHandin_Struct* QS, uint32 Items) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
uint32 lastid = 0;
if(!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO `qs_player_handin_record` SET `time`=NOW(), `quest_id`='%i', "
"`char_id`='%i', `char_pp`='%i', `char_gp`='%i', `char_sp`='%i', `char_cp`='%i', `char_items`='%i', "
"`npc_id`='%i', `npc_pp`='%i', `npc_gp`='%i', `npc_sp`='%i', `npc_cp`='%i', `npc_items`='%i'",
QS->quest_id, QS->char_id, QS->char_money.platinum, QS->char_money.gold, QS->char_money.silver, QS->char_money.copper, QS->char_count,
QS->npc_id, QS->npc_money.platinum, QS->npc_money.gold, QS->npc_money.silver, QS->npc_money.copper, QS->npc_count),
errbuf, 0, 0, &lastid)) {
StringFormat(query,"INSERT INTO `qs_player_handin_record` SET `time`=NOW(), `quest_id`='%i', "
"`char_id`='%i', `char_pp`='%i', `char_gp`='%i', `char_sp`='%i', "
"`char_cp`='%i', `char_items`='%i', `npc_id`='%i', `npc_pp`='%i', "
"`npc_gp`='%i', `npc_sp`='%i', `npc_cp`='%i', `npc_items`='%i'",
QS->quest_id, QS->char_id, QS->char_money.platinum, QS->char_money.gold,
QS->char_money.silver, QS->char_money.copper, QS->char_count,
QS->npc_id, QS->npc_money.platinum, QS->npc_money.gold, QS->npc_money.silver,
QS->npc_money.copper, QS->npc_count);
if(!RunQuery(query, errbuf, 0, 0, &lastid)) {
_log(NET__WORLD, "Failed Handin Log Record Insert: %s", errbuf);
_log(NET__WORLD, "%s", query);
_log(NET__WORLD, "%s", query.c_str());
}
if(Items > 0) {
for(int i = 0; i < Items; i++) {
if(!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO `qs_player_handin_record_entries` SET `event_id`='%i', "
"`action_type`='%s', `char_slot`='%i', `item_id`='%i', `charges`='%i', "
"`aug_1`='%i', `aug_2`='%i', `aug_3`='%i', `aug_4`='%i', `aug_5`='%i'",
lastid, QS->items[i].action_type, QS->items[i].char_slot, QS->items[i].item_id, QS->items[i].charges,
QS->items[i].aug_1, QS->items[i].aug_2, QS->items[i].aug_3, QS->items[i].aug_4, QS->items[i].aug_5,
errbuf, 0, 0))) {
StringFormat(query, "INSERT INTO `qs_player_handin_record_entries` SET `event_id`='%i', "
"`action_type`='%s', `char_slot`='%i', `item_id`='%i', `charges`='%i', "
"`aug_1`='%i', `aug_2`='%i', `aug_3`='%i', `aug_4`='%i', `aug_5`='%i'",
lastid, QS->items[i].action_type, QS->items[i].char_slot,
QS->items[i].item_id, QS->items[i].charges, QS->items[i].aug_1,
QS->items[i].aug_2, QS->items[i].aug_3, QS->items[i].aug_4, QS->items[i].aug_5);
if(!RunQuery(query, errbuf, 0, 0)) {
_log(NET__WORLD, "Failed Handin Log Record Entry Insert: %s", errbuf);
_log(NET__WORLD, "%s", query);
_log(NET__WORLD, "%s", query.c_str());
}
}
}
@ -215,18 +229,28 @@ void Database::LogPlayerHandin(QSPlayerLogHandin_Struct* QS, uint32 Items) {
void Database::LogPlayerNPCKill(QSPlayerLogNPCKill_Struct* QS, uint32 Members){
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
uint32 lastid = 0;
if(!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO `qs_player_npc_kill_record` SET `npc_id`='%i', `type`='%i', `zone_id`='%i', `time`=NOW()", QS->s1.NPCID, QS->s1.Type, QS->s1.ZoneID), errbuf, 0, 0, &lastid)) {
StringFormat(query,"INSERT INTO `qs_player_npc_kill_record` SET `npc_id`='%i', "
"`type`='%i', `zone_id`='%i', `time`=NOW()",
QS->s1.NPCID, QS->s1.Type, QS->s1.ZoneID);
if(!RunQuery(query, errbuf, nullptr, nullptr, &lastid)) {
_log(NET__WORLD, "Failed NPC Kill Log Record Insert: %s", errbuf);
_log(NET__WORLD, "%s", query);
_log(NET__WORLD, "%s", query.c_str());
}
if(Members > 0){
for (int i = 0; i < Members; i++) {
if(!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO `qs_player_npc_kill_record_entries` SET `event_id`='%i', `char_id`='%i'", lastid, QS->Chars[i].char_id, errbuf, 0, 0))) {
StringFormat(query, "INSERT INTO `qs_player_npc_kill_record_entries` SET "
"`event_id`='%i', `char_id`='%i'",
lastid, QS->Chars[i].char_id);
if(!RunQuery(query, errbuf, nullptr, nullptr)) {
_log(NET__WORLD, "Failed NPC Kill Log Entry Insert: %s", errbuf);
_log(NET__WORLD, "%s", query);
_log(NET__WORLD, "%s", query.c_str());
}
}
}
@ -235,26 +259,31 @@ void Database::LogPlayerNPCKill(QSPlayerLogNPCKill_Struct* QS, uint32 Members){
void Database::LogPlayerDelete(QSPlayerLogDelete_Struct* QS, uint32 Items) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
uint32 lastid = 0;
if(!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO `qs_player_delete_record` SET `time`=NOW(), "
"`char_id`='%i', `stack_size`='%i', `char_items`='%i'",
QS->char_id, QS->stack_size, QS->char_count, QS->char_count),
errbuf, 0, 0, &lastid)) {
StringFormat(query, "INSERT INTO `qs_player_delete_record` SET `time`=NOW(), "
"`char_id`='%i', `stack_size`='%i', `char_items`='%i'",
QS->char_id, QS->stack_size, QS->char_count, QS->char_count);
if(!RunQuery(query, errbuf, nullptr, nullptr, &lastid)) {
_log(NET__WORLD, "Failed Delete Log Record Insert: %s", errbuf);
_log(NET__WORLD, "%s", query);
_log(NET__WORLD, "%s", query.c_str());
}
if(Items > 0) {
for(int i = 0; i < Items; i++) {
if(!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO `qs_player_delete_record_entries` SET `event_id`='%i', "
"`char_slot`='%i', `item_id`='%i', `charges`='%i', `aug_1`='%i', "
"`aug_2`='%i', `aug_3`='%i', `aug_4`='%i', `aug_5`='%i'",
lastid, QS->items[i].char_slot, QS->items[i].item_id, QS->items[i].charges, QS->items[i].aug_1,
QS->items[i].aug_2, QS->items[i].aug_3, QS->items[i].aug_4, QS->items[i].aug_5,
errbuf, 0, 0))) {
StringFormat(query,"INSERT INTO `qs_player_delete_record_entries` SET `event_id`='%i', "
"`char_slot`='%i', `item_id`='%i', `charges`='%i', `aug_1`='%i', "
"`aug_2`='%i', `aug_3`='%i', `aug_4`='%i', `aug_5`='%i'",
lastid, QS->items[i].char_slot, QS->items[i].item_id,
QS->items[i].charges, QS->items[i].aug_1,QS->items[i].aug_2,
QS->items[i].aug_3, QS->items[i].aug_4, QS->items[i].aug_5);
if(!RunQuery(query, errbuf, nullptr, nullptr)) {
_log(NET__WORLD, "Failed Delete Log Record Entry Insert: %s", errbuf);
_log(NET__WORLD, "%s", query);
_log(NET__WORLD, "%s", query.c_str());
}
}
}
@ -263,26 +292,33 @@ void Database::LogPlayerDelete(QSPlayerLogDelete_Struct* QS, uint32 Items) {
void Database::LogPlayerMove(QSPlayerLogMove_Struct* QS, uint32 Items) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
uint32 lastid = 0;
if(!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO `qs_player_move_record` SET `time`=NOW(), "
"`char_id`='%i', `from_slot`='%i', `to_slot`='%i', `stack_size`='%i', `char_items`='%i', `postaction`='%i'",
QS->char_id, QS->from_slot, QS->to_slot, QS->stack_size, QS->char_count, QS->postaction),
errbuf, 0, 0, &lastid)) {
StringFormat(query, "INSERT INTO `qs_player_move_record` SET `time`=NOW(), "
"`char_id`='%i', `from_slot`='%i', `to_slot`='%i', "
"`stack_size`='%i', `char_items`='%i', `postaction`='%i'",
QS->char_id, QS->from_slot, QS->to_slot, QS->stack_size,
QS->char_count, QS->postaction);
if(!RunQuery(query, errbuf, 0, 0, &lastid)) {
_log(NET__WORLD, "Failed Move Log Record Insert: %s", errbuf);
_log(NET__WORLD, "%s", query);
_log(NET__WORLD, "%s", query.c_str());
}
if(Items > 0) {
for(int i = 0; i < Items; i++) {
if(!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO `qs_player_move_record_entries` SET `event_id`='%i', "
"`from_slot`='%i', `to_slot`='%i', `item_id`='%i', `charges`='%i', "
"`aug_1`='%i', `aug_2`='%i', `aug_3`='%i', `aug_4`='%i', `aug_5`='%i'", lastid,
QS->items[i].from_slot, QS->items[i].to_slot, QS->items[i].item_id, QS->items[i].charges,
QS->items[i].aug_1, QS->items[i].aug_2, QS->items[i].aug_3, QS->items[i].aug_4, QS->items[i].aug_5,
errbuf, 0, 0))) {
StringFormat(query,"INSERT INTO `qs_player_move_record_entries` SET `event_id`='%i', "
"`from_slot`='%i', `to_slot`='%i', `item_id`='%i', `charges`='%i', "
"`aug_1`='%i', `aug_2`='%i', `aug_3`='%i', `aug_4`='%i', `aug_5`='%i'",
lastid, QS->items[i].from_slot, QS->items[i].to_slot, QS->items[i].item_id,
QS->items[i].charges, QS->items[i].aug_1, QS->items[i].aug_2, QS->items[i].aug_3,
QS->items[i].aug_4, QS->items[i].aug_5);
if(!RunQuery(query, errbuf, nullptr, nullptr)) {
_log(NET__WORLD, "Failed Move Log Record Entry Insert: %s", errbuf);
_log(NET__WORLD, "%s", query);
_log(NET__WORLD, "%s", query.c_str());
}
}
}
@ -292,28 +328,38 @@ void Database::LogMerchantTransaction(QSMerchantLogTransaction_Struct* QS, uint3
// Merchant transactions are from the perspective of the merchant, not the player -U
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
uint32 lastid = 0;
if(!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO `qs_merchant_transaction_record` SET `time`=NOW(), "
"`zone_id`='%i', `merchant_id`='%i', `merchant_pp`='%i', `merchant_gp`='%i', `merchant_sp`='%i', `merchant_cp`='%i', `merchant_items`='%i', "
"`char_id`='%i', `char_pp`='%i', `char_gp`='%i', `char_sp`='%i', `char_cp`='%i', `char_items`='%i'",
QS->zone_id, QS->merchant_id, QS->merchant_money.platinum, QS->merchant_money.gold, QS->merchant_money.silver, QS->merchant_money.copper, QS->merchant_count,
QS->char_id, QS->char_money.platinum, QS->char_money.gold, QS->char_money.silver, QS->char_money.copper, QS->char_count),
errbuf, 0, 0, &lastid)) {
StringFormat(query,"INSERT INTO `qs_merchant_transaction_record` SET `time`=NOW(), "
"`zone_id`='%i', `merchant_id`='%i', `merchant_pp`='%i', "
"`merchant_gp`='%i', `merchant_sp`='%i', `merchant_cp`='%i', "
"`merchant_items`='%i', `char_id`='%i', `char_pp`='%i', "
"`char_gp`='%i', `char_sp`='%i', `char_cp`='%i', `char_items`='%i'",
QS->zone_id, QS->merchant_id, QS->merchant_money.platinum,
QS->merchant_money.gold, QS->merchant_money.silver,
QS->merchant_money.copper, QS->merchant_count,
QS->char_id, QS->char_money.platinum, QS->char_money.gold,
QS->char_money.silver, QS->char_money.copper, QS->char_count);
if(!RunQuery(query, errbuf, 0, 0, &lastid)) {
_log(NET__WORLD, "Failed Transaction Log Record Insert: %s", errbuf);
_log(NET__WORLD, "%s", query);
_log(NET__WORLD, "%s", query.c_str());
}
if(Items > 0) {
for(int i = 0; i < Items; i++) {
if(!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO `qs_merchant_transaction_record_entries` SET `event_id`='%i', "
"`char_slot`='%i', `item_id`='%i', `charges`='%i', `aug_1`='%i', "
"`aug_2`='%i', `aug_3`='%i', `aug_4`='%i', `aug_5`='%i'",
lastid, QS->items[i].char_slot, QS->items[i].item_id, QS->items[i].charges, QS->items[i].aug_1,
QS->items[i].aug_2, QS->items[i].aug_3, QS->items[i].aug_4, QS->items[i].aug_5,
errbuf, 0, 0))) {
StringFormat(query,"INSERT INTO `qs_merchant_transaction_record_entries` SET `event_id`='%i', "
"`char_slot`='%i', `item_id`='%i', `charges`='%i', `aug_1`='%i', "
"`aug_2`='%i', `aug_3`='%i', `aug_4`='%i', `aug_5`='%i'",
lastid, QS->items[i].char_slot, QS->items[i].item_id, QS->items[i].charges,
QS->items[i].aug_1, QS->items[i].aug_2, QS->items[i].aug_3, QS->items[i].aug_4,
QS->items[i].aug_5);
if(!RunQuery(query, errbuf, 0, 0)) {
_log(NET__WORLD, "Failed Transaction Log Record Entry Insert: %s", errbuf);
_log(NET__WORLD, "%s", query);
_log(NET__WORLD, "%s", query.c_str());
}
}
}

68
queryserv/lfguild.cpp
View File

@ -35,19 +35,20 @@ GuildLookingForPlayers::GuildLookingForPlayers(char *Name, char *Comments, uint3
bool LFGuildManager::LoadDatabase()
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
if (!database.RunQuery(query,MakeAnyLenString(&query, "SELECT `type`,`name`,`comment`, `fromlevel`, `tolevel`, `classes`, `aacount`, `timezone`, `timeposted` FROM `lfguild`"),errbuf,&result)){
std::string query = "SELECT `type`,`name`,`comment`, `fromlevel`, "
"`tolevel`, `classes`, `aacount`, `timezone`, "
"`timeposted` FROM `lfguild`";
_log(QUERYSERV__ERROR, "Failed to load LFGuild info from database. %s %s", query, errbuf);
safe_delete_array(query);
if (!database.RunQuery(query,errbuf,&result)){
_log(QUERYSERV__ERROR, "Failed to load LFGuild info from database. %s %s", query.c_str(), errbuf);
return false;
}
safe_delete_array(query);
while((row = mysql_fetch_row(result))) {
@ -243,7 +244,7 @@ void LFGuildManager::SendGuildMatches(uint32 FromZoneID, uint32 FromInstanceID,
void LFGuildManager::TogglePlayer(uint32 FromZoneID, uint32 FromInstanceID, char *From, uint32 Class, uint32 Level, uint32 AAPoints, char *Comments, uint32 Toggle, uint32 TimeZone)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
std::list<PlayerLookingForGuild>::iterator it;
@ -257,10 +258,11 @@ void LFGuildManager::TogglePlayer(uint32 FromZoneID, uint32 FromInstanceID, char
}
}
if(!database.RunQuery(query, MakeAnyLenString(&query, "DELETE FROM `lfguild` WHERE `type` = 0 AND `name` = '%s'", From), errbuf, 0, 0))
_log(QUERYSERV__ERROR, "Error removing player from LFGuild table, query was %s, %s", query, errbuf);
StringFormat(query,"DELETE FROM `lfguild` WHERE `type` = 0 AND `name` = '%s'", From);
if(!database.RunQuery(query, errbuf, 0, 0))
_log(QUERYSERV__ERROR, "Error removing player from LFGuild table, query was %s, %s", query.c_str(), errbuf);
safe_delete_array(query);
uint32 Now = time(nullptr);
@ -268,10 +270,14 @@ void LFGuildManager::TogglePlayer(uint32 FromZoneID, uint32 FromInstanceID, char
{
PlayerLookingForGuild p(From, Comments, Level, Class, AAPoints, TimeZone, Now);
Players.push_back(p);
if(!database.RunQuery(query, MakeAnyLenString(&query, "INSERT INTO `lfguild` (`type`, `name`, `comment`, `fromlevel`, `tolevel`, `classes`, `aacount`, `timezone`, `timeposted`) VALUES(0, '%s', '%s', %u, 0, %u, %u, %u, %u)", From, Comments, Level, Class, AAPoints, TimeZone, Now), errbuf, 0, 0))
_log(QUERYSERV__ERROR, "Error inserting player into LFGuild table, query was %s, %s", query, errbuf);
safe_delete_array(query);
StringFormat(query,"INSERT INTO `lfguild` (`type`, `name`, `comment`, `fromlevel`, "
"`tolevel`, `classes`, `aacount`, `timezone`, `timeposted`) "
"VALUES(0, '%s', '%s', %u, 0, %u, %u, %u, %u)",
From, Comments, Level, Class, AAPoints, TimeZone, Now);
if(!database.RunQuery(query, errbuf, nullptr, nullptr))
_log(QUERYSERV__ERROR, "Error inserting player into LFGuild table, query was %s, %s", query.c_str(), errbuf);
}
@ -295,7 +301,7 @@ void LFGuildManager::TogglePlayer(uint32 FromZoneID, uint32 FromInstanceID, char
void LFGuildManager::ToggleGuild(uint32 FromZoneID, uint32 FromInstanceID, char *From, char* GuildName, char *Comments, uint32 FromLevel, uint32 ToLevel, uint32 Classes, uint32 AACount, uint32 Toggle, uint32 TimeZone)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
std::list<GuildLookingForPlayers>::iterator it;
@ -308,10 +314,11 @@ void LFGuildManager::ToggleGuild(uint32 FromZoneID, uint32 FromInstanceID, char
}
}
if(!database.RunQuery(query, MakeAnyLenString(&query, "DELETE FROM `lfguild` WHERE `type` = 1 AND `name` = '%s'", GuildName), errbuf, 0, 0))
_log(QUERYSERV__ERROR, "Error removing guild from LFGuild table, query was %s, %s", query, errbuf);
StringFormat(query,"DELETE FROM `lfguild` WHERE `type` = 1 AND `name` = '%s'", GuildName);
if(!database.RunQuery(query, errbuf, 0, 0))
_log(QUERYSERV__ERROR, "Error removing guild from LFGuild table, query was %s, %s", query.c_str(), errbuf);
safe_delete_array(query);
uint32 Now = time(nullptr);
@ -319,10 +326,16 @@ void LFGuildManager::ToggleGuild(uint32 FromZoneID, uint32 FromInstanceID, char
{
GuildLookingForPlayers g(GuildName, Comments, FromLevel, ToLevel, Classes, AACount, TimeZone, Now);
Guilds.push_back(g);
if(!database.RunQuery(query, MakeAnyLenString(&query, "INSERT INTO `lfguild` (`type`, `name`, `comment`, `fromlevel`, `tolevel`, `classes`, `aacount`, `timezone`, `timeposted`) VALUES(1, '%s', '%s', %u, %u, %u, %u, %u, %u)", GuildName, Comments, FromLevel, ToLevel, Classes, AACount, TimeZone, Now), errbuf, 0, 0))
_log(QUERYSERV__ERROR, "Error inserting guild into LFGuild table, query was %s, %s", query, errbuf);
safe_delete_array(query);
StringFormat(query,"INSERT INTO `lfguild` (`type`, `name`, `comment`, `fromlevel`, "
"`tolevel`, `classes`, `aacount`, `timezone`, `timeposted`) "
"VALUES(1, '%s', '%s', %u, %u, %u, %u, %u, %u)",
GuildName, Comments, FromLevel, ToLevel, Classes,
AACount, TimeZone, Now);
if(!database.RunQuery(query, errbuf, 0, 0))
_log(QUERYSERV__ERROR, "Error inserting guild into LFGuild table, query was %s, %s", query.c_str(), errbuf);
}
ServerPacket *pack = new ServerPacket(ServerOP_LFGuildUpdate, strlen(GuildName) + strlen(Comments) + 30);
@ -344,7 +357,7 @@ void LFGuildManager::ToggleGuild(uint32 FromZoneID, uint32 FromInstanceID, char
void LFGuildManager::ExpireEntries()
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
std::list<PlayerLookingForGuild>::iterator it;
std::list<GuildLookingForPlayers>::iterator it2;
@ -353,10 +366,12 @@ void LFGuildManager::ExpireEntries()
{
if((*it).TimePosted + 604800 <= (uint32)time(nullptr))
{
if(!database.RunQuery(query, MakeAnyLenString(&query, "DELETE from `lfguild` WHERE `type` = 0 AND `name` = '%s'", (*it).Name.c_str()), errbuf, 0, 0))
_log(QUERYSERV__ERROR, "Error expiring player LFGuild entry, query was %s, %s", query, errbuf);
safe_delete_array(query);
StringFormat(query, "DELETE from `lfguild` WHERE `type` = 0 AND `name` = '%s'", (*it).Name.c_str());
if(!database.RunQuery(query, errbuf, 0, 0))
_log(QUERYSERV__ERROR, "Error expiring player LFGuild entry, query was %s, %s", query.c_str(), errbuf);
it = Players.erase(it);
}
@ -366,10 +381,11 @@ void LFGuildManager::ExpireEntries()
{
if((*it2).TimePosted + 2592000 <= time(nullptr))
{
if(!database.RunQuery(query, MakeAnyLenString(&query, "DELETE from `lfguild` WHERE `type` = 1 AND `name` = '%s'", (*it2).Name.c_str()), errbuf, 0, 0))
_log(QUERYSERV__ERROR, "Error removing guild LFGuild entry, query was %s, %s", query, errbuf);
StringFormat(query, "DELETE from `lfguild` WHERE `type` = 1 AND `name` = '%s'", (*it2).Name.c_str());
if(!database.RunQuery(query, errbuf, 0, 0))
_log(QUERYSERV__ERROR, "Error removing guild LFGuild entry, query was %s, %s", query.c_str(), errbuf);
safe_delete_array(query);
it2 = Guilds.erase(it2);
}

251
ucs/database.cpp
View File

@ -105,21 +105,22 @@ Database::~Database()
void Database::GetAccountStatus(Client *c) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (!RunQuery(query,MakeAnyLenString(&query, "select `status`, `hideme`, `karma`, `revoked` from `account` where `id`='%i' limit 1",
c->GetAccountID()),errbuf,&result)){
StringFormat(query, "select `status`, `hideme`, `karma`, `revoked` from `account` "
"where `id`='%i' limit 1",
c->GetAccountID());
if (!RunQuery(query,errbuf,&result)){
_log(UCS__ERROR, "Unable to get account status for character %s, error %s", c->GetName().c_str(), errbuf);
safe_delete_array(query);
return;
}
_log(UCS__TRACE, "GetAccountStatus Query: %s", query);
safe_delete_array(query);
_log(UCS__TRACE, "GetAccountStatus Query: %s", query.c_str());
if(mysql_num_rows(result) != 1)
{
@ -144,20 +145,21 @@ int Database::FindAccount(const char *CharacterName, Client *c) {
_log(UCS__TRACE, "FindAccount for character %s", CharacterName);
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
c->ClearCharacters();
if (!RunQuery(query,MakeAnyLenString(&query, "select `id`, `account_id`, `level` from `character_` where `name`='%s' limit 1",
CharacterName),errbuf,&result))
StringFormat(query, "select `id`, `account_id`, `level` from "
"`character_` where `name`='%s' limit 1",
CharacterName);
if (!RunQuery(query,errbuf,&result))
{
_log(UCS__ERROR, "FindAccount query failed: %s", query);
safe_delete_array(query);
_log(UCS__ERROR, "FindAccount query failed: %s", query.c_str());
return -1;
}
safe_delete_array(query);
if (mysql_num_rows(result) != 1)
{
@ -173,13 +175,15 @@ int Database::FindAccount(const char *CharacterName, Client *c) {
mysql_free_result(result);
_log(UCS__TRACE, "Account ID for %s is %i", CharacterName, AccountID);
if (!RunQuery(query,MakeAnyLenString(&query, "select `id`, `name`, `level` from `character_` where `account_id`=%i and `name` !='%s'",
AccountID, CharacterName),errbuf,&result))
StringFormat(query,"select `id`, `name`, `level` from "
"`character_` where `account_id`=%i "
"and `name` !='%s'",
AccountID, CharacterName);
if (!RunQuery(query,errbuf,&result))
{
safe_delete_array(query);
return AccountID;
}
safe_delete_array(query);
for(unsigned int i = 0; i < mysql_num_rows(result); i++)
{
@ -193,21 +197,20 @@ int Database::FindAccount(const char *CharacterName, Client *c) {
bool Database::VerifyMailKey(std::string CharacterName, int IPAddress, std::string MailKey) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (!RunQuery(query,MakeAnyLenString(&query, "select `mailkey` from `character_` where `name`='%s' limit 1",
CharacterName.c_str()),errbuf,&result)){
StringFormat(query,"select `mailkey` from `character_` where `name`='%s' limit 1",
CharacterName.c_str());
safe_delete_array(query);
if (!RunQuery(query,errbuf,&result)){
_log(UCS__ERROR, "Error retrieving mailkey from database: %s", errbuf);
return false;
}
safe_delete_array(query);
row = mysql_fetch_row(result);
@ -234,24 +237,24 @@ bool Database::VerifyMailKey(std::string CharacterName, int IPAddress, std::stri
int Database::FindCharacter(const char *CharacterName) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
char *SafeCharName = RemoveApostrophes(CharacterName);
if (!RunQuery(query,MakeAnyLenString(&query, "select `id` from `character_` where `name`='%s' limit 1",
SafeCharName),errbuf,&result)){
StringFormat(query,"select `id` from `character_` where `name`='%s' limit 1",
SafeCharName);
_log(UCS__ERROR, "FindCharacter failed. %s %s", query, errbuf);
if (!RunQuery(query,errbuf,&result)){
_log(UCS__ERROR, "FindCharacter failed. %s %s", query.c_str(), errbuf);
safe_delete_array(query);
safe_delete_array(SafeCharName);
return -1;
}
safe_delete_array(query);
safe_delete_array(SafeCharName);
if (mysql_num_rows(result) != 1) {
@ -276,21 +279,19 @@ int Database::FindCharacter(const char *CharacterName) {
bool Database::GetVariable(const char* varname, char* varvalue, uint16 varvalue_len) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
StringFormat(query,"select `value` from `variables` where `varname`='%s'", varname);
if (!RunQuery(query,MakeAnyLenString(&query, "select `value` from `variables` where `varname`='%s'", varname), errbuf, &result)) {
if (!RunQuery(query, errbuf, &result)) {
_log(UCS__ERROR, "Unable to get message count from database. %s %s", query, errbuf);
safe_delete_array(query);
_log(UCS__ERROR, "Unable to get message count from database. %s %s", query.c_str(), errbuf);
return false;
}
safe_delete_array(query);
if (mysql_num_rows(result) != 1) {
mysql_free_result(result);
@ -312,19 +313,18 @@ bool Database::LoadChatChannels() {
_log(UCS__INIT, "Loading chat channels from the database.");
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
if (!RunQuery(query,MakeAnyLenString(&query, "select `name`,`owner`,`password`, `minstatus` from `chatchannels`"),errbuf,&result)){
std::string query = "select `name`,`owner`,`password`, `minstatus` from `chatchannels`";
_log(UCS__ERROR, "Failed to load channels. %s %s", query, errbuf);
safe_delete_array(query);
if (!RunQuery(query,errbuf,&result)){
_log(UCS__ERROR, "Failed to load channels. %s %s", query.c_str(), errbuf);
return false;
}
safe_delete_array(query);
while((row = mysql_fetch_row(result))) {
@ -345,16 +345,16 @@ void Database::SetChannelPassword(std::string ChannelName, std::string Password)
_log(UCS__TRACE, "Database::SetChannelPassword(%s, %s)", ChannelName.c_str(), Password.c_str());
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
if(!RunQuery(query, MakeAnyLenString(&query, "UPDATE `chatchannels` set `password`='%s' where `name`='%s'", Password.c_str(),
ChannelName.c_str()), errbuf)) {
StringFormat(query,"UPDATE `chatchannels` set `password`='%s' where `name`='%s'",
Password.c_str(), ChannelName.c_str());
_log(UCS__ERROR, "Error updating password in database: %s, %s", query, errbuf);
if(!RunQuery(query, errbuf)) {
_log(UCS__ERROR, "Error updating password in database: %s, %s", query.c_str(), errbuf);
}
safe_delete_array(query);
}
void Database::SetChannelOwner(std::string ChannelName, std::string Owner) {
@ -362,16 +362,16 @@ void Database::SetChannelOwner(std::string ChannelName, std::string Owner) {
_log(UCS__TRACE, "Database::SetChannelOwner(%s, %s)", ChannelName.c_str(), Owner.c_str());
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
if(!RunQuery(query, MakeAnyLenString(&query, "UPDATE `chatchannels` set `owner`='%s' where `name`='%s'", Owner.c_str(),
ChannelName.c_str()), errbuf)) {
StringFormat(query, "UPDATE `chatchannels` set `owner`='%s' where `name`='%s'",
Owner.c_str(), ChannelName.c_str());
_log(UCS__ERROR, "Error updating Owner in database: %s, %s", query, errbuf);
if(!RunQuery(query, errbuf)) {
_log(UCS__ERROR, "Error updating Owner in database: %s, %s", query.c_str(), errbuf);
}
safe_delete_array(query);
}
void Database::SendHeaders(Client *c) {
@ -384,22 +384,20 @@ void Database::SendHeaders(Client *c) {
if(CharacterID <= 0)
return;
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (!RunQuery(query,MakeAnyLenString(&query, "select `msgid`,`timestamp`,`from`,`subject`, `status` from `mail` "
"where `charid`=%i", CharacterID),errbuf,&result)){
StringFormat(query, "select `msgid`,`timestamp`,`from`,`subject`, `status` "
"from `mail` where `charid`=%i",
CharacterID);
safe_delete_array(query);
if (!RunQuery(query,errbuf,&result)){
return ;
}
safe_delete_array(query);
char Buf[100];
my_ulonglong NumRows = mysql_num_rows(result);
@ -490,18 +488,18 @@ void Database::SendBody(Client *c, int MessageNumber) {
return;
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (!RunQuery(query,MakeAnyLenString(&query, "select `msgid`, `body`, `to` from `mail` "
"where `charid`=%i and `msgid`=%i", CharacterID, MessageNumber), errbuf, &result)){
safe_delete_array(query);
StringFormat(query,"select `msgid`, `body`, `to` from `mail` "
"where `charid`=%i and `msgid`=%i",
CharacterID, MessageNumber);
if (!RunQuery(query,errbuf, &result)) {
return ;
}
safe_delete_array(query);
if (mysql_num_rows(result) != 1) {
@ -568,38 +566,31 @@ bool Database::SendMail(std::string Recipient, std::string From, std::string Sub
if(CharacterID <= 0) return false;
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query,escSubject,escBody;
char *EscSubject = new char[Subject.length() * 2 + 1];
char *EscBody = new char[Body.length() * 2 + 1];
DoEscapeString(escSubject, Subject.c_str(), Subject.length());
DoEscapeString(escBody, Body.c_str(), Body.length());
DoEscapeString(EscSubject, Subject.c_str(), Subject.length());
DoEscapeString(EscBody, Body.c_str(), Body.length());
const char *MailQuery="INSERT INTO `mail` (`charid`, `timestamp`, `from`, `subject`, `body`, `to`, `status`) "
"VALUES ('%i', %i, '%s', '%s', '%s', '%s', %i)";
uint32 LastMsgID;
int Now = time(nullptr); // time returns a 64 bit int on Windows at least, which vsnprintf doesn't like.
if(!RunQuery(query, MakeAnyLenString(&query, MailQuery, CharacterID, Now, From.c_str(), EscSubject, EscBody,
RecipientsString.c_str(), 1), errbuf, 0, 0, &LastMsgID)) {
StringFormat(query,"INSERT INTO `mail` (`charid`, `timestamp`, `from`, "
"`subject`, `body`, `to`, `status`) "
"VALUES ('%i', %i, '%s', '%s', '%s', '%s', %i)",
CharacterID, Now, From.c_str(), escSubject.c_str(), escBody.c_str(),
RecipientsString.c_str(), 1);
_log(UCS__ERROR, "SendMail: Query %s failed with error %s", query, errbuf);
if(!RunQuery(query, errbuf, nullptr, nullptr, &LastMsgID)) {
safe_delete_array(EscSubject);
safe_delete_array(EscBody);
safe_delete_array(query);
_log(UCS__ERROR, "SendMail: Query %s failed with error %s", query.c_str(), errbuf);
return false;
}
_log(UCS__TRACE, "MessageID %i generated, from %s, to %s", LastMsgID, From.c_str(), Recipient.c_str());
safe_delete_array(EscSubject);
safe_delete_array(EscBody);
safe_delete_array(query);
Client *c = CL->IsCharacterOnline(CharacterName);
@ -619,17 +610,24 @@ void Database::SetMessageStatus(int MessageNumber, int Status) {
_log(UCS__TRACE, "SetMessageStatus %i %i", MessageNumber, Status);
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
if(Status == 0)
RunQuery(query, MakeAnyLenString(&query, "delete from `mail` where `msgid`=%i", MessageNumber), errbuf);
else if (!RunQuery(query, MakeAnyLenString(&query, "update `mail` set `status`=%i where `msgid`=%i", Status, MessageNumber), errbuf)) {
{
StringFormat(query, "delete from `mail` where `msgid`=%i", MessageNumber);
_log(UCS__ERROR, "Error updating status %s, %s", query, errbuf);
RunQuery(query, errbuf);
}
else
{
StringFormat(query, "update `mail` set `status`=%i where `msgid`=%i",
Status, MessageNumber);
if (!RunQuery(query, errbuf)) {
_log(UCS__ERROR, "Error updating status %s, %s", query.c_str(), errbuf);
}
}
safe_delete_array(query);
}
void Database::ExpireMail() {
@ -637,18 +635,16 @@ void Database::ExpireMail() {
_log(UCS__INIT, "Expiring mail...");
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
uint32 AffectedRows;
if (!RunQuery(query,MakeAnyLenString(&query, "select COUNT(*) from `mail` "),errbuf,&result)){
_log(UCS__ERROR, "Unable to get message count from database. %s %s", query, errbuf);
safe_delete_array(query);
std::string query ="select COUNT(*) from `mail` ";
if (!RunQuery(query,errbuf,&result)){
_log(UCS__ERROR, "Unable to get message count from database. %s %s", query.c_str(), errbuf);
return ;
}
safe_delete_array(query);
row = mysql_fetch_row(result);
@ -658,94 +654,93 @@ void Database::ExpireMail() {
// Expire Trash
if(RuleI(Mail, ExpireTrash) >= 0) {
if(RunQuery(query, MakeAnyLenString(&query, "delete from `mail` where `status`=4 and `timestamp` < %i",
time(nullptr) - RuleI(Mail, ExpireTrash)), errbuf, 0, &AffectedRows)) {
StringFormat(query,"delete from `mail` where `status`=4 and `timestamp` < %i",
time(nullptr) - RuleI(Mail, ExpireTrash));
if(RunQuery(query, errbuf, 0, &AffectedRows)) {
_log(UCS__INIT, "Expired %i trash messages.", AffectedRows);
}
else {
_log(UCS__ERROR, "Error expiring trash messages, %s %s", query, errbuf);
_log(UCS__ERROR, "Error expiring trash messages, %s %s", query.c_str(), errbuf);
}
safe_delete_array(query);
}
// Expire Read
if(RuleI(Mail, ExpireRead) >= 0) {
if(RunQuery(query, MakeAnyLenString(&query, "delete from `mail` where `status`=3 and `timestamp` < %i",
time(nullptr) - RuleI(Mail, ExpireRead)), errbuf, 0, &AffectedRows)) {
StringFormat(query,"delete from `mail` where `status`=3 and `timestamp` < %i",
time(nullptr) - RuleI(Mail, ExpireRead));
if(RunQuery(query, errbuf, 0, &AffectedRows)) {
_log(UCS__INIT, "Expired %i read messages.", AffectedRows);
}
else {
_log(UCS__ERROR, "Error expiring read messages, %s %s", query, errbuf);
_log(UCS__ERROR, "Error expiring read messages, %s %s", query.c_str(), errbuf);
}
safe_delete_array(query);
}
// Expire Unread
if(RuleI(Mail, ExpireUnread) >= 0) {
if(RunQuery(query, MakeAnyLenString(&query, "delete from `mail` where `status`=1 and `timestamp` < %i",
time(nullptr) - RuleI(Mail, ExpireUnread)), errbuf, 0, &AffectedRows)) {
_log(UCS__INIT, "Expired %i unread messages.", AffectedRows);
StringFormat(query, "delete from `mail` where `status`=1 and `timestamp` < %i",
time(nullptr) - RuleI(Mail, ExpireUnread));
if(RunQuery(query, errbuf, 0, &AffectedRows)) {
_log(UCS__INIT, "Expired %i unread messages.", AffectedRows);
}
else {
_log(UCS__ERROR, "Error expiring unread messages, %s %s", query, errbuf);
_log(UCS__ERROR, "Error expiring unread messages, %s %s", query.c_str(), errbuf);
}
safe_delete_array(query);
}
}
void Database::AddFriendOrIgnore(int CharID, int Type, std::string Name) {
const char *FriendsQuery="INSERT INTO `friends` (`charid`, `type`, `name`) VALUES ('%i', %i, '%s')";
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
StringFormat(query, "INSERT INTO `friends` (`charid`, `type`, `name`) VALUES ('%i', %i, '%s')",
CharID, Type, CapitaliseName(Name).c_str());
if(!RunQuery(query, MakeAnyLenString(&query, FriendsQuery, CharID, Type, CapitaliseName(Name).c_str()), errbuf, 0, 0))
_log(UCS__ERROR, "Error adding friend/ignore, query was %s : %s", query, errbuf);
if(!RunQuery(query, errbuf, 0, 0))
_log(UCS__ERROR, "Error adding friend/ignore, query was %s : %s", query.c_str(), errbuf);
else
_log(UCS__TRACE, "Wrote Friend/Ignore entry for charid %i, type %i, name %s to database.",
CharID, Type, Name.c_str());
safe_delete_array(query);
CharID, Type, Name.c_str());
}
void Database::RemoveFriendOrIgnore(int CharID, int Type, std::string Name) {
const char *FriendsQuery="DELETE FROM `friends` WHERE `charid`=%i AND `type`=%i and `name`='%s'";
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
if(!RunQuery(query, MakeAnyLenString(&query, FriendsQuery, CharID, Type, CapitaliseName(Name).c_str()), errbuf, 0, 0))
_log(UCS__ERROR, "Error removing friend/ignore, query was %s", query);
StringFormat(query,"DELETE FROM `friends` WHERE `charid`=%i AND `type`=%i and `name`='%s'",
CharID, Type, CapitaliseName(Name).c_str());
if(!RunQuery(query, errbuf, 0, 0))
_log(UCS__ERROR, "Error removing friend/ignore, query was %s", query.c_str());
else
_log(UCS__TRACE, "Removed Friend/Ignore entry for charid %i, type %i, name %s from database.",
CharID, Type, Name.c_str());
safe_delete_array(query);
}
void Database::GetFriendsAndIgnore(int CharID, std::vector<std::string> &Friends, std::vector<std::string> &Ignorees) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
const char *FriendsQuery="select `type`, `name` from `friends` WHERE `charid`=%i";
StringFormat(query,"select `type`, `name` from `friends` WHERE `charid`=%i", CharID);
if (!RunQuery(query,MakeAnyLenString(&query, FriendsQuery, CharID),errbuf,&result)){
if (!RunQuery(query,errbuf,&result)){
_log(UCS__ERROR, "GetFriendsAndIgnore query error %s, %s", query, errbuf);
safe_delete_array(query);
_log(UCS__ERROR, "GetFriendsAndIgnore query error %s, %s", query.c_str(), errbuf);
return ;
}
safe_delete_array(query);
while((row = mysql_fetch_row(result))) {
std::string Name = row[1];

24
world/Adventure.cpp
View File

@ -375,11 +375,13 @@ void Adventure::MoveCorpsesToGraveyard()
std::list<uint32> dbid_list;
std::list<uint32> charid_list;
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if(database.RunQuery(query,MakeAnyLenString(&query,"SELECT id, charid FROM player_corpses WHERE instanceid=%d", GetInstanceID()), errbuf, &result))
StringFormat(query,"SELECT id, charid FROM player_corpses WHERE instanceid=%d", GetInstanceID());
if(database.RunQuery(query,errbuf, &result))
{
while((row = mysql_fetch_row(result)))
{
@ -387,12 +389,10 @@ void Adventure::MoveCorpsesToGraveyard()
charid_list.push_back(atoi(row[1]));
}
mysql_free_result(result);
safe_delete_array(query);
}
else
{
LogFile->write(EQEMuLog::Error, "Error in AdventureManager:::MoveCorpsesToGraveyard: %s (%s)", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in AdventureManager:::MoveCorpsesToGraveyard: %s (%s)", query.c_str(), errbuf);
}
std::list<uint32>::iterator iter = dbid_list.begin();
@ -401,15 +401,13 @@ void Adventure::MoveCorpsesToGraveyard()
float x = GetTemplate()->graveyard_x + MakeRandomFloat(-GetTemplate()->graveyard_radius, GetTemplate()->graveyard_radius);
float y = GetTemplate()->graveyard_y + MakeRandomFloat(-GetTemplate()->graveyard_radius, GetTemplate()->graveyard_radius);
float z = GetTemplate()->graveyard_z;
if(database.RunQuery(query,MakeAnyLenString(&query, "UPDATE player_corpses SET zoneid=%d, instanceid=0, x=%f, y=%f, z=%f WHERE instanceid=%d",
GetTemplate()->graveyard_zone_id, x, y, z, GetInstanceID()), errbuf))
StringFormat(query,"UPDATE player_corpses SET zoneid=%d, instanceid=0, x=%f, y=%f, z=%f WHERE instanceid=%d",
GetTemplate()->graveyard_zone_id, x, y, z, GetInstanceID());
if(!database.RunQuery(query,errbuf))
{
safe_delete_array(query);
}
else
{
LogFile->write(EQEMuLog::Error, "Error in AdventureManager:::MoveCorpsesToGraveyard: %s (%s)", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in AdventureManager:::MoveCorpsesToGraveyard: %s (%s)", query.c_str(), errbuf);
}
iter++;
}

42
world/AdventureManager.cpp
View File

@ -636,16 +636,17 @@ AdventureTemplate *AdventureManager::GetAdventureTemplate(int id)
bool AdventureManager::LoadAdventureTemplates()
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
if(database.RunQuery(query,MakeAnyLenString(&query,"SELECT id, zone, zone_version, "
"is_hard, min_level, max_level, type, type_data, type_count, assa_x, "
"assa_y, assa_z, assa_h, text, duration, zone_in_time, win_points, lose_points, "
"theme, zone_in_zone_id, zone_in_x, zone_in_y, zone_in_object_id, dest_x, dest_y,"
" dest_z, dest_h, graveyard_zone_id, graveyard_x, graveyard_y, graveyard_z, "
"graveyard_radius FROM adventure_template"), errbuf, &result))
std::string query = "SELECT id, zone, zone_version, "
"is_hard, min_level, max_level, type, type_data, type_count, assa_x, "
"assa_y, assa_z, assa_h, text, duration, zone_in_time, win_points, lose_points, "
"theme, zone_in_zone_id, zone_in_x, zone_in_y, zone_in_object_id, dest_x, dest_y,"
" dest_z, dest_h, graveyard_zone_id, graveyard_x, graveyard_y, graveyard_z, "
"graveyard_radius FROM adventure_template";
if(database.RunQuery(query,errbuf, &result))
{
while((row = mysql_fetch_row(result)))
{
@ -686,13 +687,11 @@ bool AdventureManager::LoadAdventureTemplates()
adventure_templates[t->id] = t;
}
mysql_free_result(result);
safe_delete_array(query);
return true;
}
else
{
LogFile->write(EQEMuLog::Error, "Error in AdventureManager:::LoadAdventures: %s (%s)", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in AdventureManager:::LoadAdventures: %s (%s)", query.c_str(), errbuf);
return false;
}
return false;
@ -701,11 +700,12 @@ bool AdventureManager::LoadAdventureTemplates()
bool AdventureManager::LoadAdventureEntries()
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
if(database.RunQuery(query,MakeAnyLenString(&query,"SELECT id, template_id FROM adventure_template_entry"), errbuf, &result))
std::string query= "SELECT id, template_id FROM adventure_template_entry";
if(database.RunQuery(query, errbuf, &result))
{
while((row = mysql_fetch_row(result)))
{
@ -738,13 +738,11 @@ bool AdventureManager::LoadAdventureEntries()
}
}
mysql_free_result(result);
safe_delete_array(query);
return true;
}
else
{
LogFile->write(EQEMuLog::Error, "Error in AdventureManager:::LoadAdventureEntries: %s (%s)", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in AdventureManager:::LoadAdventureEntries: %s (%s)", query.c_str(), errbuf);
return false;
}
return false;
@ -1093,12 +1091,14 @@ void AdventureManager::LoadLeaderboardInfo()
leaderboard_info_wins_tak.clear();
leaderboard_info_percentage_tak.clear();
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
if(database.RunQuery(query,MakeAnyLenString(&query,"select ch.name, ch.id, adv_stats.* from adventure_stats "
"AS adv_stats ""left join character_ AS ch on adv_stats.player_id = ch.id;"), errbuf, &result))
std::string query = "select ch.name, ch.id, adv_stats.* from adventure_stats "
"AS adv_stats ""left join character_ AS ch on "
"adv_stats.player_id = ch.id;";
if(database.RunQuery(query,errbuf, &result))
{
while((row = mysql_fetch_row(result)))
{
@ -1155,13 +1155,11 @@ void AdventureManager::LoadLeaderboardInfo()
}
}
mysql_free_result(result);
safe_delete_array(query);
return;
}
else
{
LogFile->write(EQEMuLog::Error, "Error in AdventureManager:::GetLeaderboardInfo: %s (%s)", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in AdventureManager:::GetLeaderboardInfo: %s (%s)", query.c_str(), errbuf);
return;
}
return;

156
world/EQLConfig.cpp
View File

@ -34,19 +34,18 @@ EQLConfig::EQLConfig(const char *launcher_name)
void EQLConfig::LoadSettings() {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
LauncherZone tmp;
char namebuf[128];
database.DoEscapeString(namebuf, m_name.c_str(), m_name.length()&0x3F); //limit len to 64
namebuf[127] = '\0';
std::string namebuf;
database.DoEscapeString(namebuf, m_name.c_str(), m_name.length());
namebuf.resize(63); //limit len to 64
if (database.RunQuery(query, MakeAnyLenString(&query,
"SELECT dynamics FROM launcher WHERE name='%s'",
namebuf)
, errbuf, &result))
StringFormat(query,"SELECT dynamics FROM launcher WHERE name='%s'",namebuf.c_str());
if (database.RunQuery(query, errbuf, &result))
{
while ((row = mysql_fetch_row(result))) {
m_dynamics = atoi(row[0]);
@ -55,12 +54,10 @@ void EQLConfig::LoadSettings() {
} else {
LogFile->write(EQEMuLog::Error, "EQLConfig::LoadSettings: %s", errbuf);
}
safe_delete_array(query);
if (database.RunQuery(query, MakeAnyLenString(&query,
"SELECT zone,port FROM launcher_zones WHERE launcher='%s'",
namebuf)
, errbuf, &result))
StringFormat(query, "SELECT zone,port FROM launcher_zones WHERE launcher='%s'", namebuf.c_str());
if (database.RunQuery(query, errbuf, &result))
{
LauncherZone zs;
while ((row = mysql_fetch_row(result))) {
@ -72,25 +69,23 @@ void EQLConfig::LoadSettings() {
} else {
LogFile->write(EQEMuLog::Error, "EQLConfig::LoadSettings: %s", errbuf);
}
safe_delete_array(query);
}
EQLConfig *EQLConfig::CreateLauncher(const char *name, uint8 dynamic_count) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
char namebuf[128];
database.DoEscapeString(namebuf, name, strlen(name)&0x3F); //limit len to 64
namebuf[127] = '\0';
std::string namebuf;
database.DoEscapeString(namebuf, name, strlen(name));
namebuf.resize(63); //limit len to 64
if (!database.RunQuery(query, MakeAnyLenString(&query,
"INSERT INTO launcher (name,dynamics) VALUES('%s', %d)",
namebuf, dynamic_count), errbuf)) {
StringFormat(query, "INSERT INTO launcher (name,dynamics) VALUES('%s', %d)",
namebuf.c_str(), dynamic_count);
if (!database.RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error in CreateLauncher query: %s", errbuf);
safe_delete_array(query);
return nullptr;
}
safe_delete_array(query);
return(new EQLConfig(name));
}
@ -127,29 +122,26 @@ void EQLConfig::DeleteLauncher() {
launcher_list.Remove(m_name.c_str());
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
char namebuf[128];
database.DoEscapeString(namebuf, m_name.c_str(), m_name.length()&0x3F); //limit len to 64
namebuf[127] = '\0';
std::string namebuf;
database.DoEscapeString(namebuf, m_name.c_str(), m_name.length());
namebuf.resize(63); //limit len to 64
if (!database.RunQuery(query, MakeAnyLenString(&query,
"DELETE FROM launcher WHERE name='%s'",
namebuf), errbuf)) {
StringFormat(query, "DELETE FROM launcher WHERE name='%s'",namebuf.c_str());
if (!database.RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error in DeleteLauncher 1 query: %s", errbuf);
safe_delete_array(query);
return;
}
safe_delete_array(query);
if (!database.RunQuery(query, MakeAnyLenString(&query,
"DELETE FROM launcher_zones WHERE launcher='%s'",
namebuf), errbuf)) {
StringFormat(query, "DELETE FROM launcher_zones WHERE launcher='%s'",
namebuf.c_str());
if (!database.RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error in DeleteLauncher 2 query: %s", errbuf);
safe_delete_array(query);
return;
}
safe_delete_array(query);
}
bool EQLConfig::IsConnected() const {
@ -185,23 +177,23 @@ bool EQLConfig::BootStaticZone(Const_char *short_name, uint16 port) {
//database update
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
char namebuf[128];
database.DoEscapeString(namebuf, m_name.c_str(), m_name.length()&0x3F); //limit len to 64
namebuf[127] = '\0';
char zonebuf[32];
database.DoEscapeString(zonebuf, short_name, strlen(short_name)&0xF); //limit len to 16
zonebuf[31] = '\0';
std::string namebuf;
database.DoEscapeString(namebuf, m_name.c_str(), m_name.length());
namebuf.resize(63); //limit len to 64
std::string zonebuf;
database.DoEscapeString(zonebuf, short_name, strlen(short_name));
zonebuf.resize(15); //limit len to 16
if (!database.RunQuery(query, MakeAnyLenString(&query,
"INSERT INTO launcher_zones (launcher,zone,port) VALUES('%s', '%s', %d)",
namebuf, zonebuf, port), errbuf)) {
StringFormat(query, "INSERT INTO launcher_zones (launcher,zone,port) VALUES('%s', '%s', %d)",
namebuf.c_str(), zonebuf.c_str(), port);
if (!database.RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error in BootStaticZone query: %s", errbuf);
safe_delete_array(query);
return false;
}
safe_delete_array(query);
//update our internal state.
LauncherZone lz;
@ -235,24 +227,23 @@ bool EQLConfig::ChangeStaticZone(Const_char *short_name, uint16 port) {
//database update
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
char namebuf[128];
database.DoEscapeString(namebuf, m_name.c_str(), m_name.length()&0x3F); //limit len to 64
namebuf[127] = '\0';
char zonebuf[32];
database.DoEscapeString(zonebuf, short_name, strlen(short_name)&0xF); //limit len to 16
zonebuf[31] = '\0';
std::string namebuf;
database.DoEscapeString(namebuf, m_name.c_str(), m_name.length());
namebuf.resize(63); //limit len to 64
std::string zonebuf;
database.DoEscapeString(zonebuf, short_name, strlen(short_name)); //limit len to 16
zonebuf.resize(15);
if (!database.RunQuery(query, MakeAnyLenString(&query,
"UPDATE launcher_zones SET port=%d WHERE launcher='%s' AND zone='%s'",
port, namebuf, zonebuf), errbuf)) {
StringFormat(query, "UPDATE launcher_zones SET port=%d WHERE launcher='%s' AND zone='%s'",
port, namebuf.c_str(), zonebuf.c_str());
if (!database.RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error in ChangeStaticZone query: %s", errbuf);
safe_delete_array(query);
return false;
}
safe_delete_array(query);
//update internal state
res->second.port = port;
@ -278,23 +269,23 @@ bool EQLConfig::DeleteStaticZone(Const_char *short_name) {
//database update
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
char namebuf[128];
database.DoEscapeString(namebuf, m_name.c_str(), m_name.length()&0x3F); //limit len to 64
namebuf[127] = '\0';
char zonebuf[32];
database.DoEscapeString(zonebuf, short_name, strlen(short_name)&0xF); //limit len to 16
zonebuf[31] = '\0';
std::string namebuf;
database.DoEscapeString(namebuf, m_name.c_str(), m_name.length());
namebuf.resize(63);//limit len to 64
std::string zonebuf;
database.DoEscapeString(zonebuf, short_name, strlen(short_name));
zonebuf.resize(15); //limit len to 16
if (!database.RunQuery(query, MakeAnyLenString(&query,
"DELETE FROM launcher_zones WHERE launcher='%s' AND zone='%s'",
namebuf, zonebuf), errbuf)) {
StringFormat(query, "DELETE FROM launcher_zones WHERE launcher='%s' AND zone='%s'",
namebuf.c_str(), zonebuf.c_str());
if (!database.RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error in DeleteStaticZone query: %s", errbuf);
safe_delete_array(query);
return false;
}
safe_delete_array(query);
//internal update.
m_zones.erase(res);
@ -310,20 +301,19 @@ bool EQLConfig::DeleteStaticZone(Const_char *short_name) {
bool EQLConfig::SetDynamicCount(int count) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
char namebuf[128];
database.DoEscapeString(namebuf, m_name.c_str(), m_name.length()&0x3F); //limit len to 64
namebuf[127] = '\0';
std::string namebuf;
database.DoEscapeString(namebuf, m_name.c_str(), m_name.length());
namebuf.resize(63);//limit len to 64
if (!database.RunQuery(query, MakeAnyLenString(&query,
"UPDATE launcher SET dynamics=%d WHERE name='%s'",
count, namebuf), errbuf)) {
StringFormat(query, "UPDATE launcher SET dynamics=%d WHERE name='%s'",
count, namebuf.c_str());
if (!database.RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error in SetDynamicCount query: %s", errbuf);
safe_delete_array(query);
return false;
}
safe_delete_array(query);
//update in-memory version.
m_dynamics = count;

36
world/EQW.cpp
View File

@ -385,11 +385,12 @@ bool EQW::SetPublicNote(uint32 charid, const char *note) {
int EQW::CountBugs() {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
if(database.RunQuery(query, MakeAnyLenString(&query, "SELECT count(*) FROM bugs where status = 0"), errbuf, &result)) {
safe_delete_array(query);
std::string query = "SELECT count(*) FROM bugs where status = 0";
if(database.RunQuery(query, errbuf, &result)) {
if((row = mysql_fetch_row(result))) {
int count = atoi(row[0]);
mysql_free_result(result);
@ -397,35 +398,37 @@ int EQW::CountBugs() {
}
mysql_free_result(result);
}
safe_delete_array(query);
return 0;
}
std::vector<std::string> EQW::ListBugs(uint32 offset) {
std::vector<std::string> res;
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if(database.RunQuery(query, MakeAnyLenString(&query, "SELECT id FROM bugs WHERE status = 0 limit %d, 30", offset), errbuf, &result)) {
safe_delete_array(query);
StringFormat(query,"SELECT id FROM bugs WHERE status = 0 limit %d, 30", offset);
if(database.RunQuery(query, errbuf, &result)) {
while((row = mysql_fetch_row(result))) {
res.push_back(row[0]);
}
mysql_free_result(result);
}
safe_delete_array(query);
return res;
}
std::map<std::string,std::string> EQW::GetBugDetails(Const_char *id) {
std::map<std::string,std::string> res;
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if(database.RunQuery(query, MakeAnyLenString(&query, "select name, zone, x, y, z, target, bug from bugs where id = %s", id), errbuf, &result)) {
safe_delete_array(query);
StringFormat(query,"select name, zone, x, y, z, target, bug from bugs where id = %s", id);
if(database.RunQuery(query, errbuf, &result)) {
while((row = mysql_fetch_row(result))) {
res["name"] = row[0];
res["zone"] = row[1];
@ -438,18 +441,19 @@ std::map<std::string,std::string> EQW::GetBugDetails(Const_char *id) {
}
mysql_free_result(result);
}
safe_delete_array(query);
return res;
}
void EQW::ResolveBug(const char *id) {
std::vector<std::string> res;
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
if(database.RunQuery(query, MakeAnyLenString(&query, "UPDATE bugs SET status=1 WHERE id=%s", id), errbuf)) {
safe_delete_array(query);
std::string query;
StringFormat(query,"UPDATE bugs SET status=1 WHERE id=%s", id);
if(!database.RunQuery(query, errbuf)) {
// TODO: log failed statement.
}
safe_delete_array(query);
}
void EQW::SendMessage(uint32 type, const char *msg) {

133
world/worlddb.cpp
View File

@ -36,7 +36,7 @@ extern std::vector<RaceClassCombos> character_create_race_class_combos;
// solar: the current stuff is at the bottom of this function
void WorldDatabase::GetCharSelectInfo(uint32 account_id, CharacterSelect_Struct* cs) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
Inventory *inv;
@ -53,8 +53,12 @@ void WorldDatabase::GetCharSelectInfo(uint32 account_id, CharacterSelect_Struct*
unsigned long* lengths;
// Populate character info
if (RunQuery(query, MakeAnyLenString(&query, "SELECT name,profile,zonename,class,level FROM character_ WHERE account_id=%i order by name limit 10", account_id), errbuf, &result)) {
safe_delete_array(query);
StringFormat(query,"SELECT name,profile,zonename,class,level "
"FROM character_ WHERE account_id=%i "
"order by name limit 10",
account_id);
if (RunQuery(query, errbuf, &result)) {
while ((row = mysql_fetch_row(result))) {
lengths = mysql_fetch_lengths(result);
////////////
@ -119,18 +123,12 @@ void WorldDatabase::GetCharSelectInfo(uint32 account_id, CharacterSelect_Struct*
}
}
else {
RunQuery(query,
MakeAnyLenString(&query,
"SELECT zone_id,bind_id,x,y,z FROM start_zones "
"WHERE player_class=%i AND player_deity=%i AND player_race=%i",
pp->class_,
pp->deity,
pp->race
),
errbuf,
&result2
);
safe_delete_array(query);
StringFormat(query, "SELECT zone_id,bind_id,x,y,z FROM start_zones "
"WHERE player_class=%i AND player_deity=%i AND player_race=%i",
pp->class_, pp->deity, pp->race);
RunQuery(query,errbuf,&result2);
// if there is only one possible start city, set it
if(mysql_num_rows(result2) == 1) {
@ -160,8 +158,10 @@ void WorldDatabase::GetCharSelectInfo(uint32 account_id, CharacterSelect_Struct*
// update the player profile
if(altered) {
uint32 char_id = GetCharacterID(cs->name[char_num]);
RunQuery(query,MakeAnyLenString(&query,"SELECT extprofile FROM character_ WHERE id=%i",char_id), errbuf, &result2);
safe_delete_array(query);
StringFormat(query,"SELECT extprofile FROM character_ WHERE id=%i",char_id);
RunQuery(query,errbuf, &result2);
if(result2) {
row2 = mysql_fetch_row(result2);
ExtendedProfile_Struct* ext = (ExtendedProfile_Struct*)row2[0];
@ -229,7 +229,6 @@ void WorldDatabase::GetCharSelectInfo(uint32 account_id, CharacterSelect_Struct*
else
{
std::cerr << "Error in GetCharSelectInfo query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return;
}
@ -242,7 +241,7 @@ int WorldDatabase::MoveCharacterToBind(int CharID, uint8 bindnum) {
bindnum = 0;
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
uint32 affected_rows = 0;
@ -250,7 +249,9 @@ int WorldDatabase::MoveCharacterToBind(int CharID, uint8 bindnum) {
bool PPValid = false;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT profile from character_ where id='%i'", CharID), errbuf, &result)) {
StringFormat(query, "SELECT profile from character_ where id='%i'", CharID);
if (RunQuery(query, errbuf, &result)) {
row = mysql_fetch_row(result);
unsigned long* lengths = mysql_fetch_lengths(result);
if (lengths[0] == sizeof(PlayerProfile_Struct)) {
@ -259,7 +260,6 @@ int WorldDatabase::MoveCharacterToBind(int CharID, uint8 bindnum) {
}
mysql_free_result(result);
}
safe_delete_array(query);
if(!PPValid) return 0;
@ -267,13 +267,14 @@ int WorldDatabase::MoveCharacterToBind(int CharID, uint8 bindnum) {
if(!strcmp(BindZoneName, "UNKNWN")) return pp.zone_id;
if (!RunQuery(query, MakeAnyLenString(&query, "UPDATE character_ SET zonename = '%s',zoneid=%i,x=%f, y=%f, z=%f, instanceid=0 WHERE id='%i'",
StringFormat(query, "UPDATE character_ SET zonename = '%s',zoneid=%i,x=%f, y=%f, z=%f, instanceid=0 WHERE id='%i'",
BindZoneName, pp.binds[bindnum].zoneId, pp.binds[bindnum].x, pp.binds[bindnum].y, pp.binds[bindnum].z,
CharID), errbuf, 0,&affected_rows)) {
CharID);
if (!RunQuery(query, errbuf, nullptr,&affected_rows)) {
return pp.zone_id;
}
safe_delete_array(query);
return pp.binds[bindnum].zoneId;
}
@ -281,7 +282,7 @@ int WorldDatabase::MoveCharacterToBind(int CharID, uint8 bindnum) {
bool WorldDatabase::GetStartZone(PlayerProfile_Struct* in_pp, CharCreate_Struct* in_cc)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row = 0;
int rows;
@ -292,20 +293,19 @@ bool WorldDatabase::GetStartZone(PlayerProfile_Struct* in_pp, CharCreate_Struct*
in_pp->x = in_pp->y = in_pp->z = in_pp->heading = in_pp->zone_id = 0;
in_pp->binds[0].x = in_pp->binds[0].y = in_pp->binds[0].z = in_pp->binds[0].zoneId = 0;
if(!RunQuery(query, MakeAnyLenString(&query, "SELECT x,y,z,heading,zone_id,bind_id FROM start_zones WHERE player_choice=%i AND player_class=%i "
"AND player_deity=%i AND player_race=%i",
in_cc->start_zone,
in_cc->class_,
in_cc->deity,
in_cc->race), errbuf, &result))
StringFormat(query, "SELECT x,y,z,heading,zone_id,bind_id FROM "
"start_zones WHERE player_choice=%i AND player_class=%i "
"AND player_deity=%i AND player_race=%i",
in_cc->start_zone, in_cc->class_,
in_cc->deity, in_cc->race);
if(!RunQuery(query, errbuf, &result))
{
LogFile->write(EQEMuLog::Error, "Start zone query failed: %s : %s\n", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Start zone query failed: %s : %s\n", query.c_str(), errbuf);
return false;
}
LogFile->write(EQEMuLog::Status, "Start zone query: %s\n", query);
safe_delete_array(query);
LogFile->write(EQEMuLog::Status, "Start zone query: %s\n", query.c_str());
if((rows = mysql_num_rows(result)) > 0)
row = mysql_fetch_row(result);
@ -433,7 +433,7 @@ bool WorldDatabase::GetStartZoneSoF(PlayerProfile_Struct* in_pp, CharCreate_Stru
// reason for no match being found.
//
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row = 0;
int rows;
@ -444,20 +444,19 @@ bool WorldDatabase::GetStartZoneSoF(PlayerProfile_Struct* in_pp, CharCreate_Stru
in_pp->x = in_pp->y = in_pp->z = in_pp->heading = in_pp->zone_id = 0;
in_pp->binds[0].x = in_pp->binds[0].y = in_pp->binds[0].z = in_pp->binds[0].zoneId = 0;
if(!RunQuery(query, MakeAnyLenString(&query, "SELECT x,y,z,heading,bind_id FROM start_zones WHERE zone_id=%i AND player_class=%i "
"AND player_deity=%i AND player_race=%i",
in_cc->start_zone,
in_cc->class_,
in_cc->deity,
in_cc->race), errbuf, &result))
StringFormat(query,"SELECT x,y,z,heading,bind_id FROM "
"start_zones WHERE zone_id=%i AND player_class=%i "
"AND player_deity=%i AND player_race=%i",
in_cc->start_zone, in_cc->class_,
in_cc->deity, in_cc->race);
if(!RunQuery(query, errbuf, &result))
{
LogFile->write(EQEMuLog::Status, "SoF Start zone query failed: %s : %s\n", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Status, "SoF Start zone query failed: %s : %s\n", query.c_str(), errbuf);
return false;
}
LogFile->write(EQEMuLog::Status, "SoF Start zone query: %s\n", query);
safe_delete_array(query);
LogFile->write(EQEMuLog::Status, "SoF Start zone query: %s\n", query.c_str());
if((rows = mysql_num_rows(result)) > 0)
row = mysql_fetch_row(result);
@ -499,15 +498,14 @@ bool WorldDatabase::GetStartZoneSoF(PlayerProfile_Struct* in_pp, CharCreate_Stru
void WorldDatabase::GetLauncherList(std::vector<std::string> &rl) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
rl.clear();
if (RunQuery(query, MakeAnyLenString(&query,
"SELECT name FROM launcher" )
, errbuf, &result))
std::string query = "SELECT name FROM launcher";
if (RunQuery(query, errbuf, &result))
{
while ((row = mysql_fetch_row(result))) {
rl.push_back(row[0]);
@ -517,13 +515,12 @@ void WorldDatabase::GetLauncherList(std::vector<std::string> &rl) {
else {
LogFile->write(EQEMuLog::Error, "WorldDatabase::GetLauncherList: %s", errbuf);
}
safe_delete_array(query);
}
void WorldDatabase::SetMailKey(int CharID, int IPAddress, int MailKey) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
char MailKeyString[17];
@ -532,29 +529,29 @@ void WorldDatabase::SetMailKey(int CharID, int IPAddress, int MailKey) {
else
sprintf(MailKeyString, "%08X", MailKey);
if (!RunQuery(query, MakeAnyLenString(&query, "UPDATE character_ SET mailkey = '%s' WHERE id='%i'",
MailKeyString, CharID), errbuf))
StringFormat(query, "UPDATE character_ SET mailkey = '%s' WHERE id='%i'",
MailKeyString, CharID);
if (!RunQuery(query, errbuf))
LogFile->write(EQEMuLog::Error, "WorldDatabase::SetMailKey(%i, %s) : %s", CharID, MailKeyString, errbuf);
safe_delete_array(query);
}
bool WorldDatabase::GetCharacterLevel(const char *name, int &level)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if(RunQuery(query, MakeAnyLenString(&query, "SELECT level FROM character_ WHERE name='%s'", name), errbuf, &result))
StringFormat(query, "SELECT level FROM character_ WHERE name='%s'", name);
if(RunQuery(query, errbuf, &result))
{
if(row = mysql_fetch_row(result))
{
level = atoi(row[0]);
mysql_free_result(result);
safe_delete_array(query);
return true;
}
mysql_free_result(result);
@ -563,7 +560,6 @@ bool WorldDatabase::GetCharacterLevel(const char *name, int &level)
{
LogFile->write(EQEMuLog::Error, "WorldDatabase::GetCharacterLevel: %s", errbuf);
}
safe_delete_array(query);
return false;
}
@ -571,11 +567,13 @@ bool WorldDatabase::LoadCharacterCreateAllocations() {
character_create_allocations.clear();
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
if(RunQuery(query, MakeAnyLenString(&query, "SELECT * FROM char_create_point_allocations order by id"), errbuf, &result)) {
safe_delete_array(query);
std::string query = "SELECT * FROM char_create_point_allocations order by id";
if(RunQuery(query, errbuf, &result)) {
while(row = mysql_fetch_row(result)) {
RaceClassAllocation allocate;
int r = 0;
@ -598,7 +596,6 @@ bool WorldDatabase::LoadCharacterCreateAllocations() {
}
mysql_free_result(result);
} else {
safe_delete_array(query);
return false;
}
@ -609,11 +606,12 @@ bool WorldDatabase::LoadCharacterCreateCombos() {
character_create_race_class_combos.clear();
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
if(RunQuery(query, MakeAnyLenString(&query, "select * from char_create_combinations order by race, class, deity, start_zone"), errbuf, &result)) {
safe_delete_array(query);
std::string query ="select * from char_create_combinations order by race, class, deity, start_zone";
if(RunQuery(query, errbuf, &result)) {
while(row = mysql_fetch_row(result)) {
RaceClassCombos combo;
int r = 0;
@ -627,7 +625,6 @@ bool WorldDatabase::LoadCharacterCreateCombos() {
}
mysql_free_result(result);
} else {
safe_delete_array(query);
return false;
}

18
world/zoneserver.cpp
View File

@ -448,7 +448,7 @@ bool ZoneServer::Process() {
else if (cle->Online() == CLE_Status_Zoning) {
if (!scm->noreply) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
//MYSQL_ROW row; Trumpcard - commenting. Currently unused.
time_t rawtime;
@ -456,21 +456,25 @@ bool ZoneServer::Process() {
time ( &rawtime );
timeinfo = localtime ( &rawtime );
char *telldate=asctime(timeinfo);
if (database.RunQuery(query, MakeAnyLenString(&query, "SELECT name from character_ where name='%s'",scm->deliverto), errbuf, &result)) {
safe_delete(query);
StringFormat(query,"SELECT name from character_ where name='%s'",scm->deliverto);
if (database.RunQuery(query,errbuf, &result)) {
if (result!=0) {
if (database.RunQuery(query, MakeAnyLenString(&query, "INSERT INTO tellque (Date,Receiver,Sender,Message) values('%s','%s','%s','%s')",telldate,scm->deliverto,scm->from,scm->message), errbuf, &result))
StringFormat(query, "INSERT INTO tellque (Date,Receiver,Sender,Message) "
"values('%s','%s','%s','%s')",
telldate, scm->deliverto, scm->from,scm->message);
if (database.RunQuery(query, errbuf, &result))
zoneserver_list.SendEmoteMessage(scm->from, 0, 0, 0, "Your message has been added to the %s's que.", scm->to);
else
zoneserver_list.SendEmoteMessage(scm->from, 0, 0, 0, "You told %s, '%s is not online at this time'", scm->to, scm->to);
safe_delete(query);
}
else
zoneserver_list.SendEmoteMessage(scm->from, 0, 0, 0, "You told %s, '%s is not online at this time'", scm->to, scm->to);
mysql_free_result(result);
}
else
safe_delete(query);
}
// zoneserver_list.SendEmoteMessage(scm->from, 0, 0, 0, "You told %s, '%s is not online at this time'", scm->to, scm->to);
}

172
zone/AA.cpp
View File

@ -1465,12 +1465,13 @@ void Zone::LoadAAs() {
bool ZoneDatabase::LoadAAEffects2() {
aa_effects.clear(); //start fresh
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT aaid, slot, effectid, base1, base2 FROM aa_effects ORDER BY aaid ASC, slot ASC"), errbuf, &result)) {
std::string query = "SELECT aaid, slot, effectid, base1, base2 FROM aa_effects ORDER BY aaid ASC, slot ASC";
if (RunQuery(query, errbuf, &result)) {
int count = 0;
while((row = mysql_fetch_row(result))!= nullptr) {
int aaid = atoi(row[0]);
@ -1488,10 +1489,9 @@ bool ZoneDatabase::LoadAAEffects2() {
if (count < 1) //no results
LogFile->write(EQEMuLog::Error, "Error loading AA Effects, none found in the database.");
} else {
LogFile->write(EQEMuLog::Error, "Error in ZoneDatabase::LoadAAEffects2 query: '%s': %s", query, errbuf);
LogFile->write(EQEMuLog::Error, "Error in ZoneDatabase::LoadAAEffects2 query: '%s': %s", query.c_str(), errbuf);
return false;
}
safe_delete_array(query);
return true;
}
void Client::ResetAA(){
@ -1639,11 +1639,10 @@ bool ZoneDatabase::LoadAAEffects() {
memset(AA_Actions, 0, sizeof(AA_Actions)); //I hope the compiler is smart about this size...
const char *query = "SELECT aaid,rank,reuse_time,spell_id,target,nonspell_action,nonspell_mana,nonspell_duration,"
"redux_aa,redux_rate,redux_aa2,redux_rate2 FROM aa_actions";
std::string query = "SELECT aaid,rank,reuse_time,spell_id,target,nonspell_action,nonspell_mana,nonspell_duration,"
"redux_aa,redux_rate,redux_aa2,redux_rate2 FROM aa_actions";
if(RunQuery(query, static_cast<uint32>(strlen(query)), errbuf, &result)) {
//safe_delete_array(query);
if(RunQuery(query, errbuf, &result)) {
int r;
while ((row = mysql_fetch_row(result))) {
r = 0;
@ -1668,8 +1667,7 @@ bool ZoneDatabase::LoadAAEffects() {
mysql_free_result(result);
}
else {
LogFile->write(EQEMuLog::Error, "Error in LoadAAEffects query '%s': %s", query, errbuf);;
//safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in LoadAAEffects query '%s': %s", query.c_str(), errbuf);
return false;
}
@ -1684,20 +1682,21 @@ bool ZoneDatabase::LoadAAEffects() {
//AndMetal: this may now be obsolete since we have Zone::GetTotalAALevels()
uint8 ZoneDatabase::GetTotalAALevels(uint32 skill_id) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
int total=0;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT count(slot) from aa_effects where aaid=%i", skill_id), errbuf, &result)) {
safe_delete_array(query);
StringFormat(query,"SELECT count(slot) from aa_effects where aaid=%i", skill_id);
if (RunQuery(query, errbuf, &result)) {
if (mysql_num_rows(result) == 1) {
row = mysql_fetch_row(result);
total=atoi(row[0]);
}
mysql_free_result(result);
} else {
LogFile->write(EQEMuLog::Error, "Error in GetTotalAALevels '%s: %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in GetTotalAALevels '%s: %s", query.c_str(), errbuf);
}
return total;
}
@ -1728,10 +1727,14 @@ void ZoneDatabase::FillAAEffects(SendAA_Struct* aa_struct){
return;
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT effectid, base1, base2, slot from aa_effects where aaid=%i order by slot asc", aa_struct->id), errbuf, &result)) {
StringFormat(query,"SELECT effectid, base1, base2, slot from aa_effects "
"where aaid=%i order by slot asc", aa_struct->id);
if (RunQuery(query, errbuf, &result)) {
int ndx=0;
while((row = mysql_fetch_row(result))!=nullptr) {
aa_struct->abilities[ndx].skill_id=atoi(row[0]);
@ -1742,43 +1745,44 @@ void ZoneDatabase::FillAAEffects(SendAA_Struct* aa_struct){
}
mysql_free_result(result);
} else {
LogFile->write(EQEMuLog::Error, "Error in Client::FillAAEffects query: '%s': %s", query, errbuf);
LogFile->write(EQEMuLog::Error, "Error in Client::FillAAEffects query: '%s': %s", query.c_str(), errbuf);
}
safe_delete_array(query);
}
uint32 ZoneDatabase::CountAAs(){
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
int count=0;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT count(title_sid) from altadv_vars"), errbuf, &result)) {
std::string query = "SELECT count(title_sid) from altadv_vars";
if (RunQuery(query, errbuf, &result)) {
if((row = mysql_fetch_row(result))!=nullptr)
count = atoi(row[0]);
mysql_free_result(result);
} else {
LogFile->write(EQEMuLog::Error, "Error in ZoneDatabase::CountAAs query '%s': %s", query, errbuf);
LogFile->write(EQEMuLog::Error, "Error in ZoneDatabase::CountAAs query '%s': %s", query.c_str(), errbuf);
}
safe_delete_array(query);
return count;
}
uint32 ZoneDatabase::CountAAEffects(){
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
int count=0;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT count(id) from aa_effects"), errbuf, &result)) {
std::string query = "SELECT count(id) from aa_effects";
if (RunQuery(query, errbuf, &result)) {
if((row = mysql_fetch_row(result))!=nullptr){
count = atoi(row[0]);
}
mysql_free_result(result);
} else {
LogFile->write(EQEMuLog::Error, "Error in ZoneDatabase::CountAALevels query '%s': %s", query, errbuf);
LogFile->write(EQEMuLog::Error, "Error in ZoneDatabase::CountAALevels query '%s': %s", query.c_str(), errbuf);
}
safe_delete_array(query);
return count;
}
@ -1793,10 +1797,12 @@ void ZoneDatabase::LoadAAs(SendAA_Struct **load){
if(!load)
return;
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT skill_id from altadv_vars order by skill_id"), errbuf, &result)) {
std::string query = "SELECT skill_id from altadv_vars order by skill_id";
if (RunQuery(query, errbuf, &result)) {
int skill=0,ndx=0;
while((row = mysql_fetch_row(result))!=nullptr) {
skill=atoi(row[0]);
@ -1806,13 +1812,14 @@ void ZoneDatabase::LoadAAs(SendAA_Struct **load){
}
mysql_free_result(result);
} else {
LogFile->write(EQEMuLog::Error, "Error in ZoneDatabase::LoadAAs query '%s': %s", query, errbuf);
LogFile->write(EQEMuLog::Error, "Error in ZoneDatabase::LoadAAs query '%s': %s", query.c_str(), errbuf);
}
safe_delete_array(query);
AARequiredLevelAndCost.clear();
if (RunQuery(query, MakeAnyLenString(&query, "SELECT skill_id, level, cost from aa_required_level_cost order by skill_id"), errbuf, &result))
query = "SELECT skill_id, level, cost from aa_required_level_cost order by skill_id";
if (RunQuery(query, errbuf, &result))
{
AALevelCost_Struct aalcs;
while((row = mysql_fetch_row(result))!=nullptr)
@ -1824,69 +1831,56 @@ void ZoneDatabase::LoadAAs(SendAA_Struct **load){
mysql_free_result(result);
}
else
LogFile->write(EQEMuLog::Error, "Error in ZoneDatabase::LoadAAs query '%s': %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in ZoneDatabase::LoadAAs query '%s': %s", query.c_str(), errbuf);
}
SendAA_Struct* ZoneDatabase::GetAASkillVars(uint32 skill_id)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
SendAA_Struct* sendaa = nullptr;
uchar* buffer;
if (RunQuery(query, MakeAnyLenString(&query, "SET @row = 0"), errbuf)) { //initialize "row" variable in database for next query
safe_delete_array(query);
std::string query = "SET @row = 0";
if (RunQuery(query, errbuf)) { //initialize "row" variable in database for next query
MYSQL_RES *result; //we don't really need these unless we get to this point, so why bother?
MYSQL_ROW row;
if (RunQuery(query, MakeAnyLenString(&query,
"SELECT "
"a.cost, "
"a.max_level, "
"a.hotkey_sid, "
"a.hotkey_sid2, "
"a.title_sid, "
"a.desc_sid, "
"a.type, "
"COALESCE(" //so we can return 0 if it's null
"(" //this is our derived table that has the row # that we can SELECT from, because the client is stupid
"SELECT "
"p.prereq_index_num "
"FROM "
"("
"SELECT "
"a2.skill_id, "
"@row := @row + 1 AS prereq_index_num "
"FROM "
"altadv_vars a2"
") AS p "
"WHERE "
"p.skill_id = a.prereq_skill"
"), "
"0) AS prereq_skill_index, "
"a.prereq_minpoints, "
"a.spell_type, "
"a.spell_refresh, "
"a.classes, "
"a.berserker, "
"a.spellid, "
"a.class_type, "
"a.name, "
"a.cost_inc, "
"a.aa_expansion, "
"a.special_category, "
"a.sof_type, "
"a.sof_cost_inc, "
"a.sof_max_level, "
"a.sof_next_skill, "
"a.clientver, " // Client Version 0 = None, 1 = All, 2 = Titanium/6.2, 4 = SoF 5 = SOD 6 = UF
"a.account_time_required, "
"a.sof_current_level,"
"a.sof_next_id, "
"a.level_inc "
" FROM altadv_vars a WHERE skill_id=%i", skill_id), errbuf, &result)) {
safe_delete_array(query);
StringFormat(query, "SELECT "
"a.cost, a.max_level, a.hotkey_sid, a.hotkey_sid2, "
"a.title_sid, a.desc_sid, a.type, "
"COALESCE(" //so we can return 0 if it's null
// This is our derived table that has the row # that we can SELECT from,
// because the client is stupid.
"("
"SELECT "
"p.prereq_index_num "
"FROM "
"("
"SELECT "
"a2.skill_id, "
"@row := @row + 1 AS prereq_index_num "
"FROM "
"altadv_vars a2"
") AS p "
"WHERE "
"p.skill_id = a.prereq_skill"
"), "
"0) AS prereq_skill_index, "
"a.prereq_minpoints, a.spell_type, "
"a.spell_refresh, a.classes, "
"a.berserker, a.spellid, "
"a.class_type, a.name, "
"a.cost_inc, a.aa_expansion, "
"a.special_category, a.sof_type, "
"a.sof_cost_inc, a.sof_max_level, "
// Client Version 0 = None, 1 = All, 2 = Titanium/6.2, 4 = SoF 5 = SOD 6 = UF
"a.sof_next_skill, a.clientver, "
"a.account_time_required, a.sof_current_level,"
"a.sof_next_id, a.level_inc "
" FROM altadv_vars a WHERE skill_id=%i", skill_id);
if (RunQuery(query, errbuf, &result)) {
if (mysql_num_rows(result) == 1) {
int total_abilities = GetTotalAALevels(skill_id); //eventually we'll want to use zone->GetTotalAALevels(skill_id) since it should save queries to the DB
int totalsize = total_abilities * sizeof(AA_Ability) + sizeof(SendAA_Struct);
@ -1943,12 +1937,10 @@ SendAA_Struct* ZoneDatabase::GetAASkillVars(uint32 skill_id)
}
mysql_free_result(result);
} else {
LogFile->write(EQEMuLog::Error, "Error in GetAASkillVars '%s': %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in GetAASkillVars '%s': %s", query.c_str(), errbuf);
}
} else {
LogFile->write(EQEMuLog::Error, "Error in GetAASkillVars '%s': %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in GetAASkillVars '%s': %s", query.c_str(), errbuf);
}
return sendaa;
}

27
zone/MobAI.cpp
View File

@ -2330,20 +2330,26 @@ DBnpcspells_Struct* ZoneDatabase::GetNPCSpells(uint32 iDBSpellsID) {
else if (!npc_spells_loadtried[iDBSpellsID]) { // no reason to ask the DB again if we have failed once already
npc_spells_loadtried[iDBSpellsID] = true;
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT id, parent_list, attack_proc, proc_chance from npc_spells where id=%d", iDBSpellsID), errbuf, &result)) {
safe_delete_array(query);
StringFormat(query, "SELECT id, parent_list, attack_proc, proc_chance from npc_spells where id=%d", iDBSpellsID);
if (RunQuery(query, errbuf, &result)) {
if (mysql_num_rows(result) == 1) {
row = mysql_fetch_row(result);
uint32 tmpparent_list = atoi(row[1]);
int16 tmpattack_proc = atoi(row[2]);
uint8 tmpproc_chance = atoi(row[3]);
mysql_free_result(result);
if (RunQuery(query, MakeAnyLenString(&query, "SELECT spellid, type, minlevel, maxlevel, manacost, recast_delay, priority, resist_adjust from npc_spells_entries where npc_spells_id=%d ORDER BY minlevel", iDBSpellsID), errbuf, &result)) {
safe_delete_array(query);
StringFormat(query, "SELECT spellid, type, minlevel, maxlevel, manacost, recast_delay, "
"priority, resist_adjust from npc_spells_entries "
"where npc_spells_id=%d ORDER BY minlevel",
iDBSpellsID);
if (RunQuery(query, errbuf, &result)) {
uint32 tmpSize = sizeof(DBnpcspells_Struct) + (sizeof(DBnpcspells_entries_Struct) * mysql_num_rows(result));
npc_spells_cache[iDBSpellsID] = (DBnpcspells_Struct*) new uchar[tmpSize];
memset(npc_spells_cache[iDBSpellsID], 0, tmpSize);
@ -2379,7 +2385,6 @@ DBnpcspells_Struct* ZoneDatabase::GetNPCSpells(uint32 iDBSpellsID) {
}
else {
std::cerr << "Error in AddNPCSpells query1 '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return 0;
}
}
@ -2389,7 +2394,6 @@ DBnpcspells_Struct* ZoneDatabase::GetNPCSpells(uint32 iDBSpellsID) {
}
else {
std::cerr << "Error in AddNPCSpells query1 '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return 0;
}
@ -2400,12 +2404,12 @@ DBnpcspells_Struct* ZoneDatabase::GetNPCSpells(uint32 iDBSpellsID) {
uint32 ZoneDatabase::GetMaxNPCSpellsID() {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT max(id) from npc_spells"), errbuf, &result)) {
safe_delete_array(query);
std::string query = "SELECT max(id) from npc_spells";
if (RunQuery(query,errbuf, &result)) {
if (mysql_num_rows(result) == 1) {
row = mysql_fetch_row(result);
uint32 ret = 0;
@ -2418,7 +2422,6 @@ uint32 ZoneDatabase::GetMaxNPCSpellsID() {
}
else {
std::cerr << "Error in GetMaxNPCSpellsID query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return 0;
}

66
zone/Object.cpp
View File

@ -559,7 +559,7 @@ bool Object::HandleClick(Client* sender, const ClickObject_Struct* click_object)
uint32 ZoneDatabase::AddObject(uint32 type, uint32 icon, const Object_Struct& object, const ItemInst* inst)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
uint32 database_id = 0;
uint32 item_id = 0;
@ -572,18 +572,16 @@ uint32 ZoneDatabase::AddObject(uint32 type, uint32 icon, const Object_Struct& ob
// SQL Escape object_name
uint32 len = strlen(object.object_name) * 2 + 1;
char* object_name = new char[len];
std::string object_name;
DoEscapeString(object_name, object.object_name, strlen(object.object_name));
// Construct query
uint32 len_query = MakeAnyLenString(&query,
"insert into object (zoneid, xpos, ypos, zpos, heading, itemid, charges, objectname, "
"type, icon) values (%i, %f, %f, %f, %f, %i, %i, '%s', %i, %i)",
object.zone_id, object.x, object.y, object.z, object.heading,
item_id, charges, object_name, type, icon);
StringFormat(query,"insert into object (zoneid, xpos, ypos, zpos, heading, itemid, charges, objectname, "
"type, icon) values (%i, %f, %f, %f, %f, %i, %i, '%s', %i, %i)",
object.zone_id, object.x, object.y, object.z, object.heading,
item_id, charges, object_name.c_str(), type, icon);
// Save new record for object
if (!RunQuery(query, len_query, errbuf, nullptr, nullptr, &database_id)) {
if (!RunQuery(query, errbuf, nullptr, nullptr, &database_id)) {
LogFile->write(EQEMuLog::Error, "Unable to insert object: %s", errbuf);
}
else {
@ -593,8 +591,6 @@ uint32 ZoneDatabase::AddObject(uint32 type, uint32 icon, const Object_Struct& ob
}
}
safe_delete_array(object_name);
safe_delete_array(query);
return database_id;
}
@ -602,7 +598,7 @@ uint32 ZoneDatabase::AddObject(uint32 type, uint32 icon, const Object_Struct& ob
void ZoneDatabase::UpdateObject(uint32 id, uint32 type, uint32 icon, const Object_Struct& object, const ItemInst* inst)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
uint32 item_id = 0;
int16 charges = 0;
@ -614,18 +610,16 @@ void ZoneDatabase::UpdateObject(uint32 id, uint32 type, uint32 icon, const Objec
// SQL Escape object_name
uint32 len = strlen(object.object_name) * 2 + 1;
char* object_name = new char[len];
std::string object_name;
DoEscapeString(object_name, object.object_name, strlen(object.object_name));
// Construct query
uint32 len_query = MakeAnyLenString(&query,
"update object set zoneid=%i, xpos=%f, ypos=%f, zpos=%f, heading=%f, "
"itemid=%i, charges=%i, objectname='%s', type=%i, icon=%i where id=%i",
object.zone_id, object.x, object.y, object.z, object.heading,
item_id, charges, object_name, type, icon, id);
StringFormat(query,"update object set zoneid=%i, xpos=%f, ypos=%f, zpos=%f, heading=%f, "
"itemid=%i, charges=%i, objectname='%s', type=%i, icon=%i where id=%i",
object.zone_id, object.x, object.y, object.z, object.heading,
item_id, charges, object_name.c_str(), type, icon, id);
// Save new record for object
if (!RunQuery(query, len_query, errbuf)) {
if (!RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Unable to update object: %s", errbuf);
}
else {
@ -635,18 +629,21 @@ void ZoneDatabase::UpdateObject(uint32 id, uint32 type, uint32 icon, const Objec
}
}
safe_delete_array(object_name);
safe_delete_array(query);
}
Ground_Spawns* ZoneDatabase::LoadGroundSpawns(uint32 zone_id, int16 version, Ground_Spawns* gs){
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT max_x,max_y,max_z,min_x,min_y,heading,name,item,max_allowed,respawn_timer from ground_spawns where zoneid=%i and (version=%u OR version=-1) limit 50", zone_id, version), errbuf, &result))
StringFormat(query,"SELECT max_x, max_y, max_z, min_x, min_y,"
"heading,name,item,max_allowed,respawn_timer "
"from ground_spawns where zoneid=%i and "
"(version=%u OR version=-1) limit 50",
zone_id, version);
if (RunQuery(query, errbuf, &result))
{
safe_delete_array(query);
int i=0;
while( (row=mysql_fetch_row(result) ) ) {
gs->spawn[i].max_x=atof(row[0]);
@ -665,29 +662,20 @@ Ground_Spawns* ZoneDatabase::LoadGroundSpawns(uint32 zone_id, int16 version, Gro
}
else {
std::cerr << "Error in LoadGroundSpawns query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
}
return gs;
}
void ZoneDatabase::DeleteObject(uint32 id)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
// Construct query
uint32 len_query = MakeAnyLenString(&query,
"delete from object where id=%i", id);
std::string query;
// Save new record for object
if (!RunQuery(query, len_query, errbuf)) {
StringFormat(query,"delete from object where id=%i", id);
if (!RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Unable to delete object: %s", errbuf);
}
//else {
// Delete contained items, if any
// DeleteWorldContainer(id);
//}
safe_delete_array(query);
}
uint32 Object::GetDBID()

318
zone/PlayerCorpse.cpp
View File

@ -416,7 +416,7 @@ Corpse::Corpse(Client* client, int32 in_rezexp)
iter++;
}
ss << ")";
database.RunQuery(ss.str().c_str(), ss.str().length());
database.RunQuery(ss.str());
}
if(cursor) { // all cursor items should be on corpse (client < SoF or RespawnFromHover = false)
@ -1446,14 +1446,13 @@ void Corpse::Spawn() {
bool ZoneDatabase::DeleteGraveyard(uint32 zone_id, uint32 graveyard_id) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = new char[256];
std::string query;
uint32 query_length = 0;
uint32 affected_rows = 0;
query_length = sprintf(query,"UPDATE zone SET graveyard_id=0 WHERE zoneidnumber=%u AND version=0", zone_id);
StringFormat(query, "UPDATE zone SET graveyard_id=0 WHERE zoneidnumber=%u AND version=0", zone_id);
if (!RunQuery(query, query_length, errbuf, 0, &affected_rows)) {
safe_delete_array(query);
if (!RunQuery(query, errbuf, 0, &affected_rows)) {
std::cerr << "Error1 in DeleteGraveyard query " << errbuf << std::endl;
return false;
}
@ -1463,14 +1462,12 @@ bool ZoneDatabase::DeleteGraveyard(uint32 zone_id, uint32 graveyard_id) {
return false;
}
query_length = sprintf(query,"DELETE FROM graveyard WHERE id=%u", graveyard_id);
StringFormat(query,"DELETE FROM graveyard WHERE id=%u", graveyard_id);
if (!RunQuery(query, query_length, errbuf, 0, &affected_rows)) {
safe_delete_array(query);
if (!RunQuery(query,errbuf, 0, &affected_rows)) {
std::cerr << "Error3 in DeleteGraveyard query " << errbuf << std::endl;
return false;
}
safe_delete_array(query);
if (affected_rows == 0) {
std::cerr << "Error4 in DeleteGraveyard query: affected_rows = 0" << std::endl;
@ -1481,18 +1478,17 @@ bool ZoneDatabase::DeleteGraveyard(uint32 zone_id, uint32 graveyard_id) {
}
uint32 ZoneDatabase::AddGraveyardIDToZone(uint32 zone_id, uint32 graveyard_id) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = new char[256];
char* end = query;
std::string query;
uint32 affected_rows = 0;
end += sprintf(end,"UPDATE zone SET graveyard_id=%u WHERE zoneidnumber=%u AND version=0", graveyard_id, zone_id);
StringFormat(query, "UPDATE zone SET graveyard_id=%u "
"WHERE zoneidnumber=%u AND version=0",
graveyard_id, zone_id);
if (!RunQuery(query, (uint32) (end - query), errbuf, 0, &affected_rows)) {
safe_delete_array(query);
if (!RunQuery(query,errbuf, 0, &affected_rows)) {
std::cerr << "Error1 in AddGraveyardIDToZone query " << errbuf << std::endl;
return 0;
}
safe_delete_array(query);
if (affected_rows == 0) {
std::cerr << "Error2 in AddGraveyardIDToZone query: affected_rows = 0" << std::endl;
@ -1503,19 +1499,17 @@ uint32 ZoneDatabase::AddGraveyardIDToZone(uint32 zone_id, uint32 graveyard_id) {
}
uint32 ZoneDatabase::NewGraveyardRecord(uint32 graveyard_zoneid, float graveyard_x, float graveyard_y, float graveyard_z, float graveyard_heading) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = new char[256];
char* end = query;
std::string query;
uint32 affected_rows = 0;
uint32 new_graveyard_id = 0;
end += sprintf(end,"INSERT INTO graveyard SET zone_id=%u, x=%1.1f, y=%1.1f, z=%1.1f, heading=%1.1f", graveyard_zoneid, graveyard_x, graveyard_y, graveyard_z, graveyard_heading);
StringFormat(query, "INSERT INTO graveyard SET zone_id=%u, x=%1.1f, y=%1.1f, z=%1.1f, heading=%1.1f",
graveyard_zoneid, graveyard_x, graveyard_y, graveyard_z, graveyard_heading);
if (!RunQuery(query, (uint32) (end - query), errbuf, 0, &affected_rows, &new_graveyard_id)) {
safe_delete_array(query);
if (!RunQuery(query, errbuf, 0, &affected_rows, &new_graveyard_id)) {
std::cerr << "Error1 in NewGraveyardRecord query " << errbuf << std::endl;
return 0;
}
safe_delete_array(query);
if (affected_rows == 0) {
std::cerr << "Error2 in NewGraveyardRecord query: affected_rows = 0" << std::endl;
@ -1529,21 +1523,22 @@ uint32 ZoneDatabase::NewGraveyardRecord(uint32 graveyard_zoneid, float graveyard
return new_graveyard_id;
}
uint32 ZoneDatabase::GraveyardPlayerCorpse(uint32 dbid, uint32 zoneid, uint16 instanceid, float x, float y, float z, float heading) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = new char[256];
char* end = query;
std::string query;
uint32 affected_rows = 0;
// We probably don't want a graveyard located in an instance.
end += sprintf(end,"Update player_corpses SET zoneid=%u, instanceid=0, x=%1.1f, y=%1.1f, z=%1.1f, heading=%1.1f, WasAtGraveyard=1 WHERE id=%d", zoneid, x, y, z, heading, dbid);
StringFormat(query,"Update player_corpses SET zoneid=%u, instanceid=0, "
"x=%1.1f, y=%1.1f, z=%1.1f, heading=%1.1f, "
"WasAtGraveyard=1 WHERE id=%d",
zoneid, x, y, z, heading, dbid);
if (!RunQuery(query, (uint32) (end - query), errbuf, 0, &affected_rows)) {
safe_delete_array(query);
if (!RunQuery(query, errbuf, 0, &affected_rows)) {
std::cerr << "Error1 in GraveyardPlayerCorpse query " << errbuf << std::endl;
return 0;
}
safe_delete_array(query);
if (affected_rows == 0) {
std::cerr << "Error2 in GraveyardPlayerCorpse query: affected_rows = 0" << std::endl;
@ -1551,34 +1546,44 @@ uint32 ZoneDatabase::GraveyardPlayerCorpse(uint32 dbid, uint32 zoneid, uint16 in
}
return dbid;
}
uint32 ZoneDatabase::UpdatePlayerCorpse(uint32 dbid, uint32 charid, const char* charname, uint32 zoneid, uint16 instanceid, uchar* data, uint32 datasize, float x, float y, float z, float heading, bool rezzed) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = new char[256+(datasize*2)];
char* end = query;
std::string query;
std::string dataSection;
std::string endOfQuery;
uint32 affected_rows = 0;
end += sprintf(end, "Update player_corpses SET data=");
*end++ = '\'';
end += DoEscapeString(end, (char*)data, datasize);
*end++ = '\'';
end += sprintf(end,", charname='%s', zoneid=%u, instanceid=%u, charid=%d, x=%1.1f, y=%1.1f, z=%1.1f, heading=%1.1f WHERE id=%d", charname, zoneid, instanceid, charid, x, y, z, heading, dbid);
query = "Update player_corpses SET data= \'";
DoEscapeString(dataSection, (char*)data, datasize);
query.append(dataSection);
if (!RunQuery(query, (uint32) (end - query), errbuf, 0, &affected_rows)) {
safe_delete_array(query);
StringFormat(endOfQuery,"\', charname='%s', zoneid=%u, instanceid=%u, "
"charid=%d, x=%1.1f, y=%1.1f, z=%1.1f, heading=%1.1f "
"WHERE id=%d",
charname, zoneid, instanceid, charid,
x, y, z, heading, dbid);
query.append(endOfQuery);
if (!RunQuery(query, errbuf, 0, &affected_rows)) {
std::cerr << "Error1 in UpdatePlayerCorpse query " << errbuf << std::endl;
return 0;
}
safe_delete_array(query);
if (affected_rows == 0) {
std::cerr << "Error2 in UpdatePlayerCorpse query: affected_rows = 0" << std::endl;
return 0;
}
if(rezzed){
if (!RunQuery(query, MakeAnyLenString(&query, "update player_corpses set rezzed = 1 WHERE id=%d",dbid), errbuf)) {
StringFormat(query,"update player_corpses set rezzed = 1 WHERE id=%d",dbid);
if (!RunQuery(query, errbuf)) {
std::cerr << "Error in UpdatePlayerCorpse/Rezzed query: " << errbuf << std::endl;
}
safe_delete_array(query);
}
return dbid;
}
@ -1586,37 +1591,40 @@ uint32 ZoneDatabase::UpdatePlayerCorpse(uint32 dbid, uint32 charid, const char*
void ZoneDatabase::MarkCorpseAsRezzed(uint32 dbid)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
if(!database.RunQuery(query,MakeAnyLenString(&query, "UPDATE player_corpses SET rezzed = 1 WHERE id = %i", dbid), errbuf))
StringFormat(query,"UPDATE player_corpses SET rezzed = 1 WHERE id = %i", dbid);
if(!database.RunQuery(query, errbuf))
{
LogFile->write(EQEMuLog::Error, "MarkCorpseAsRezzed failed: %s, %s", query, errbuf);
LogFile->write(EQEMuLog::Error, "MarkCorpseAsRezzed failed: %s, %s", query.c_str(), errbuf);
}
safe_delete_array(query);
}
uint32 ZoneDatabase::CreatePlayerCorpse(uint32 charid, const char* charname, uint32 zoneid, uint16 instanceid, uchar* data, uint32 datasize, float x, float y, float z, float heading) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = new char[256+(datasize*2)];
char* end = query;
//MYSQL_RES *result;
//MYSQL_ROW row;
std::string dataSection;
uint32 affected_rows = 0;
uint32 last_insert_id = 0;
end += sprintf(end, "Insert into player_corpses SET data=");
*end++ = '\'';
end += DoEscapeString(end, (char*)data, datasize);
*end++ = '\'';
end += sprintf(end,", charname='%s', zoneid=%u, instanceid=%u, charid=%d, x=%1.1f, y=%1.1f, z=%1.1f, heading=%1.1f, timeofdeath=Now(), IsBurried=0", charname, zoneid, instanceid, charid, x, y, z, heading);
std::string endOfQuery;
std::string query = "Insert into player_corpses SET data= \'";
DoEscapeString(dataSection, (char*)data, datasize);
query.append(dataSection);
if (!RunQuery(query, (uint32) (end - query), errbuf, 0, &affected_rows, &last_insert_id)) {
safe_delete_array(query);
StringFormat(endOfQuery,"\', charname='%s', zoneid=%u, instanceid=%u, "
"charid=%d, x=%1.1f, y=%1.1f, z=%1.1f, heading=%1.1f, "
"timeofdeath=Now(), IsBurried=0",
charname, zoneid, instanceid, charid, x, y, z, heading);
query.append(endOfQuery);
if (!RunQuery(query, errbuf, 0, &affected_rows, &last_insert_id)) {
std::cerr << "Error1 in CreatePlayerCorpse query " << errbuf << std::endl;
return 0;
}
safe_delete_array(query);
if (affected_rows == 0) {
std::cerr << "Error2 in CreatePlayerCorpse query: affected_rows = 0" << std::endl;
return 0;
@ -1632,8 +1640,8 @@ uint32 ZoneDatabase::CreatePlayerCorpse(uint32 charid, const char* charname, uin
bool ZoneDatabase::CreatePlayerCorpseBackup(uint32 dbid, uint32 charid, const char* charname, uint32 zoneid, uint16 instanceid, uchar* data, uint32 datasize, float x, float y, float z, float heading) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = new char[256+(datasize*2)];
char* end = query;
std::string query;
std::string dataSection;
uint32 affected_rows = 0;
uint32 last_insert_id = 0;
bool result = false;
@ -1641,13 +1649,24 @@ bool ZoneDatabase::CreatePlayerCorpseBackup(uint32 dbid, uint32 charid, const ch
if (dbid != 0) {
if(RuleB(Character, LeaveCorpses) == true && dbpcs->level >= RuleI(Character, DeathItemLossLevel)){
end += sprintf(end, "Insert into player_corpses_backup SET data=");
*end++ = '\'';
end += DoEscapeString(end, (char*)data, datasize);
*end++ = '\'';
end += sprintf(end,", charname='%s', zoneid=%u, instanceid=%u, charid=%d, x=%1.1f, y=%1.1f, z=%1.1f, heading=%1.1f, timeofdeath=Now(), IsBurried=0, id=%u", charname, zoneid, instanceid, charid, x, y, z, heading, dbid);
query = "Insert into player_corpses_backup SET data=\'";
DoEscapeString(dataSection, (char*)data, datasize);
query.append(dataSection);
std::string endOfQuery;
StringFormat(endOfQuery, "\', charname='%s', zoneid=%u, instanceid=%u, "
"charid=%d, x=%1.1f, y=%1.1f, z=%1.1f, "
"heading=%1.1f, timeofdeath=Now(), IsBurried=0, id=%u",
charname, zoneid, instanceid, charid,
x, y, z, heading, dbid);
query.append(endOfQuery);
if (RunQuery(query, (uint32) (end - query), errbuf, 0, &affected_rows)) {
if (RunQuery(query, errbuf, 0, &affected_rows)) {
if (affected_rows == 1)
result = true;
else
@ -1656,7 +1675,6 @@ bool ZoneDatabase::CreatePlayerCorpseBackup(uint32 dbid, uint32 charid, const ch
else
std::cerr << "Error in CreatePlayerCorpseBackup query " << errbuf << std::endl;
}
safe_delete_array(query);
}
else {
std::cerr << "Error in CreatePlayerCorpseBackup: dbid = 0" << std::endl;
@ -1666,12 +1684,15 @@ bool ZoneDatabase::CreatePlayerCorpseBackup(uint32 dbid, uint32 charid, const ch
uint32 ZoneDatabase::GetPlayerBurriedCorpseCount(uint32 char_id) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
uint32 CorpseCount = 0;
if (RunQuery(query, MakeAnyLenString(&query, "select count(*) from player_corpses where charid = '%u' and IsBurried = 1", char_id), errbuf, &result)) {
StringFormat(query,"select count(*) from player_corpses "
"where charid = '%u' and IsBurried = 1", char_id);
if (RunQuery(query, errbuf, &result)) {
row = mysql_fetch_row(result);
CorpseCount = atoi(row[0]);
mysql_free_result(result);
@ -1680,19 +1701,19 @@ uint32 ZoneDatabase::GetPlayerBurriedCorpseCount(uint32 char_id) {
std::cerr << "Error in GetPlayerBurriedCorpseCount query '" << query << "' " << errbuf << std::endl;
}
safe_delete_array(query);
return CorpseCount;
}
uint32 ZoneDatabase::GetPlayerCorpseCount(uint32 char_id) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
uint32 CorpseCount = 0;
if (RunQuery(query, MakeAnyLenString(&query, "select count(*) from player_corpses where charid = '%u'", char_id), errbuf, &result)) {
StringFormat(query,"select count(*) from player_corpses where charid = '%u'", char_id);
if (RunQuery(query, errbuf, &result)) {
row = mysql_fetch_row(result);
CorpseCount = atoi(row[0]);
mysql_free_result(result);
@ -1701,19 +1722,19 @@ uint32 ZoneDatabase::GetPlayerCorpseCount(uint32 char_id) {
std::cerr << "Error in GetPlayerCorpseCount query '" << query << "' " << errbuf << std::endl;
}
safe_delete_array(query);
return CorpseCount;
}
uint32 ZoneDatabase::GetPlayerCorpseID(uint32 char_id, uint8 corpse) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
uint32 id = 0;
if (RunQuery(query, MakeAnyLenString(&query, "select id from player_corpses where charid = '%u'", char_id), errbuf, &result)) {
StringFormat(query,"select id from player_corpses where charid = '%u'", char_id);
if (RunQuery(query, errbuf, &result)) {
for (int i=0; i<corpse;i++) {
row = mysql_fetch_row(result);
id = (uint32)atoi(row[0]);
@ -1724,8 +1745,6 @@ uint32 ZoneDatabase::GetPlayerCorpseID(uint32 char_id, uint8 corpse) {
std::cerr << "Error in GetPlayerCorpseID query '" << query << "' " << errbuf << std::endl;
}
safe_delete_array(query);
return id;
}
@ -1742,13 +1761,17 @@ uint32 ZoneDatabase::GetPlayerCorpseItemAt(uint32 corpse_id, uint16 slotid) {
Corpse* ZoneDatabase::SummonBurriedPlayerCorpse(uint32 char_id, uint32 dest_zoneid, uint16 dest_instanceid, float dest_x, float dest_y, float dest_z, float dest_heading) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
Corpse* NewCorpse = 0;
unsigned long* lengths;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT id, charname, data, timeofdeath, rezzed FROM player_corpses WHERE charid='%u' AND IsBurried=1 ORDER BY timeofdeath LIMIT 1", char_id), errbuf, &result)) {
StringFormat(query,"SELECT id, charname, data, timeofdeath, rezzed "
"FROM player_corpses WHERE charid='%u' AND "
"IsBurried=1 ORDER BY timeofdeath LIMIT 1", char_id);
if (RunQuery(query, errbuf, &result)) {
row = mysql_fetch_row(result);
lengths = mysql_fetch_lengths(result);
if(row) {
@ -1770,8 +1793,6 @@ Corpse* ZoneDatabase::SummonBurriedPlayerCorpse(uint32 char_id, uint32 dest_zone
std::cerr << "Error in SummonBurriedPlayerCorpse query '" << query << "' " << errbuf << std::endl;
}
safe_delete_array(query);
return NewCorpse;
}
@ -1779,22 +1800,26 @@ bool ZoneDatabase::SummonAllPlayerCorpses(uint32 char_id, uint32 dest_zoneid, ui
float dest_x, float dest_y, float dest_z, float dest_heading)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
Corpse* NewCorpse = 0;
int CorpseCount = 0;
unsigned long* lengths;
if(!RunQuery(query, MakeAnyLenString(&query, "UPDATE player_corpses SET zoneid = %i, instanceid = %i, x = %f, y = %f, z = %f, "
"heading = %f, IsBurried = 0, WasAtGraveyard = 0 WHERE charid = %i",
dest_zoneid, dest_instanceid, dest_x, dest_y, dest_z, dest_heading, char_id), errbuf))
LogFile->write(EQEMuLog::Error, "Error moving corpses, Query = %s, Error = %s\n", query, errbuf);
StringFormat(query,"UPDATE player_corpses SET zoneid = %i, instanceid = %i, x = %f, y = %f, z = %f, "
"heading = %f, IsBurried = 0, WasAtGraveyard = 0 WHERE charid = %i",
dest_zoneid, dest_instanceid, dest_x, dest_y, dest_z, dest_heading, char_id);
safe_delete_array(query);
if(!RunQuery(query, errbuf))
LogFile->write(EQEMuLog::Error, "Error moving corpses, Query = %s, Error = %s\n", query.c_str(), errbuf);
if (RunQuery(query, MakeAnyLenString(&query, "SELECT id, charname, data, timeofdeath, rezzed FROM player_corpses WHERE charid='%u'"
"ORDER BY timeofdeath", char_id), errbuf, &result))
StringFormat(query,"SELECT id, charname, data, timeofdeath, rezzed "
"FROM player_corpses WHERE charid='%u'"
"ORDER BY timeofdeath",
char_id);
if (RunQuery(query, errbuf, &result))
{
while((row = mysql_fetch_row(result)))
{
@ -1814,23 +1839,24 @@ bool ZoneDatabase::SummonAllPlayerCorpses(uint32 char_id, uint32 dest_zoneid, ui
mysql_free_result(result);
}
else
LogFile->write(EQEMuLog::Error, "Error in SummonAllPlayerCorpses Query = %s, Error = %s\n", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in SummonAllPlayerCorpses Query = %s, Error = %s\n", query.c_str(), errbuf);
return (CorpseCount > 0);
}
bool ZoneDatabase::UnburyPlayerCorpse(uint32 dbid, uint32 new_zoneid, uint16 new_instanceid, float new_x, float new_y, float new_z, float new_heading) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = new char[256];
char* end = query;
std::string query;
uint32 affected_rows = 0;
bool Result = false;
end += sprintf(end, "UPDATE player_corpses SET IsBurried=0, zoneid=%u, instanceid=%u, x=%f, y=%f, z=%f, heading=%f, timeofdeath=Now(), WasAtGraveyard=0 WHERE id=%u", new_zoneid, new_instanceid, new_x, new_y, new_z, new_heading, dbid);
StringFormat(query,"UPDATE player_corpses SET IsBurried=0, zoneid=%u, "
"instanceid=%u, x=%f, y=%f, z=%f, heading=%f, "
"timeofdeath=Now(), WasAtGraveyard=0 WHERE id=%u",
new_zoneid, new_instanceid, new_x, new_y, new_z,
new_heading, dbid);
if (RunQuery(query, (uint32) (end - query), errbuf, 0, &affected_rows)) {
if (RunQuery(query, errbuf, 0, &affected_rows)) {
if (affected_rows == 1)
Result = true;
else
@ -1839,26 +1865,29 @@ bool ZoneDatabase::UnburyPlayerCorpse(uint32 dbid, uint32 new_zoneid, uint16 new
else
std::cerr << "Error1 in UnburyPlayerCorpse query " << errbuf << std::endl;
safe_delete_array(query);
return Result;
}
Corpse* ZoneDatabase::LoadPlayerCorpse(uint32 player_corpse_id) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
Corpse* NewCorpse = 0;
unsigned long* lengths;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT id, charid, charname, x, y, z, heading, data, timeofdeath, rezzed, WasAtGraveyard FROM player_corpses WHERE id='%u'", player_corpse_id), errbuf, &result)) {
StringFormat(query,"SELECT id, charid, charname, x, y, z, "
"heading, data, timeofdeath, rezzed, WasAtGraveyard "
"FROM player_corpses WHERE id='%u'",
player_corpse_id);
if (RunQuery(query, errbuf, &result)) {
row = mysql_fetch_row(result);
lengths = mysql_fetch_lengths(result);
if(row && lengths)
{
NewCorpse = Corpse::LoadFromDBData(atoi(row[0]), atoi(row[1]), row[2], (uchar*) row[7], lengths[7], atof(row[3]), atoi(row[4]), atoi(row[5]), atoi(row[6]), row[8],atoi(row[9])==1, atoi(row[10]));
entity_list.AddCorpse(NewCorpse);
NewCorpse = Corpse::LoadFromDBData(atoi(row[0]), atoi(row[1]), row[2], (uchar*) row[7], lengths[7], atof(row[3]), atoi(row[4]), atoi(row[5]), atoi(row[6]), row[8],atoi(row[9])==1, atoi(row[10]));
entity_list.AddCorpse(NewCorpse);
}
mysql_free_result(result);
}
@ -1867,27 +1896,35 @@ Corpse* ZoneDatabase::LoadPlayerCorpse(uint32 player_corpse_id) {
std::cerr << "Note that if your missing the 'rezzed' field you can add it with:\nALTER TABLE `player_corpses` ADD `rezzed` TINYINT UNSIGNED DEFAULT \"0\";\n";
}
safe_delete_array(query);
return NewCorpse;
}
bool ZoneDatabase::LoadPlayerCorpses(uint32 iZoneID, uint16 iInstanceID) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
uint32 query_length = 0;
unsigned long* lengths;
if(!RuleB(Zone, EnableShadowrest))
query_length = MakeAnyLenString(&query, "SELECT id, charid, charname, x, y, z, heading, data, timeofdeath, rezzed, WasAtGraveyard FROM player_corpses WHERE zoneid='%u' AND instanceid='%u'", iZoneID, iInstanceID);
else
query_length = MakeAnyLenString(&query, "SELECT id, charid, charname, x, y, z, heading, data, timeofdeath, rezzed, 0 FROM player_corpses WHERE zoneid='%u' AND instanceid='%u' AND IsBurried=0", iZoneID, iInstanceID);
if(!RuleB(Zone, EnableShadowrest)) {
StringFormat(query, "SELECT id, charid, charname, x, y, z, "
"heading, data, timeofdeath, rezzed, "
"WasAtGraveyard FROM player_corpses WHERE "
"zoneid='%u' AND instanceid='%u'",
iZoneID, iInstanceID);
}
else {
StringFormat(query, "SELECT id, charid, charname, x, y, z, "
"heading, data, timeofdeath, rezzed, 0 "
"FROM player_corpses WHERE zoneid='%u' "
"AND instanceid='%u' AND IsBurried=0",
iZoneID, iInstanceID);
}
if (RunQuery(query, query_length, errbuf, &result)) {
safe_delete_array(query);
if (RunQuery(query, errbuf, &result)) {
while ((row = mysql_fetch_row(result))) {
lengths = mysql_fetch_lengths(result);
entity_list.AddCorpse(Corpse::LoadFromDBData(atoi(row[0]), atoi(row[1]), row[2], (uchar*) row[7], lengths[7], atof(row[3]), atoi(row[4]), atoi(row[5]), atoi(row[6]), row[8],atoi(row[9])==1, atoi(row[10])));
@ -1897,7 +1934,6 @@ bool ZoneDatabase::LoadPlayerCorpses(uint32 iZoneID, uint16 iInstanceID) {
else {
std::cerr << "Error in LoadPlayerCorpses query '" << query << "' " << errbuf << std::endl;
std::cerr << "Note that if your missing the 'rezzed' field you can add it with:\nALTER TABLE `player_corpses` ADD `rezzed` TINYINT UNSIGNED DEFAULT \"0\";\n";
safe_delete_array(query);
return false;
}
@ -1906,68 +1942,68 @@ bool ZoneDatabase::LoadPlayerCorpses(uint32 iZoneID, uint16 iInstanceID) {
uint32 ZoneDatabase::GetFirstCorpseID(uint32 char_id) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
uint32 CorpseID = 0;
MakeAnyLenString(&query, "SELECT id FROM player_corpses WHERE charid='%u' AND IsBurried=0 ORDER BY timeofdeath LIMIT 1", char_id);
if (RunQuery(query, strlen(query), errbuf, &result)) {
if (mysql_num_rows(result)!= 0){
row = mysql_fetch_row(result);
CorpseID = atoi(row[0]);
mysql_free_result(result);
}
StringFormat(query, "SELECT id FROM player_corpses WHERE charid='%u' "
"AND IsBurried=0 ORDER BY timeofdeath LIMIT 1",
char_id);
if (RunQuery(query, errbuf, &result)) {
if (mysql_num_rows(result)!= 0) {
row = mysql_fetch_row(result);
CorpseID = atoi(row[0]);
mysql_free_result(result);
}
}
else {
std::cerr << "Error in GetFirstCorpseID query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return 0;
}
safe_delete_array(query);
return CorpseID;
}
bool ZoneDatabase::BuryPlayerCorpse(uint32 dbid) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
if (!RunQuery(query, MakeAnyLenString(&query, "UPDATE player_corpses SET IsBurried = 1 WHERE id=%d", dbid), errbuf)) {
StringFormat(query,"UPDATE player_corpses SET IsBurried = 1 WHERE id=%d", dbid);
if (!RunQuery(query, errbuf)) {
std::cerr << "Error in BuryPlayerCorpse query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return false;
}
safe_delete_array(query);
return true;
}
bool ZoneDatabase::BuryAllPlayerCorpses(uint32 charid) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
if (!RunQuery(query, MakeAnyLenString(&query, "UPDATE player_corpses SET IsBurried = 1 WHERE charid=%d", charid), errbuf)) {
StringFormat(query,"UPDATE player_corpses SET IsBurried = 1 WHERE charid=%d", charid);
if (!RunQuery(query, errbuf)) {
std::cerr << "Error in BuryPlayerCorpse query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return false;
}
safe_delete_array(query);
return true;
}
bool ZoneDatabase::DeletePlayerCorpse(uint32 dbid) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
if (!RunQuery(query, MakeAnyLenString(&query, "Delete from player_corpses where id=%d", dbid), errbuf)) {
StringFormat(query,"Delete from player_corpses where id=%d", dbid);
if (!RunQuery(query, errbuf)) {
std::cerr << "Error in DeletePlayerCorpse query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return false;
}
safe_delete_array(query);
return true;
}
@ -2022,11 +2058,15 @@ void Corpse::LoadPlayerCorpseDecayTime(uint32 dbid){
if(!dbid)
return;
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (database.RunQuery(query, MakeAnyLenString(&query, "SELECT (UNIX_TIMESTAMP() - UNIX_TIMESTAMP(timeofdeath)) FROM player_corpses WHERE id=%d and not timeofdeath=0", dbid), errbuf, &result)) {
safe_delete_array(query);
StringFormat(query,"SELECT (UNIX_TIMESTAMP() - UNIX_TIMESTAMP(timeofdeath)) "
"FROM player_corpses WHERE id=%d and not timeofdeath=0",
dbid);
if (database.RunQuery(query, errbuf, &result)) {
while ((row = mysql_fetch_row(result))) {
if(atoi(row[0]) > 0 && RuleI(Character, CorpseDecayTimeMS) > (atoi(row[0]) * 1000)) {
corpse_decay_timer.SetTimer(RuleI(Character, CorpseDecayTimeMS) - (atoi(row[0]) * 1000));
@ -2054,8 +2094,6 @@ void Corpse::LoadPlayerCorpseDecayTime(uint32 dbid){
}
mysql_free_result(result);
}
else
safe_delete_array(query);
}
/*

37
zone/QGlobals.cpp
View File

@ -140,12 +140,14 @@ void QGlobalCache::PurgeExpiredGlobals()
void QGlobalCache::LoadByNPCID(uint32 npcID)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (database.RunQuery(query, MakeAnyLenString(&query, "select name, charid, npcid, zoneid, value, expdate"
" from quest_globals where npcid = %d", npcID), errbuf, &result))
StringFormat(query,"select name, charid, npcid, zoneid, value, expdate"
" from quest_globals where npcid = %d", npcID);
if (database.RunQuery(query, errbuf, &result))
{
while((row = mysql_fetch_row(result)))
{
@ -153,18 +155,20 @@ void QGlobalCache::LoadByNPCID(uint32 npcID)
}
mysql_free_result(result);
}
safe_delete_array(query);
}
void QGlobalCache::LoadByCharID(uint32 charID)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (database.RunQuery(query, MakeAnyLenString(&query, "select name, charid, npcid, zoneid, value, expdate from"
" quest_globals where charid = %d && npcid = 0", charID), errbuf, &result))
StringFormat(query,"select name, charid, npcid, zoneid, value, expdate from "
"quest_globals where charid = %d && npcid = 0",
charID);
if (database.RunQuery(query, errbuf, &result))
{
while((row = mysql_fetch_row(result)))
{
@ -172,18 +176,19 @@ void QGlobalCache::LoadByCharID(uint32 charID)
}
mysql_free_result(result);
}
safe_delete_array(query);
}
void QGlobalCache::LoadByZoneID(uint32 zoneID)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (database.RunQuery(query, MakeAnyLenString(&query, "select name, charid, npcid, zoneid, value, expdate from quest_globals"
" where zoneid = %d && npcid = 0 && charid = 0", zoneID), errbuf, &result))
StringFormat(query,"select name, charid, npcid, zoneid, value, expdate from quest_globals"
" where zoneid = %d && npcid = 0 && charid = 0", zoneID);
if (database.RunQuery(query, errbuf, &result))
{
while((row = mysql_fetch_row(result)))
{
@ -191,17 +196,18 @@ void QGlobalCache::LoadByZoneID(uint32 zoneID)
}
mysql_free_result(result);
}
safe_delete_array(query);
}
void QGlobalCache::LoadByGlobalContext()
{
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (database.RunQuery(query, MakeAnyLenString(&query, "select name, charid, npcid, zoneid, value, expdate from quest_globals"
" where zoneid = 0 && npcid = 0 && charid = 0"), errbuf, &result))
query = "select name, charid, npcid, zoneid, value, expdate from quest_globals"
" where zoneid = 0 && npcid = 0 && charid = 0";
if (database.RunQuery(query, errbuf, &result))
{
while((row = mysql_fetch_row(result)))
{
@ -209,5 +215,4 @@ void QGlobalCache::LoadByGlobalContext()
}
mysql_free_result(result);
}
safe_delete_array(query);
}

534
zone/bot.cpp
View File

File diff suppressed because it is too large Load Diff

268
zone/client.cpp
View File

@ -599,13 +599,17 @@ bool Client::Save(uint8 iCommitNow) {
SaveTaskState();
if (iCommitNow <= 1) {
char* query = 0;
std::string query;
uint32_breakdown workpt;
workpt.b4() = DBA_b4_Entity;
workpt.w2_3() = GetID();
workpt.b1() = DBA_b1_Entity_Client_Save;
DBAsyncWork* dbaw = new DBAsyncWork(&database, &MTdbafq, workpt, DBAsync::Write, 0xFFFFFFFF);
dbaw->AddQuery(iCommitNow == 0 ? true : false, &query, database.SetPlayerProfile_MQ(&query, account_id, character_id, &m_pp, &m_inv, &m_epp, 0, 0, MaxXTargets), false);
database.SetPlayerProfile_MQ(query, account_id, character_id, &m_pp, &m_inv, &m_epp, 0, 0, MaxXTargets);
dbaw->AddQuery(iCommitNow == 0 ? true : false, query, false);
if (iCommitNow == 0){
pQueuedSaveWorkID = dbasync->AddWork(&dbaw, 2500);
}
@ -613,7 +617,6 @@ bool Client::Save(uint8 iCommitNow) {
dbasync->AddWork(&dbaw, 0);
SaveBackup();
}
safe_delete_array(query);
return true;
}
else if (database.SetPlayerProfile(account_id, character_id, &m_pp, &m_inv, &m_epp, 0, 0, MaxXTargets)) {
@ -630,9 +633,14 @@ bool Client::Save(uint8 iCommitNow) {
void Client::SaveBackup() {
if (!RunLoops)
return;
char* query = 0;
std::string query;
DBAsyncWork* dbaw = new DBAsyncWork(&database, &DBAsyncCB_CharacterBackup, this->CharacterID(), DBAsync::Read);
dbaw->AddQuery(0, &query, MakeAnyLenString(&query, "Select id, UNIX_TIMESTAMP()-UNIX_TIMESTAMP(ts) as age from character_backup where charid=%u and backupreason=0 order by ts asc", this->CharacterID()), true);
StringFormat(query,"Select id, UNIX_TIMESTAMP()-UNIX_TIMESTAMP(ts) as age "
"from character_backup where charid=%u and backupreason=0 "
"order by ts asc", this->CharacterID());
dbaw->AddQuery(0, query, true);
dbasync->AddWork(&dbaw, 0);
}
@ -3849,22 +3857,20 @@ void Client::SendWindow(uint32 PopupID, uint32 NegativeID, uint32 Buttons, const
void Client::KeyRingLoad()
{
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
query = new char[256];
sprintf(query, "SELECT item_id FROM keyring WHERE char_id='%i' ORDER BY item_id",character_id);
if (database.RunQuery(query, strlen(query), errbuf, &result))
std::string query;
StringFormat(query, "SELECT item_id FROM keyring WHERE char_id='%i' ORDER BY item_id",character_id);
if (database.RunQuery(query, errbuf, &result))
{
safe_delete_array(query);
while(0 != (row = mysql_fetch_row(result))){
keyring.push_back(atoi(row[0]));
}
mysql_free_result(result);
}else {
std::cerr << "Error in Client::KeyRingLoad query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return;
}
}
@ -3873,21 +3879,21 @@ void Client::KeyRingAdd(uint32 item_id)
{
if(0==item_id)return;
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
uint32 affected_rows = 0;
query = new char[256];
std::string query;
bool bFound = KeyRingCheck(item_id);
if(!bFound){
sprintf(query, "INSERT INTO keyring(char_id,item_id) VALUES(%i,%i)",character_id,item_id);
if(database.RunQuery(query, strlen(query), errbuf, 0, &affected_rows))
StringFormat(query, "INSERT INTO keyring(char_id,item_id) VALUES(%i,%i)",
character_id, item_id);
if(database.RunQuery(query, errbuf, 0, &affected_rows))
{
Message(4,"Added to keyring.");
safe_delete_array(query);
}
else
{
std::cerr << "Error in Doors::HandleClick query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return;
}
keyring.push_back(item_id);
@ -3923,17 +3929,18 @@ void Client::KeyRingList()
bool Client::IsDiscovered(uint32 itemid) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (database.RunQuery(query, MakeAnyLenString(&query, "SELECT count(*) FROM discovered_items WHERE item_id = '%lu'", itemid), errbuf, &result))
StringFormat(query,"SELECT count(*) FROM discovered_items WHERE item_id = '%lu'", itemid);
if (database.RunQuery(query, errbuf, &result))
{
row = mysql_fetch_row(result);
if (atoi(row[0]))
{
mysql_free_result(result);
safe_delete_array(query);
return true;
}
}
@ -3942,20 +3949,24 @@ bool Client::IsDiscovered(uint32 itemid) {
std::cerr << "Error in IsDiscovered query '" << query << "' " << errbuf << std::endl;
}
mysql_free_result(result);
safe_delete_array(query);
return false;
}
void Client::DiscoverItem(uint32 itemid) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
if (database.RunQuery(query,MakeAnyLenString(&query, "INSERT INTO discovered_items SET item_id=%lu, char_name='%s', discovered_date=UNIX_TIMESTAMP(), account_status=%i", itemid, GetName(), Admin()), errbuf, &result))
StringFormat(query,"INSERT INTO discovered_items SET "
"item_id=%lu, char_name='%s', "
"discovered_date=UNIX_TIMESTAMP(), account_status=%i",
itemid, GetName(), Admin());
if (database.RunQuery(query, errbuf, &result))
{
mysql_free_result(result);
}
safe_delete_array(query);
parse->EventPlayer(EVENT_DISCOVER_ITEM, this, "", itemid);
}
@ -5099,13 +5110,16 @@ void Client::SendRewards()
{
std::vector<ClientReward> rewards;
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if(database.RunQuery(query,MakeAnyLenString(&query,"SELECT reward_id, amount FROM"
" account_rewards WHERE account_id=%i ORDER by reward_id", AccountID()),
errbuf,&result))
StringFormat(query, "SELECT reward_id, amount FROM"
" account_rewards WHERE account_id=%i "
"ORDER by reward_id",
AccountID());
if(database.RunQuery(query,errbuf,&result))
{
while((row = mysql_fetch_row(result)))
{
@ -5115,12 +5129,10 @@ void Client::SendRewards()
rewards.push_back(cr);
}
mysql_free_result(result);
safe_delete_array(query);
}
else
{
LogFile->write(EQEMuLog::Error, "Error in Client::SendRewards(): %s (%s)", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in Client::SendRewards(): %s (%s)", query.c_str(), errbuf);
return;
}
@ -5188,14 +5200,18 @@ bool Client::TryReward(uint32 claim_id)
}
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
uint32 amt = 0;
if(database.RunQuery(query,MakeAnyLenString(&query,"SELECT amount FROM"
" account_rewards WHERE account_id=%i AND reward_id=%i", AccountID(), claim_id),
errbuf,&result))
StringFormat(query, "SELECT amount FROM"
" account_rewards WHERE "
"account_id=%i AND reward_id=%i",
AccountID(), claim_id);
if(database.RunQuery(query,errbuf,&result))
{
row = mysql_fetch_row(result);
if(row)
@ -5205,16 +5221,13 @@ bool Client::TryReward(uint32 claim_id)
else
{
mysql_free_result(result);
safe_delete_array(query);
return false;
}
mysql_free_result(result);
safe_delete_array(query);
}
else
{
LogFile->write(EQEMuLog::Error, "Error in Client::TryReward(): %s (%s)", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in Client::TryReward(): %s (%s)", query.c_str(), errbuf);
return false;
}
@ -5240,30 +5253,24 @@ bool Client::TryReward(uint32 claim_id)
if(amt == 1)
{
if(!database.RunQuery(query,MakeAnyLenString(&query,"DELETE FROM"
" account_rewards WHERE account_id=%i AND reward_id=%i", AccountID(), claim_id),
errbuf))
StringFormat(query, "DELETE FROM account_rewards WHERE "
"account_id=%i AND reward_id=%i",
AccountID(), claim_id);
if(!database.RunQuery(query, errbuf))
{
LogFile->write(EQEMuLog::Error, "Error in Client::TryReward(): %s (%s)", query, errbuf);
safe_delete_array(query);
}
else
{
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in Client::TryReward(): %s (%s)", query.c_str(), errbuf);
}
}
else
{
if(!database.RunQuery(query,MakeAnyLenString(&query,"UPDATE account_rewards SET amount=(amount-1)"
" WHERE account_id=%i AND reward_id=%i", AccountID(), claim_id),
errbuf))
StringFormat(query,"UPDATE account_rewards SET amount=(amount-1)"
" WHERE account_id=%i AND reward_id=%i",
AccountID(), claim_id);
if(!database.RunQuery(query,errbuf))
{
LogFile->write(EQEMuLog::Error, "Error in Client::TryReward(): %s (%s)", query, errbuf);
safe_delete_array(query);
}
else
{
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in Client::TryReward(): %s (%s)", query.c_str(), errbuf);
}
}
@ -7630,107 +7637,112 @@ some day.
void Client::LoadAccountFlags()
{
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
char errbuf[MYSQL_ERRMSG_SIZE];
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
accountflags.clear();
MakeAnyLenString(&query, "SELECT p_flag, p_value FROM account_flags WHERE p_accid = '%d'", account_id);
if(database.RunQuery(query, strlen(query), errbuf, &result))
{
while(row = mysql_fetch_row(result))
{
std::string fname(row[0]);
std::string fval(row[1]);
accountflags[fname] = fval;
}
mysql_free_result(result);
}
else
{
std::cerr << "Error in LoadAccountFlags query '" << query << "' " << errbuf << std::endl;
}
safe_delete_array(query);
accountflags.clear();
StringFormat(query,"SELECT p_flag, p_value FROM "
"account_flags WHERE p_accid = '%d'",
account_id);
if(database.RunQuery(query, errbuf, &result))
{
while(row = mysql_fetch_row(result))
{
std::string fname(row[0]);
std::string fval(row[1]);
accountflags[fname] = fval;
}
mysql_free_result(result);
}
else
{
std::cerr << "Error in LoadAccountFlags query '" << query << "' " << errbuf << std::endl;
}
}
void Client::SetAccountFlag(std::string flag, std::string val)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
char errbuf[MYSQL_ERRMSG_SIZE];
std::string query;
StringFormat(query, "REPLACE INTO account_flags (p_accid, p_flag, p_value) "
"VALUES( '%d', '%s', '%s')",
account_id, flag.c_str(), val.c_str());
if(!database.RunQuery(query, errbuf))
{
std::cerr << "Error in SetAccountFlags query '" << query << "' " << errbuf << std::endl;
}
MakeAnyLenString(&query, "REPLACE INTO account_flags (p_accid, p_flag, p_value) VALUES( '%d', '%s', '%s')", account_id, flag.c_str(), val.c_str());
if(!database.RunQuery(query, strlen(query), errbuf))
{
std::cerr << "Error in SetAccountFlags query '" << query << "' " << errbuf << std::endl;
}
safe_delete_array(query);
accountflags[flag] = val;
accountflags[flag] = val;
}
std::string Client::GetAccountFlag(std::string flag)
{
return(accountflags[flag]);
return(accountflags[flag]);
}
void Client::TickItemCheck()
{
int i;
int i;
if(zone->tick_items.empty()) { return; }
//Scan equip slots for items
for(i = 0; i <= 21; i++)
{
//Scan equip slots for items
for(i = 0; i <= 21; i++)
{
TryItemTick(i);
}
//Scan main inventory + cursor
for(i = 22; i < 31; i++)
{
}
//Scan main inventory + cursor
for(i = 22; i < 31; i++)
{
TryItemTick(i);
}
//Scan bags
for(i = 251; i < 340; i++)
{
}
//Scan bags
for(i = 251; i < 340; i++)
{
TryItemTick(i);
}
}
}
void Client::TryItemTick(int slot)
{
int iid = 0;
const ItemInst* inst = m_inv[slot];
if(inst == 0) { return; }
const ItemInst* inst = m_inv[slot];
if(inst == 0) { return; }
iid = inst->GetID();
iid = inst->GetID();
if(zone->tick_items.count(iid) > 0)
{
if( GetLevel() >= zone->tick_items[iid].level && MakeRandomInt(0, 100) >= (100 - zone->tick_items[iid].chance) && (zone->tick_items[iid].bagslot || slot < 22) )
{
ItemInst* e_inst = (ItemInst*)inst;
parse->EventItem(EVENT_ITEM_TICK, this, e_inst, e_inst->GetID(), slot);
}
}
if(zone->tick_items.count(iid) > 0)
{
if( GetLevel() >= zone->tick_items[iid].level && MakeRandomInt(0, 100) >= (100 - zone->tick_items[iid].chance) && (zone->tick_items[iid].bagslot || slot < 22) )
{
ItemInst* e_inst = (ItemInst*)inst;
parse->EventItem(EVENT_ITEM_TICK, this, e_inst, e_inst->GetID(), slot);
}
}
//Only look at augs in main inventory
if(slot > 21) { return; }
for(int x = 0; x < MAX_AUGMENT_SLOTS; ++x)
{
ItemInst * a_inst = inst->GetAugment(x);
if(!a_inst) { continue; }
for(int x = 0; x < MAX_AUGMENT_SLOTS; ++x)
{
ItemInst * a_inst = inst->GetAugment(x);
if(!a_inst) { continue; }
iid = a_inst->GetID();
iid = a_inst->GetID();
if(zone->tick_items.count(iid) > 0)
{
if( GetLevel() >= zone->tick_items[iid].level && MakeRandomInt(0, 100) >= (100 - zone->tick_items[iid].chance) )
{
ItemInst* e_inst = (ItemInst*)a_inst;
parse->EventItem(EVENT_ITEM_TICK, this, e_inst, e_inst->GetID(), slot);
}
}
}
if(zone->tick_items.count(iid) > 0)
{
if( GetLevel() >= zone->tick_items[iid].level && MakeRandomInt(0, 100) >= (100 - zone->tick_items[iid].chance) )
{
ItemInst* e_inst = (ItemInst*)a_inst;
parse->EventItem(EVENT_ITEM_TICK, this, e_inst, e_inst->GetID(), slot);
}
}
}
}

2
zone/client.h
View File

@ -659,7 +659,7 @@ public:
inline uint16 MaxSkill(SkillType skillid) const { return MaxSkill(skillid, GetClass(), GetLevel()); }
uint8 SkillTrainLevel(SkillType skillid, uint16 class_);
void TradeskillSearchResults(const char *query, unsigned long qlen, unsigned long objtype, unsigned long someid);
void TradeskillSearchResults(const std::string query, unsigned long qlen, unsigned long objtype, unsigned long someid);
void SendTradeskillDetails(uint32 recipe_id);
bool TradeskillExecute(DBTradeskillRecipe_Struct *spec);
void CheckIncreaseTradeskill(int16 bonusstat, int16 stat_modifier, float skillup_modifier, uint16 success_modifier, SkillType tradeskill);

248
zone/client_packet.cpp
View File

@ -537,23 +537,37 @@ void Client::Handle_Connect_OP_ZoneEntry(const EQApplicationPacket *app)
client->Disconnect();
}
char* query = 0;
uint32_breakdown workpt;
workpt.b4() = DBA_b4_Entity;
workpt.w2_3() = GetID();
workpt.b1() = DBA_b1_Entity_Client_InfoForLogin;
DBAsyncWork* dbaw = new DBAsyncWork(&database, &MTdbafq, workpt, DBAsync::Read);
dbaw->AddQuery(1, &query, MakeAnyLenString(&query,
"SELECT status,name,lsaccount_id,gmspeed,revoked,hideme,time_creation FROM account WHERE id=%i",
account_id));
std::string accountQuery;
StringFormat(accountQuery,"SELECT status, name, lsaccount_id, gmspeed, "
"revoked, hideme, time_creation FROM account "
"WHERE id=%i", account_id);
dbaw->AddQuery(1, accountQuery);
//DO NOT FORGET TO EDIT ZoneDatabase::GetCharacterInfoForLogin if you change this
dbaw->AddQuery(2, &query, MakeAnyLenString(&query,
"SELECT id,profile,zonename,x,y,z,guild_id,rank,extprofile,class,level,lfp,lfg,instanceid,xtargets,firstlogon"
" FROM character_ LEFT JOIN guild_members ON id=char_id WHERE id=%i",
character_id));
dbaw->AddQuery(3, &query, MakeAnyLenString(&query,
"SELECT faction_id,current_value FROM faction_values WHERE temp = 0 AND char_id = %i",
character_id));
std::string characterInfoQuery;
StringFormat(characterInfoQuery,"SELECT id, profile, zonename, x, y, z, "
"guild_id, rank, extprofile, class, "
"level, lfp, lfg, instanceid, xtargets, "
"firstlogon FROM character_ LEFT JOIN "
"guild_members ON id=char_id WHERE id=%i",
character_id);
dbaw->AddQuery(2, characterInfoQuery);
std::string characterFactionQuery;
StringFormat(characterFactionQuery, "SELECT faction_id,current_value FROM "
"faction_values WHERE temp = 0 AND "
"char_id = %i", character_id);
dbaw->AddQuery(3, characterFactionQuery);
if (!(pDBAsyncWorkID = dbasync->AddWork(&dbaw))) {
safe_delete(dbaw);
LogFile->write(EQEMuLog::Error,"dbasync->AddWork() returned false, client crash");
@ -2070,28 +2084,28 @@ void Client::Handle_OP_ItemVerifyRequest(const EQApplicationPacket *app)
}
}
int r;
bool tryaug = false;
ItemInst* clickaug = 0;
Item_Struct* augitem = 0;
int r;
bool tryaug = false;
ItemInst* clickaug = 0;
Item_Struct* augitem = 0;
for(r = 0; r < MAX_AUGMENT_SLOTS; r++) {
const ItemInst* aug_i = inst->GetAugment(r);
if(!aug_i)
continue;
const Item_Struct* aug = aug_i->GetItem();
if(!aug)
continue;
for(r = 0; r < MAX_AUGMENT_SLOTS; r++) {
const ItemInst* aug_i = inst->GetAugment(r);
if(!aug_i)
continue;
const Item_Struct* aug = aug_i->GetItem();
if(!aug)
continue;
if ( (aug->Click.Type == ET_ClickEffect) || (aug->Click.Type == ET_Expendable) || (aug->Click.Type == ET_EquipClick) || (aug->Click.Type == ET_ClickEffect2) )
{
tryaug = true;
clickaug = (ItemInst*)aug_i;
augitem = (Item_Struct*)aug;
spell_id = aug->Click.Effect;
break;
}
}
if ( (aug->Click.Type == ET_ClickEffect) || (aug->Click.Type == ET_Expendable) || (aug->Click.Type == ET_EquipClick) || (aug->Click.Type == ET_ClickEffect2) )
{
tryaug = true;
clickaug = (ItemInst*)aug_i;
augitem = (Item_Struct*)aug;
spell_id = aug->Click.Effect;
break;
}
}
if((spell_id <= 0) && (item->ItemType != ItemTypeFood && item->ItemType != ItemTypeDrink && item->ItemType != ItemTypeAlcohol && item->ItemType != ItemTypeSpell))
{
@ -2140,39 +2154,39 @@ void Client::Handle_OP_ItemVerifyRequest(const EQApplicationPacket *app)
return;
}
}
else if (tryaug)
{
if (clickaug->GetCharges() == 0)
{
//Message(0, "This item is out of charges.");
Message_StringID(13, ITEM_OUT_OF_CHARGES);
return;
}
if(GetLevel() >= augitem->Click.Level2)
{
if(parse->ItemHasQuestSub(clickaug, "EVENT_ITEM_CLICK_CAST"))
{
//TODO: need to enforce and set recast timers here because the spell may not be cast.
parse->EventItem(EVENT_ITEM_CLICK_CAST, this, clickaug, clickaug->GetID(), slot_id);
inst = m_inv[slot_id];
if (!inst)
{
// Item was deleted by the perl event
return;
}
}
else
{
//We assume augs aren't consumable
CastSpell(augitem->Click.Effect, target_id, 10, augitem->CastTime, 0, 0, slot_id);
}
}
else
{
Message_StringID(13, ITEMS_INSUFFICIENT_LEVEL);
return;
}
}
else if (tryaug)
{
if (clickaug->GetCharges() == 0)
{
//Message(0, "This item is out of charges.");
Message_StringID(13, ITEM_OUT_OF_CHARGES);
return;
}
if(GetLevel() >= augitem->Click.Level2)
{
if(parse->ItemHasQuestSub(clickaug, "EVENT_ITEM_CLICK_CAST"))
{
//TODO: need to enforce and set recast timers here because the spell may not be cast.
parse->EventItem(EVENT_ITEM_CLICK_CAST, this, clickaug, clickaug->GetID(), slot_id);
inst = m_inv[slot_id];
if (!inst)
{
// Item was deleted by the perl event
return;
}
}
else
{
//We assume augs aren't consumable
CastSpell(augitem->Click.Effect, target_id, 10, augitem->CastTime, 0, 0, slot_id);
}
}
else
{
Message_StringID(13, ITEMS_INSUFFICIENT_LEVEL);
return;
}
}
else
{
if(GetClientVersion() >= EQClientSoD && !inst->IsEquipable(GetBaseRace(),GetClass()))
@ -3227,12 +3241,13 @@ void Client::Handle_OP_ItemLinkClick(const EQApplicationPacket *app)
if (sayid && sayid > 0)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if(database.RunQuery(query,MakeAnyLenString(&query,"SELECT `phrase` FROM saylink WHERE `id` = '%i'", sayid),errbuf,&result))
StringFormat(query, "SELECT `phrase` FROM saylink WHERE `id` = '%i'", sayid);
if(database.RunQuery(query,errbuf,&result))
{
if (mysql_num_rows(result) == 1)
{
@ -3244,10 +3259,8 @@ void Client::Handle_OP_ItemLinkClick(const EQApplicationPacket *app)
else
{
Message(13, "Error: The saylink (%s) was not found in the database.",response.c_str());
safe_delete_array(query);
return;
}
safe_delete_array(query);
}
if((response).size() > 0)
@ -6159,35 +6172,34 @@ void Client::Handle_OP_RecipesSearch(const EQApplicationPacket *app)
snprintf(containers,29, "in (%u,%u)", rss->object_type, rss->some_id);
}
char *query = 0;
std::string query;
char searchclause[140]; //2X rss->query + SQL crap
//omit the rlike clause if query is empty
if(rss->query[0] != 0) {
char buf[120]; //larger than 2X rss->query
std::string buf; //larger than 2X rss->query
database.DoEscapeString(buf, rss->query, strlen(rss->query));
snprintf(searchclause, 139, "name rlike '%s' AND", buf);
snprintf(searchclause, 139, "name rlike '%s' AND", buf.c_str());
} else {
searchclause[0] = '\0';
}
uint32 qlen = 0;
//arbitrary limit of 200 recipes, makes sense to me.
qlen = MakeAnyLenString(&query, "SELECT tr.id,tr.name,tr.trivial,SUM(tre.componentcount),crl.madecount,tr.tradeskill "
" FROM tradeskill_recipe AS tr "
" LEFT JOIN tradeskill_recipe_entries AS tre ON tr.id=tre.recipe_id "
" LEFT JOIN (SELECT recipe_id, madecount FROM char_recipe_list WHERE char_id = %u) AS crl ON tr.id=crl.recipe_id "
" WHERE %s tr.trivial >= %u AND tr.trivial <= %u "
" AND tr.must_learn & 0x20 <> 0x20 AND((tr.must_learn & 0x3 <> 0 AND crl.madecount IS NOT NULL) OR (tr.must_learn & 0x3 = 0)) "
" GROUP BY tr.id "
" HAVING sum(if(tre.item_id %s AND tre.iscontainer > 0,1,0)) > 0 "
" LIMIT 200 "
, CharacterID(), searchclause, rss->mintrivial, rss->maxtrivial, containers);
StringFormat(query,"SELECT tr.id,tr.name,tr.trivial,SUM(tre.componentcount),crl.madecount,tr.tradeskill "
"FROM tradeskill_recipe AS tr "
"LEFT JOIN tradeskill_recipe_entries AS tre ON tr.id=tre.recipe_id "
"LEFT JOIN (SELECT recipe_id, madecount FROM char_recipe_list WHERE char_id = %u) AS crl ON tr.id=crl.recipe_id "
"WHERE %s tr.trivial >= %u AND tr.trivial <= %u "
"AND tr.must_learn & 0x20 <> 0x20 AND((tr.must_learn & 0x3 <> 0 AND crl.madecount IS NOT NULL) OR (tr.must_learn & 0x3 = 0)) "
"GROUP BY tr.id "
"HAVING sum(if(tre.item_id %s AND tre.iscontainer > 0,1,0)) > 0 "
"LIMIT 200 ",
CharacterID(), searchclause, rss->mintrivial, rss->maxtrivial, containers);
TradeskillSearchResults(query, qlen, rss->object_type, rss->some_id);
TradeskillSearchResults(query, query.length(), rss->object_type, rss->some_id);
safe_delete_array(query);
return;
}
@ -11508,7 +11520,7 @@ void Client::Handle_OP_SetStartCity(const EQApplicationPacket *app)
}
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result = nullptr;
MYSQL_ROW row = 0;
float x(0),y(0),z(0);
@ -11516,22 +11528,12 @@ void Client::Handle_OP_SetStartCity(const EQApplicationPacket *app)
uint32 StartCity = (uint32)strtol((const char*)app->pBuffer, nullptr, 10);
bool ValidCity = false;
database.RunQuery
(
query,
MakeAnyLenString
(
&query,
"SELECT zone_id, bind_id, x, y, z FROM start_zones "
"WHERE player_class=%i AND player_deity=%i AND player_race=%i",
m_pp.class_,
m_pp.deity,
m_pp.race
),
errbuf,
&result
);
safe_delete_array(query);
StringFormat(query,"SELECT zone_id, bind_id, x, y, z FROM start_zones "
"WHERE player_class=%i AND player_deity=%i AND player_race=%i",
m_pp.class_, m_pp.deity, m_pp.race);
database.RunQuery(query, errbuf, &result);
if(!result) {
LogFile->write(EQEMuLog::Error, "No valid start zones found for /setstartcity");
@ -11557,22 +11559,13 @@ void Client::Handle_OP_SetStartCity(const EQApplicationPacket *app)
SetStartZone(StartCity, x, y, z);
}
else {
database.RunQuery
(
query,
MakeAnyLenString
(
&query,
"SELECT zone_id, bind_id FROM start_zones "
"WHERE player_class=%i AND player_deity=%i AND player_race=%i",
m_pp.class_,
m_pp.deity,
m_pp.race
),
errbuf,
&result
);
safe_delete_array(query);
StringFormat(query, "SELECT zone_id, bind_id FROM start_zones "
"WHERE player_class=%i AND player_deity=%i AND player_race=%i",
m_pp.class_, m_pp.deity, m_pp.race);
database.RunQuery(query,errbuf,&result);
Message(15,"Use \"/startcity #\" to choose a home city from the following list:");
char* name;
while(row = mysql_fetch_row(result)) {
@ -11706,17 +11699,19 @@ void Client::Handle_OP_GMSearchCorpse(const EQApplicationPacket *app)
GMSearchCorpse_Struct *gmscs = (GMSearchCorpse_Struct *)app->pBuffer;
char errbuf[MYSQL_ERRMSG_SIZE];
char* Query = 0;
std::string query;
MYSQL_RES *Result;
MYSQL_ROW Row;
char *EscSearchString = new char[129];
std::string escSearchString;
database.DoEscapeString(EscSearchString, gmscs->Name, strlen(gmscs->Name));
if (database.RunQuery(Query, MakeAnyLenString(&Query, "select charname, zoneid, x, y, z, timeofdeath, rezzed, IsBurried from "
"player_corpses where charname like '%%%s%%' order by charname limit %i",
EscSearchString, MaxResults), errbuf, &Result))
database.DoEscapeString(escSearchString, gmscs->Name, strlen(gmscs->Name));
StringFormat(query, "select charname, zoneid, x, y, z, timeofdeath, rezzed, IsBurried from "
"player_corpses where charname like '%%%s%%' order by charname limit %i",
escSearchString.c_str(), MaxResults);
if (database.RunQuery(query, errbuf, &Result))
{
int NumberOfRows = mysql_num_rows(Result);
@ -11731,7 +11726,6 @@ void Client::Handle_OP_GMSearchCorpse(const EQApplicationPacket *app)
if(NumberOfRows == 0)
{
mysql_free_result(Result);
safe_delete_array(Query);
return;
}
@ -11782,8 +11776,6 @@ void Client::Handle_OP_GMSearchCorpse(const EQApplicationPacket *app)
Message(0, "Query failed: %s.", errbuf);
}
safe_delete_array(Query);
safe_delete_array(EscSearchString);
}
void Client::Handle_OP_GuildBank(const EQApplicationPacket *app)

1226
zone/command.cpp
View File

File diff suppressed because it is too large Load Diff

52
zone/doors.cpp
View File

@ -570,14 +570,14 @@ void Doors::DumpDoor(){
int32 ZoneDatabase::GetDoorsCount(uint32* oMaxID, const char *zone_name, int16 version) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
query = new char[256];
sprintf(query, "SELECT MAX(id), count(*) FROM doors WHERE zone='%s' AND (version=%u OR version=-1)", zone_name, version);
if (RunQuery(query, strlen(query), errbuf, &result)) {
safe_delete_array(query);
std::string query;
StringFormat(query,"SELECT MAX(id), count(*) FROM doors WHERE zone='%s' AND (version=%u OR version=-1)",zone_name, version);
if (RunQuery(query, errbuf, &result)) {
row = mysql_fetch_row(result);
if (row != nullptr && row[1] != 0) {
int32 ret = atoi(row[1]);
@ -594,7 +594,6 @@ int32 ZoneDatabase::GetDoorsCount(uint32* oMaxID, const char *zone_name, int16 v
}
else {
std::cerr << "Error in GetDoorsCount query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return -1;
}
@ -603,15 +602,16 @@ int32 ZoneDatabase::GetDoorsCount(uint32* oMaxID, const char *zone_name, int16 v
int32 ZoneDatabase::GetDoorsCountPlusOne(const char *zone_name, int16 version) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
uint32 oMaxID = 0;
MYSQL_RES *result;
MYSQL_ROW row;
query = new char[256];
sprintf(query, "SELECT MAX(id) FROM doors WHERE zone='%s' AND version=%u", zone_name, version);
if (RunQuery(query, strlen(query), errbuf, &result)) {
safe_delete_array(query);
StringFormat(query, "SELECT MAX(id) FROM doors WHERE zone='%s' AND version=%u", zone_name, version);
if (RunQuery(query, errbuf, &result)) {
row = mysql_fetch_row(result);
if (row != nullptr && row[1] != 0) {
if (row[0])
@ -625,7 +625,6 @@ int32 ZoneDatabase::GetDoorsCountPlusOne(const char *zone_name, int16 version) {
}
else {
std::cerr << "Error in GetDoorsCountPlusOne query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return -1;
}
@ -634,15 +633,15 @@ int32 ZoneDatabase::GetDoorsCountPlusOne(const char *zone_name, int16 version) {
int32 ZoneDatabase::GetDoorsDBCountPlusOne(const char *zone_name, int16 version) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
uint32 oMaxID = 0;
MYSQL_RES *result;
MYSQL_ROW row;
query = new char[256];
sprintf(query, "SELECT MAX(doorid) FROM doors WHERE zone='%s' AND (version=%u OR version=-1)", zone_name, version);
if (RunQuery(query, strlen(query), errbuf, &result)) {
safe_delete_array(query);
StringFormat(query, "SELECT MAX(doorid) FROM doors WHERE zone='%s' AND (version=%u OR version=-1)", zone_name, version);
if (RunQuery(query, errbuf, &result)) {
row = mysql_fetch_row(result);
if (row != nullptr && row[1] != 0) {
if (row[0])
@ -656,7 +655,6 @@ int32 ZoneDatabase::GetDoorsDBCountPlusOne(const char *zone_name, int16 version)
}
else {
std::cerr << "Error in GetDoorsCountPlusOne query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return -1;
}
@ -666,17 +664,20 @@ int32 ZoneDatabase::GetDoorsDBCountPlusOne(const char *zone_name, int16 version)
bool ZoneDatabase::LoadDoors(int32 iDoorCount, Door *into, const char *zone_name, int16 version) {
LogFile->write(EQEMuLog::Status, "Loading Doors from database...");
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
// Door tmpDoor;
MakeAnyLenString(&query, "SELECT id,doorid,zone,name,pos_x,pos_y,pos_z,heading,"
"opentype,guild,lockpick,keyitem,nokeyring,triggerdoor,triggertype,dest_zone,dest_instance,dest_x,"
"dest_y,dest_z,dest_heading,door_param,invert_state,incline,size,is_ldon_door,client_version_mask "
"FROM doors WHERE zone='%s' AND (version=%u OR version=-1) ORDER BY doorid asc", zone_name, version);
if (RunQuery(query, strlen(query), errbuf, &result)) {
safe_delete_array(query);
StringFormat(query, "SELECT id,doorid,zone,name,pos_x,pos_y,pos_z,heading,"
"opentype,guild,lockpick,keyitem,nokeyring,triggerdoor,"
"triggertype,dest_zone,dest_instance,dest_x,"
"dest_y,dest_z,dest_heading,door_param,invert_state,"
"incline,size,is_ldon_door,client_version_mask "
"FROM doors WHERE zone='%s' AND (version=%u OR version=-1) "
"ORDER BY doorid asc", zone_name, version);
if (RunQuery(query, errbuf, &result)) {
int32 r;
for(r = 0; (row = mysql_fetch_row(result)); r++) {
if(r >= iDoorCount) {
@ -717,7 +718,6 @@ bool ZoneDatabase::LoadDoors(int32 iDoorCount, Door *into, const char *zone_name
else
{
std::cerr << "Error in DBLoadDoors query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return false;
}
return true;

20
zone/forage.cpp
View File

@ -86,7 +86,7 @@ CREATE TABLE fishing (
// This allows EqEmu to have zone specific foraging - BoB
uint32 ZoneDatabase::GetZoneForage(uint32 ZoneID, uint8 skill) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
@ -101,13 +101,14 @@ uint32 ZoneDatabase::GetZoneForage(uint32 ZoneID, uint8 skill) {
uint32 chancepool = 0;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT itemid,chance FROM forage WHERE zoneid= '%i' and level <= '%i' LIMIT %i", ZoneID, skill, FORAGE_ITEM_LIMIT), errbuf, &result))
StringFormat(query,"SELECT itemid,chance FROM forage WHERE zoneid= '%i' and level <= '%i' LIMIT %i", ZoneID, skill, FORAGE_ITEM_LIMIT);
if (RunQuery(query, errbuf, &result))
{
safe_delete_array(query);
while ((row = mysql_fetch_row(result)) && (index < FORAGE_ITEM_LIMIT)) {
item[index] = atoi(row[0]);
chance[index] = atoi(row[1])+chancepool;
LogFile->write(EQEMuLog::Error, "Possible Forage: %d with a %d chance", item[index], chance[index]);
LogFile->write(EQEMuLog::Error, "Possible Forage: %d with a %d chance", item[index], chance[index]);
chancepool = chance[index];
index++;
}
@ -115,8 +116,7 @@ LogFile->write(EQEMuLog::Error, "Possible Forage: %d with a %d chance", item[ind
mysql_free_result(result);
}
else {
LogFile->write(EQEMuLog::Error, "Error in Forage query '%s': %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in Forage query '%s': %s", query.c_str(), errbuf);
return 0;
}
@ -144,7 +144,7 @@ LogFile->write(EQEMuLog::Error, "Possible Forage: %d with a %d chance", item[ind
uint32 ZoneDatabase::GetZoneFishing(uint32 ZoneID, uint8 skill, uint32 &npc_id, uint8 &npc_chance)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
@ -161,9 +161,10 @@ uint32 ZoneDatabase::GetZoneFishing(uint32 ZoneID, uint8 skill, uint32 &npc_id,
chance[c]=0;
}
if (RunQuery(query, MakeAnyLenString(&query, "SELECT itemid,chance,npc_id,npc_chance FROM fishing WHERE (zoneid= '%i' || zoneid = 0) and skill_level <= '%i'",ZoneID, skill ), errbuf, &result))
StringFormat(query,"SELECT itemid,chance,npc_id,npc_chance FROM fishing WHERE (zoneid= '%i' || zoneid = 0) and skill_level <= '%i'",ZoneID, skill );
if (RunQuery(query,errbuf, &result))
{
safe_delete_array(query);
while ((row = mysql_fetch_row(result))&&(index<50)) {
item[index] = atoi(row[0]);
chance[index] = atoi(row[1])+chancepool;
@ -178,7 +179,6 @@ uint32 ZoneDatabase::GetZoneFishing(uint32 ZoneID, uint8 skill, uint32 &npc_id,
}
else {
std::cerr << "Error in Fishing query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return 0;
}

103
zone/groups.cpp
View File

@ -957,16 +957,17 @@ void Group::TeleportGroup(Mob* sender, uint32 zoneID, uint16 instance_id, float
bool Group::LearnMembers() {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (database.RunQuery(query,MakeAnyLenString(&query, "SELECT name FROM group_id WHERE groupid=%lu", (unsigned long)GetID()),
errbuf,&result)){
safe_delete_array(query);
StringFormat(query, "SELECT name FROM group_id WHERE groupid=%lu", (unsigned long)GetID());
if (database.RunQuery(query,errbuf,&result)){
if(mysql_num_rows(result) < 1) { //could prolly be 2
mysql_free_result(result);
LogFile->write(EQEMuLog::Error, "Error getting group members for group %lu: %s", (unsigned long)GetID(), errbuf);
return(false);
return false;
}
int i = 0;
while((row = mysql_fetch_row(result))) {
@ -980,7 +981,7 @@ bool Group::LearnMembers() {
mysql_free_result(result);
}
return(true);
return true;
}
void Group::VerifyGroup() {
@ -1273,13 +1274,14 @@ void Group::DelegateMainTank(const char *NewMainTankName, uint8 toggle)
if(updateDB) {
char errbuff[MYSQL_ERRMSG_SIZE];
char *Query = nullptr;
std::string query;
if (!database.RunQuery(Query, MakeAnyLenString(&Query, "UPDATE group_leaders SET maintank='%s' WHERE gid=%i LIMIT 1",
MainTankName.c_str(), GetID()), errbuff))
StringFormat(query, "UPDATE group_leaders SET maintank='%s' WHERE gid=%i LIMIT 1",
MainTankName.c_str(), GetID());
if (!database.RunQuery(query, errbuff))
LogFile->write(EQEMuLog::Error, "Unable to set group main tank: %s\n", errbuff);
safe_delete_array(Query);
}
}
@ -1322,13 +1324,14 @@ void Group::DelegateMainAssist(const char *NewMainAssistName, uint8 toggle)
if(updateDB) {
char errbuff[MYSQL_ERRMSG_SIZE];
char *Query = nullptr;
std::string query;
if (!database.RunQuery(Query, MakeAnyLenString(&Query, "UPDATE group_leaders SET assist='%s' WHERE gid=%i LIMIT 1",
MainAssistName.c_str(), GetID()), errbuff))
StringFormat(query, "UPDATE group_leaders SET assist='%s' WHERE gid=%i LIMIT 1",
MainAssistName.c_str(), GetID());
if (!database.RunQuery(query, errbuff))
LogFile->write(EQEMuLog::Error, "Unable to set group main assist: %s\n", errbuff);
safe_delete_array(Query);
}
}
@ -1371,13 +1374,14 @@ void Group::DelegatePuller(const char *NewPullerName, uint8 toggle)
if(updateDB) {
char errbuff[MYSQL_ERRMSG_SIZE];
char *Query = nullptr;
std::string query;
if (!database.RunQuery(Query, MakeAnyLenString(&Query, "UPDATE group_leaders SET puller='%s' WHERE gid=%i LIMIT 1",
PullerName.c_str(), GetID()), errbuff))
StringFormat(query, "UPDATE group_leaders SET puller='%s' WHERE gid=%i LIMIT 1",
PullerName.c_str(), GetID());
if (!database.RunQuery(query, errbuff))
LogFile->write(EQEMuLog::Error, "Unable to set group main puller: %s\n", errbuff);
safe_delete_array(Query);
}
}
@ -1525,14 +1529,14 @@ void Group::UnDelegateMainTank(const char *OldMainTankName, uint8 toggle)
if(OldMainTankName == MainTankName) {
char errbuff[MYSQL_ERRMSG_SIZE];
char *Query = 0;
std::string query;
if (!database.RunQuery(Query, MakeAnyLenString(&Query, "UPDATE group_leaders SET maintank='' WHERE gid=%i LIMIT 1",
GetID()), errbuff))
StringFormat(query, "UPDATE group_leaders SET maintank='' WHERE gid=%i LIMIT 1",
GetID());
if (!database.RunQuery(query, errbuff))
LogFile->write(EQEMuLog::Error, "Unable to clear group main tank: %s\n", errbuff);
safe_delete_array(Query);
if(!toggle) {
for(uint32 i = 0; i < MAX_GROUP_MEMBERS; ++i) {
if(members[i] && members[i]->IsClient())
@ -1579,13 +1583,14 @@ void Group::UnDelegateMainAssist(const char *OldMainAssistName, uint8 toggle)
char errbuff[MYSQL_ERRMSG_SIZE];
char *Query = 0;
std::string query;
if (!database.RunQuery(Query, MakeAnyLenString(&Query, "UPDATE group_leaders SET assist='' WHERE gid=%i LIMIT 1",
GetID()), errbuff))
StringFormat(query, "UPDATE group_leaders SET assist='' WHERE gid=%i LIMIT 1",
GetID());
if (!database.RunQuery(query, errbuff))
LogFile->write(EQEMuLog::Error, "Unable to clear group main assist: %s\n", errbuff);
safe_delete_array(Query);
if(!toggle)
{
@ -1610,15 +1615,14 @@ void Group::UnDelegatePuller(const char *OldPullerName, uint8 toggle)
//
if(OldPullerName == PullerName) {
char errbuff[MYSQL_ERRMSG_SIZE];
std::string query;
char *Query = 0;
StringFormat(query, "UPDATE group_leaders SET puller='' WHERE gid=%i LIMIT 1",
GetID());
if (!database.RunQuery(Query, MakeAnyLenString(&Query, "UPDATE group_leaders SET puller='' WHERE gid=%i LIMIT 1",
GetID()), errbuff))
if (!database.RunQuery(query, errbuff))
LogFile->write(EQEMuLog::Error, "Unable to clear group main puller: %s\n", errbuff);
safe_delete_array(Query);
if(!toggle) {
for(uint32 i = 0; i < MAX_GROUP_MEMBERS; ++i) {
if(members[i] && members[i]->IsClient())
@ -1754,13 +1758,14 @@ void Group::DelegateMarkNPC(const char *NewNPCMarkerName)
char errbuff[MYSQL_ERRMSG_SIZE];
char *Query = 0;
std::string query;
if (!database.RunQuery(Query, MakeAnyLenString(&Query, "UPDATE group_leaders SET marknpc='%s' WHERE gid=%i LIMIT 1",
NewNPCMarkerName, GetID()), errbuff))
StringFormat(query, "UPDATE group_leaders SET marknpc='%s' WHERE gid=%i LIMIT 1",
NewNPCMarkerName, GetID());
if (!database.RunQuery(query, errbuff))
LogFile->write(EQEMuLog::Error, "Unable to set group mark npc: %s\n", errbuff);
safe_delete_array(Query);
}
@ -1840,13 +1845,14 @@ void Group::UnDelegateMarkNPC(const char *OldNPCMarkerName)
char errbuff[MYSQL_ERRMSG_SIZE];
char *Query = 0;
std::string query;
if (!database.RunQuery(Query, MakeAnyLenString(&Query, "UPDATE group_leaders SET marknpc='' WHERE gid=%i LIMIT 1",
GetID()), errbuff))
StringFormat(query, "UPDATE group_leaders SET marknpc='' WHERE gid=%i LIMIT 1",
GetID());
if (!database.RunQuery(query, errbuff))
LogFile->write(EQEMuLog::Error, "Unable to clear group marknpc: %s\n", errbuff);
safe_delete_array(Query);
}
void Group::SaveGroupLeaderAA()
@ -1854,21 +1860,24 @@ void Group::SaveGroupLeaderAA()
// Stores the Group Leaders Leadership AA data from the Player Profile as a blob in the group_leaders table.
// This is done so that group members not in the same zone as the Leader still have access to this information.
char *Query = new char[200 + sizeof(GroupLeadershipAA_Struct)*2];
std::string leaderAABuffer;
char *End = Query;
std::string endingOfQuery;
End += sprintf(End, "UPDATE group_leaders SET leadershipaa='");
std::string query = "UPDATE group_leaders SET leadershipaa='";
End += database.DoEscapeString(End, (char*)&LeaderAbilities, sizeof(GroupLeadershipAA_Struct));
database.DoEscapeString(leaderAABuffer, (char*)&LeaderAbilities, sizeof(GroupLeadershipAA_Struct));
End += sprintf(End,"' WHERE gid=%i LIMIT 1", GetID());
query.append(leaderAABuffer);
StringFormat(endingOfQuery, "' WHERE gid=%i LIMIT 1", GetID());
query.append(endingOfQuery);
char errbuff[MYSQL_ERRMSG_SIZE];
if (!database.RunQuery(Query, End - Query, errbuff))
if (!database.RunQuery(query, errbuff))
LogFile->write(EQEMuLog::Error, "Unable to store LeadershipAA: %s\n", errbuff);
safe_delete_array(Query);
}
void Group::UnMarkNPC(uint16 ID)

30
zone/guild.cpp
View File

@ -381,14 +381,14 @@ void Client::GuildChangeRank(const char* name, uint32 guild_id, uint32 oldrank,
bool ZoneDatabase::CheckGuildDoor(uint8 doorid,uint16 guild_id,const char* zone) {
MYSQL_ROW row;
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
if (!RunQuery(query, MakeAnyLenString(&query,
"SELECT guild FROM doors where doorid=%i AND zone='%s'",
doorid-128, zone), errbuf, &result))
{
LogFile->write(EQEMuLog::Error, "Error in CheckGuildDoor query '%s': %s", query, errbuf);
safe_delete_array(query);
StringFormat(query, "SELECT guild FROM doors where doorid=%i AND zone='%s'",
doorid-128, zone);
if (!RunQuery(query, errbuf, &result)) {
LogFile->write(EQEMuLog::Error, "Error in CheckGuildDoor query '%s': %s", query.c_str(), errbuf);
return false;
} else {
if (mysql_num_rows(result) == 1) {
@ -414,21 +414,19 @@ bool ZoneDatabase::CheckGuildDoor(uint8 doorid,uint16 guild_id,const char* zone)
bool ZoneDatabase::SetGuildDoor(uint8 doorid,uint16 guild_id, const char* zone) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
uint32 affected_rows = 0;
if (doorid > 127)
doorid = doorid - 128;
if (!RunQuery(query, MakeAnyLenString(&query,
"UPDATE doors SET guild = %i WHERE (doorid=%i) AND (zone='%s')",
guild_id, doorid, zone), errbuf, 0,&affected_rows))
{
LogFile->write(EQEMuLog::Error, "Error in SetGuildDoor query '%s': %s", query, errbuf);
safe_delete_array(query);
StringFormat(query, "UPDATE doors SET guild = %i WHERE (doorid=%i) AND (zone='%s')",
guild_id, doorid, zone);
if (!RunQuery(query, errbuf, nullptr,&affected_rows)) {
LogFile->write(EQEMuLog::Error, "Error in SetGuildDoor query '%s': %s", query.c_str(), errbuf);
return false;
}
safe_delete_array(query);
return(affected_rows > 0);
}

108
zone/guild_mgr.cpp
View File

@ -646,18 +646,15 @@ GuildBankManager::~GuildBankManager()
bool GuildBankManager::Load(uint32 GuildID)
{
const char *LoadQuery = "SELECT `area`, `slot`, `itemid`, `qty`, `donator`, `permissions`, `whofor` from `guild_bank` "
"WHERE `guildid` = %i";
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if(database.RunQuery(query, MakeAnyLenString(&query, LoadQuery, GuildID), errbuf, &result))
StringFormat(query, "SELECT `area`, `slot`, `itemid`, `qty`, `donator`, `permissions`, `whofor` "
"FROM `guild_bank` WHERE `guildid` = %i", GuildID);
if(database.RunQuery(query, errbuf, &result))
{
GuildBank *Bank = new GuildBank;
@ -727,15 +724,12 @@ bool GuildBankManager::Load(uint32 GuildID)
}
mysql_free_result(result);
safe_delete_array(query);
Banks.push_back(Bank);
}
else
{
_log(GUILDS__BANK_ERROR, "Error Loading guild bank: %s, %s", query, errbuf);
safe_delete_array(query);
_log(GUILDS__BANK_ERROR, "Error Loading guild bank: %s, %s", query.c_str(), errbuf);
return false;
}
@ -930,24 +924,23 @@ bool GuildBankManager::AddItem(uint32 GuildID, uint8 Area, uint32 ItemID, int32
return false;
}
const char *Query="INSERT INTO `guild_bank` (`guildid`, `area`, `slot`, `itemid`, `qty`, `donator`, `permissions`, `WhoFor`) "
"VALUES (%i, %i, %i, %i, %i, '%s', %i, '%s')";
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
if(!database.RunQuery(query, MakeAnyLenString(&query, Query, GuildID, Area, Slot, ItemID, QtyOrCharges, Donator, Permissions, WhoFor), errbuf))
StringFormat(query, "INSERT INTO `guild_bank` "
"(`guildid`, `area`, `slot`, `itemid`, `qty`, `donator`, `permissions`, `WhoFor`) "
"VALUES (%i, %i, %i, %i, %i, '%s', %i, '%s')",
GuildID, Area, Slot, ItemID, QtyOrCharges,
Donator, Permissions, WhoFor);
if(!database.RunQuery(query, errbuf))
{
_log(GUILDS__BANK_ERROR, "Insert Error: %s : %s", query, errbuf);
safe_delete_array(query);
_log(GUILDS__BANK_ERROR, "Insert Error: %s : %s", query.c_str(), errbuf);
return false;
}
safe_delete_array(query);
const Item_Struct *Item = database.GetItem(ItemID);
GuildBankItemUpdate_Struct gbius;
@ -1013,23 +1006,20 @@ int GuildBankManager::Promote(uint32 GuildID, int SlotID)
strn0cpy((*Iterator)->Items.MainArea[MainSlot].WhoFor, (*Iterator)->Items.DepositArea[SlotID].WhoFor, sizeof((*Iterator)->Items.MainArea[MainSlot].WhoFor));
const char *Query="UPDATE `guild_bank` SET `area` = 1, `slot` = %i WHERE `guildid` = %i AND `area` = 0 AND `slot` = %i LIMIT 1";
char errbuf[MYSQL_ERRMSG_SIZE];
std::string query;
char* query = 0;
StringFormat(query, "UPDATE `guild_bank` SET `area` = 1, `slot` = %i WHERE "
"`guildid` = %i AND `area` = 0 AND `slot` = %i LIMIT 1",
MainSlot, GuildID, SlotID);
if(!database.RunQuery(query, MakeAnyLenString(&query, Query, MainSlot, GuildID, SlotID), errbuf))
if(!database.RunQuery(query, errbuf))
{
_log(GUILDS__BANK_ERROR, "error promoting item: %s : %s", query, errbuf);
safe_delete_array(query);
_log(GUILDS__BANK_ERROR, "error promoting item: %s : %s", query.c_str(), errbuf);
return -1;
}
safe_delete_array(query);
(*Iterator)->Items.DepositArea[SlotID].ItemID = 0;
const Item_Struct *Item = database.GetItem((*Iterator)->Items.MainArea[MainSlot].ItemID);
@ -1076,22 +1066,17 @@ void GuildBankManager::SetPermissions(uint32 GuildID, uint16 SlotID, uint32 Perm
return;
}
const char *Query="UPDATE `guild_bank` SET `permissions` = %i, `whofor` = '%s' WHERE `guildid` = %i AND `area` = 1 AND `slot` = %i LIMIT 1";
char errbuf[MYSQL_ERRMSG_SIZE];
std::string query;
char* query = 0;
StringFormat(query, "UPDATE `guild_bank` SET `permissions` = %i, `whofor` = '%s' WHERE `guildid` = %i AND `area` = 1 AND `slot` = %i LIMIT 1",Permissions, MemberName, GuildID, SlotID);
if(!database.RunQuery(query, MakeAnyLenString(&query, Query, Permissions, MemberName, GuildID, SlotID), errbuf))
{
_log(GUILDS__BANK_ERROR, "error changing permissions: %s : %s", query, errbuf);
safe_delete_array(query);
if(!database.RunQuery(query, errbuf)) {
_log(GUILDS__BANK_ERROR, "error changing permissions: %s : %s", query.c_str(), errbuf);
return;
}
safe_delete_array(query);
(*Iterator)->Items.MainArea[SlotID].Permissions = Permissions;
@ -1217,7 +1202,7 @@ bool GuildBankManager::DeleteItem(uint32 GuildID, uint16 Area, uint16 SlotID, ui
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
GuildBankItem* BankArea = nullptr;
@ -1243,37 +1228,34 @@ bool GuildBankManager::DeleteItem(uint32 GuildID, uint16 Area, uint16 SlotID, ui
if(!Item->Stackable || (Quantity >= BankArea[SlotID].Quantity))
{
const char *Query = "DELETE from `guild_bank` where `guildid` = %i AND `area` = %i AND `slot` = %i LIMIT 1";
StringFormat(query, "DELETE from `guild_bank` where `guildid` = %i "
"AND `area` = %i AND `slot` = %i LIMIT 1",
GuildID, Area, SlotID);
if(!database.RunQuery(query, MakeAnyLenString(&query, Query, GuildID, Area, SlotID), errbuf))
if(!database.RunQuery(query, errbuf))
{
_log(GUILDS__BANK_ERROR, "Delete item failed. %s : %s", query, errbuf);
safe_delete_array(query);
_log(GUILDS__BANK_ERROR, "Delete item failed. %s : %s", query.c_str(), errbuf);
return false;
}
safe_delete_array(query);
BankArea[SlotID].ItemID = 0;
}
else
{
const char *Query = "UPDATE `guild_bank` SET `qty` = %i where `guildid` = %i AND `area` = %i AND `slot` = %i LIMIT 1";
std::string query;
if(!database.RunQuery(query, MakeAnyLenString(&query, Query, BankArea[SlotID].Quantity - Quantity,
GuildID, Area, SlotID), errbuf))
StringFormat(query, "UPDATE `guild_bank` SET `qty` = %i where "
"`guildid` = %i AND `area` = %i AND `slot` = %i LIMIT 1",
BankArea[SlotID].Quantity - Quantity, GuildID, Area, SlotID);
if(!database.RunQuery(query, errbuf))
{
_log(GUILDS__BANK_ERROR, "Update item failed. %s : %s", query, errbuf);
safe_delete_array(query);
_log(GUILDS__BANK_ERROR, "Update item failed. %s : %s", query.c_str(), errbuf);
return false;
}
safe_delete_array(query);
BankArea[SlotID].Quantity -= Quantity;
Deleted = false;
@ -1427,21 +1409,19 @@ void GuildBankManager::UpdateItemQuantity(uint32 GuildID, uint16 Area, uint16 Sl
// Helper method for MergeStacks. Assuming all passed parameters are valid.
//
char errbuf[MYSQL_ERRMSG_SIZE];
std::string query;
char* query = 0;
StringFormat(query, "UPDATE `guild_bank` SET `qty` = %i where "
"`guildid` = %i AND `area` = %i AND `slot` = %i LIMIT 1",
Quantity, GuildID, Area, SlotID);
const char *Query = "UPDATE `guild_bank` SET `qty` = %i where `guildid` = %i AND `area` = %i AND `slot` = %i LIMIT 1";
if(!database.RunQuery(query, MakeAnyLenString(&query, Query, Quantity, GuildID, Area, SlotID), errbuf))
if(!database.RunQuery(query, errbuf))
{
_log(GUILDS__BANK_ERROR, "Update item quantity failed. %s : %s", query, errbuf);
safe_delete_array(query);
_log(GUILDS__BANK_ERROR, "Update item quantity failed. %s : %s", query.c_str(), errbuf);
return;
}
safe_delete_array(query);
}
bool GuildBankManager::AllowedToWithdraw(uint32 GuildID, uint16 Area, uint16 SlotID, const char *Name)

11
zone/horse.cpp
View File

@ -72,13 +72,14 @@ const NPCType *Horse::BuildHorseType(uint16 spell_id) {
char mount_color = 0;
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (database.RunQuery(query,MakeAnyLenString(&query, "SELECT race,gender,texture,mountspeed FROM horses WHERE filename='%s'", FileName), errbuf, &result)) {
StringFormat(query, "SELECT race,gender,texture,mountspeed FROM horses WHERE filename='%s'", FileName);
if (database.RunQuery(query,errbuf, &result)) {
safe_delete_array(query);
if (mysql_num_rows(result) == 1) {
row = mysql_fetch_row(result);
@ -119,14 +120,12 @@ const NPCType *Horse::BuildHorseType(uint16 spell_id) {
else {
LogFile->write(EQEMuLog::Error, "No Database entry for mount: %s, check the horses table", FileName);
//Message(13, "Unable to find data for mount %s", FileName);
safe_delete_array(query);
}
mysql_free_result(result);
return nullptr;
}
else {
LogFile->write(EQEMuLog::Error, "Error in Mount query '%s': %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in Mount query '%s': %s", query.c_str(), errbuf);
return nullptr;
}

35
zone/merc.cpp
View File

@ -5928,12 +5928,20 @@ void Client::SendMercAssignPacket(uint32 entityID, uint32 unk01, uint32 unk02) {
void NPC::LoadMercTypes(){
std::string errorMessage;
char* Query = 0;
std::string query;
char TempErrorMessageBuffer[MYSQL_ERRMSG_SIZE];
MYSQL_RES* DatasetResult;
MYSQL_ROW DataRow;
if(!database.RunQuery(Query, MakeAnyLenString(&Query, "SELECT DISTINCT MTyp.dbstring, MTyp.clientversion FROM merc_merchant_entries MME, merc_merchant_template_entries MMTE, merc_types MTyp, merc_templates MTem WHERE MME.merchant_id = %i AND MME.merc_merchant_template_id = MMTE.merc_merchant_template_id AND MMTE.merc_template_id = MTem.merc_template_id AND MTem.merc_type_id = MTyp.merc_type_id;", GetNPCTypeID()), TempErrorMessageBuffer, &DatasetResult)) {
StringFormat(query,"SELECT DISTINCT MTyp.dbstring, MTyp.clientversion FROM "
"merc_merchant_entries MME, merc_merchant_template_entries MMTE, "
"merc_types MTyp, merc_templates MTem WHERE MME.merchant_id = %i "
"AND MME.merc_merchant_template_id = MMTE.merc_merchant_template_id "
"AND MMTE.merc_template_id = MTem.merc_template_id AND "
"MTem.merc_type_id = MTyp.merc_type_id;",
GetNPCTypeID());
if(!database.RunQuery(query,TempErrorMessageBuffer, &DatasetResult)) {
errorMessage = std::string(TempErrorMessageBuffer);
}
else {
@ -5949,9 +5957,6 @@ void NPC::LoadMercTypes(){
mysql_free_result(DatasetResult);
}
safe_delete_array(Query);
Query = 0;
if(!errorMessage.empty()) {
LogFile->write(EQEMuLog::Error, "Error in NPC::LoadMercTypes()");
}
@ -5960,12 +5965,24 @@ void NPC::LoadMercTypes(){
void NPC::LoadMercs(){
std::string errorMessage;
char* Query = 0;
std::string query;
char TempErrorMessageBuffer[MYSQL_ERRMSG_SIZE];
MYSQL_RES* DatasetResult;
MYSQL_ROW DataRow;
if(!database.RunQuery(Query, MakeAnyLenString(&Query, "SELECT DISTINCT MTem.merc_template_id, MTyp.dbstring AS merc_type_id, MTem.dbstring AS merc_subtype_id, 0 AS CostFormula, CASE WHEN MTem.clientversion > MTyp.clientversion then MTem.clientversion ELSE MTyp.clientversion END AS clientversion, MTem.merc_npc_type_id FROM merc_merchant_entries MME, merc_merchant_template_entries MMTE, merc_types MTyp, merc_templates MTem WHERE MME.merchant_id = %i AND MME.merc_merchant_template_id = MMTE.merc_merchant_template_id AND MMTE.merc_template_id = MTem.merc_template_id AND MTem.merc_type_id = MTyp.merc_type_id;", GetNPCTypeID()), TempErrorMessageBuffer, &DatasetResult)) {
StringFormat(query,"SELECT DISTINCT MTem.merc_template_id, MTyp.dbstring "
"AS merc_type_id, MTem.dbstring AS merc_subtype_id, 0 AS CostFormula, "
"CASE WHEN MTem.clientversion > MTyp.clientversion then "
"MTem.clientversion ELSE MTyp.clientversion END AS "
"clientversion, MTem.merc_npc_type_id FROM "
"merc_merchant_entries MME, merc_merchant_template_entries MMTE, "
"merc_types MTyp, merc_templates MTem WHERE MME.merchant_id = %i "
"AND MME.merc_merchant_template_id = MMTE.merc_merchant_template_id "
"AND MMTE.merc_template_id = MTem.merc_template_id AND "
"MTem.merc_type_id = MTyp.merc_type_id;",
GetNPCTypeID());
if(!database.RunQuery(query, TempErrorMessageBuffer, &DatasetResult)) {
errorMessage = std::string(TempErrorMessageBuffer);
}
else {
@ -5985,8 +6002,6 @@ void NPC::LoadMercs(){
mysql_free_result(DatasetResult);
}
safe_delete_array(Query);
Query = 0;
if(!errorMessage.empty()) {
LogFile->write(EQEMuLog::Error, "Error in NPC::LoadMercTypes()");

51
zone/mob.cpp
View File

@ -3729,7 +3729,7 @@ void Mob::TarGlobal(const char *varname, const char *value, const char *duration
void Mob::DelGlobal(const char *varname) {
// delglobal(varname)
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
int qgZoneid=zone->GetZoneID();
int qgCharid=0;
int qgNpcid=0;
@ -3748,15 +3748,14 @@ void Mob::DelGlobal(const char *varname) {
qgCharid = -qgNpcid; // make char id negative npc id as a fudge
}
if (!database.RunQuery(query,
MakeAnyLenString(&query,
"DELETE FROM quest_globals WHERE name='%s'"
" && (npcid=0 || npcid=%i) && (charid=0 || charid=%i) && (zoneid=%i || zoneid=0)",
varname,qgNpcid,qgCharid,qgZoneid),errbuf))
{
StringFormat(query,"DELETE FROM quest_globals WHERE name='%s' && "
"(npcid=0 || npcid=%i) && "
"(charid=0 || charid=%i) && (zoneid=%i || zoneid=0)",
varname,qgNpcid,qgCharid,qgZoneid);
if (!database.RunQuery(query,errbuf)) {
//_log(QUESTS, "DelGlobal error deleting %s : %s", varname, errbuf);
}
safe_delete_array(query);
if(zone)
{
@ -3779,7 +3778,7 @@ void Mob::DelGlobal(const char *varname) {
// Inserts global variable into quest_globals table
void Mob::InsertQuestGlobal(int charid, int npcid, int zoneid, const char *varname, const char *varvalue, int duration) {
char *query = 0;
std::string query;
char errbuf[MYSQL_ERRMSG_SIZE];
// Make duration string either "unix_timestamp(now()) + xxx" or "NULL"
@ -3797,15 +3796,15 @@ void Mob::InsertQuestGlobal(int charid, int npcid, int zoneid, const char *varna
//NOTE: this should be escaping the contents of arglist
//npcwise a malicious script can arbitrarily alter the DB
uint32 last_id = 0;
if (!database.RunQuery(query, MakeAnyLenString(&query,
"REPLACE INTO quest_globals (charid, npcid, zoneid, name, value, expdate)"
"VALUES (%i, %i, %i, '%s', '%s', %s)",
charid, npcid, zoneid, varname, varvalue, duration_ss.str().c_str()
), errbuf))
StringFormat(query, "REPLACE INTO quest_globals (charid, npcid, zoneid, name, value, expdate)"
"VALUES (%i, %i, %i, '%s', '%s', %s)",
charid, npcid, zoneid, varname, varvalue, duration_ss.str().c_str());
if (!database.RunQuery(query, errbuf))
{
//_log(QUESTS, "SelGlobal error inserting %s : %s", varname, errbuf);
}
safe_delete_array(query);
if(zone)
{
@ -4675,18 +4674,18 @@ FACTION_VALUE Mob::GetSpecialFactionCon(Mob* iOther) {
bool Mob::HasSpellEffect(int effectid)
{
int i;
int i;
uint32 buff_count = GetMaxTotalSlots();
for(i = 0; i < buff_count; i++)
{
if(buffs[i].spellid == SPELL_UNKNOWN) { continue; }
uint32 buff_count = GetMaxTotalSlots();
for(i = 0; i < buff_count; i++)
{
if(buffs[i].spellid == SPELL_UNKNOWN) { continue; }
if(IsEffectInSpell(buffs[i].spellid, effectid))
{
return(1);
}
}
return(0);
if(IsEffectInSpell(buffs[i].spellid, effectid))
{
return(1);
}
}
return(0);
}

304
zone/npc.cpp
View File

@ -982,7 +982,7 @@ NPC* NPC::SpawnNPC(const char* spawncommand, float in_x, float in_y, float in_z,
uint32 ZoneDatabase::NPCSpawnDB(uint8 command, const char* zone, uint32 zone_version, Client *c, NPC* spawn, uint32 extra) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
uint32 tmp = 0;
@ -996,7 +996,11 @@ uint32 ZoneDatabase::NPCSpawnDB(uint8 command, const char* zone, uint32 zone_ver
{
// Set an npc_type ID within the standard range for the current zone if possible (zone_id * 1000)
int starting_npc_id = c->GetZoneID() * 1000;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT MAX(id) FROM npc_types WHERE id >= %i AND id < %i", starting_npc_id, (starting_npc_id + 1000)), errbuf, &result)) {
StringFormat(query, "SELECT MAX(id) FROM npc_types WHERE id >= %i AND id < %i",
starting_npc_id, (starting_npc_id + 1000));
if (RunQuery(query, errbuf, &result)) {
row = mysql_fetch_row(result);
if(row)
{
@ -1016,66 +1020,105 @@ uint32 ZoneDatabase::NPCSpawnDB(uint8 command, const char* zone, uint32 zone_ver
}
}
safe_delete_array(query);
mysql_free_result(result);
}
}
char tmpstr[64];
char *tmpstr;
EntityList::RemoveNumbers(strn0cpy(tmpstr, spawn->GetName(), sizeof(tmpstr)));
if (npc_type_id)
{
if (!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO npc_types (id, name, level, race, class, hp, gender, texture, helmtexture, size, loottable_id, merchant_id, face, runspeed, prim_melee_type, sec_melee_type) values(%i,\"%s\",%i,%i,%i,%i,%i,%i,%i,%f,%i,%i,%i,%f,%i,%i)", npc_type_id, tmpstr, spawn->GetLevel(), spawn->GetRace(), spawn->GetClass(), spawn->GetMaxHP(), spawn->GetGender(), spawn->GetTexture(), spawn->GetHelmTexture(), spawn->GetSize(), spawn->GetLoottableID(), spawn->MerchantType, 0, spawn->GetRunspeed(), 28, 28), errbuf, 0, 0, &npc_type_id)) {
LogFile->write(EQEMuLog::Error, "NPCSpawnDB Error: %s %s", query, errbuf);
safe_delete(query);
StringFormat(query,"INSERT INTO npc_types "
"(id, name, level, race, class, hp, gender, "
"texture, helmtexture, size, loottable_id, "
"merchant_id, face, runspeed, prim_melee_type, sec_melee_type) "
"values(%i,\"%s\",%i,%i,%i,%i,%i,%i,%i,%f,%i,%i,%i,%f,%i,%i)",
npc_type_id, tmpstr, spawn->GetLevel(), spawn->GetRace(),
spawn->GetClass(), spawn->GetMaxHP(), spawn->GetGender(),
spawn->GetTexture(), spawn->GetHelmTexture(), spawn->GetSize(),
spawn->GetLoottableID(), spawn->MerchantType, 0, spawn->GetRunspeed(),
28, 28);
if (!RunQuery(query, errbuf, 0, 0, &npc_type_id)) {
LogFile->write(EQEMuLog::Error, "NPCSpawnDB Error: %s %s", query.c_str(), errbuf);
return false;
}
}
else
{
if (!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO npc_types (name, level, race, class, hp, gender, texture, helmtexture, size, loottable_id, merchant_id, face, runspeed, prim_melee_type, sec_melee_type) values(\"%s\",%i,%i,%i,%i,%i,%i,%i,%f,%i,%i,%i,%f,%i,%i)", tmpstr, spawn->GetLevel(), spawn->GetRace(), spawn->GetClass(), spawn->GetMaxHP(), spawn->GetGender(), spawn->GetTexture(), spawn->GetHelmTexture(), spawn->GetSize(), spawn->GetLoottableID(), spawn->MerchantType, 0, spawn->GetRunspeed(), 28, 28), errbuf, 0, 0, &npc_type_id)) {
LogFile->write(EQEMuLog::Error, "NPCSpawnDB Error: %s %s", query, errbuf);
safe_delete(query);
StringFormat(query, "INSERT INTO npc_types "
"(name, level, race, class, hp, gender, texture, "
"helmtexture, size, loottable_id, merchant_id, face, "
"runspeed, prim_melee_type, sec_melee_type) "
"values(\"%s\",%i,%i,%i,%i,%i,%i,%i,%f,%i,%i,%i,%f,%i,%i)",
tmpstr, spawn->GetLevel(), spawn->GetRace(), spawn->GetClass(),
spawn->GetMaxHP(), spawn->GetGender(), spawn->GetTexture(),
spawn->GetHelmTexture(), spawn->GetSize(), spawn->GetLoottableID(),
spawn->MerchantType, 0, spawn->GetRunspeed(), 28, 28);
if (!RunQuery(query, errbuf, 0, 0, &npc_type_id)) {
LogFile->write(EQEMuLog::Error, "NPCSpawnDB Error: %s %s", query.c_str(), errbuf);
return false;
}
}
if(c) c->LogSQL(query);
safe_delete_array(query);
snprintf(tmpstr, sizeof(tmpstr), "%s-%s", zone, spawn->GetName());
if (!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO spawngroup (id, name) values(%i, '%s')", tmp, tmpstr), errbuf, 0, 0, &spawngroupid)) {
LogFile->write(EQEMuLog::Error, "NPCSpawnDB Error: %s %s", query, errbuf);
safe_delete(query);
if(c)
c->LogSQL(query.c_str());
std::string spawnIDAndName;
StringFormat(spawnIDAndName, "%s-%s", zone, spawn->GetName());
StringFormat(query,"INSERT INTO spawngroup (id, name) values(%i, '%s')", tmp, spawnIDAndName.c_str());
if (!RunQuery(query,errbuf, 0, 0, &spawngroupid)) {
LogFile->write(EQEMuLog::Error, "NPCSpawnDB Error: %s %s", query.c_str(), errbuf);
return false;
}
if(c) c->LogSQL(query);
safe_delete_array(query);
if (!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO spawn2 (zone, version, x, y, z, respawntime, heading, spawngroupID) values('%s', %u, %f, %f, %f, %i, %f, %i)", zone, zone_version, spawn->GetX(), spawn->GetY(), spawn->GetZ(), 1200, spawn->GetHeading(), spawngroupid), errbuf, 0, 0, &tmp)) {
LogFile->write(EQEMuLog::Error, "NPCSpawnDB Error: %s %s", query, errbuf);
safe_delete(query);
if(c)
c->LogSQL(query.c_str());
StringFormat(query, "INSERT INTO spawn2 "
"(zone, version, x, y, z, respawntime, heading, spawngroupID) "
"values('%s', %u, %f, %f, %f, %i, %f, %i)",
zone, zone_version, spawn->GetX(), spawn->GetY(),
spawn->GetZ(), 1200, spawn->GetHeading(), spawngroupid);
if (!RunQuery(query, errbuf, 0, 0, &tmp)) {
LogFile->write(EQEMuLog::Error, "NPCSpawnDB Error: %s %s", query.c_str(), errbuf);
return false;
}
if(c) c->LogSQL(query);
safe_delete_array(query);
if (!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO spawnentry (spawngroupID, npcID, chance) values(%i, %i, %i)", spawngroupid, npc_type_id, 100), errbuf, 0)) {
LogFile->write(EQEMuLog::Error, "NPCSpawnDB Error: %s %s", query, errbuf);
safe_delete(query);
if(c)
c->LogSQL(query.c_str());
StringFormat(query, "INSERT INTO spawnentry (spawngroupID, npcID, chance) values(%i, %i, %i)",
spawngroupid, npc_type_id, 100);
if (!RunQuery(query, errbuf, 0)) {
LogFile->write(EQEMuLog::Error, "NPCSpawnDB Error: %s %s", query.c_str(), errbuf);
return false;
}
if(c) c->LogSQL(query);
safe_delete_array(query);
if(c)
c->LogSQL(query.c_str());
return true;
break;
}
case 1:{ // Add new spawn group and spawn point for an existing NPC Type ID
tmp2 = spawn->GetNPCTypeID();
char tmpstr[64];
snprintf(tmpstr, sizeof(tmpstr), "%s%s%i", zone, spawn->GetName(),Timer::GetCurrentTime());
if (!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO spawngroup (name) values('%s')", tmpstr), errbuf, 0, 0, &last_insert_id)) {
LogFile->write(EQEMuLog::Error, "NPCSpawnDB Error: %s %s", query, errbuf);
safe_delete(query);
std::string zoneSpawnNameTime;
StringFormat(zoneSpawnNameTime, "%s%s%i", zone, spawn->GetName(),Timer::GetCurrentTime());
StringFormat(query, "INSERT INTO spawngroup (name) values('%s')", zoneSpawnNameTime.c_str());
if (!RunQuery(query, errbuf, 0, 0, &last_insert_id)) {
LogFile->write(EQEMuLog::Error, "NPCSpawnDB Error: %s %s", query.c_str(), errbuf);
return false;
}
if(c) c->LogSQL(query);
safe_delete_array(query);
if(c)
c->LogSQL(query.c_str());
uint32 respawntime = 0;
uint32 spawnid = 0;
@ -1085,77 +1128,110 @@ uint32 ZoneDatabase::NPCSpawnDB(uint8 command, const char* zone, uint32 zone_ver
respawntime = spawn->respawn2->RespawnTimer();
else
respawntime = 1200;
if (!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO spawn2 (zone, version, x, y, z, respawntime, heading, spawngroupID) values('%s', %u, %f, %f, %f, %i, %f, %i)", zone, zone_version, spawn->GetX(), spawn->GetY(), spawn->GetZ(), respawntime, spawn->GetHeading(), last_insert_id), errbuf, 0, 0, &spawnid)) {
LogFile->write(EQEMuLog::Error, "NPCSpawnDB Error: %s %s", query, errbuf);
safe_delete(query);
StringFormat(query, "INSERT INTO spawn2 "
"(zone, version, x, y, z, respawntime, heading, spawngroupID) "
"values('%s', %u, %f, %f, %f, %i, %f, %i)",
zone, zone_version, spawn->GetX(), spawn->GetY(), spawn->GetZ(),
respawntime, spawn->GetHeading(), last_insert_id);
if (!RunQuery(query,errbuf, 0, 0, &spawnid)) {
LogFile->write(EQEMuLog::Error, "NPCSpawnDB Error: %s %s", query.c_str(), errbuf);
return false;
}
if(c) c->LogSQL(query);
safe_delete_array(query);
if(c)
c->LogSQL(query.c_str());
StringFormat(query,"INSERT INTO spawnentry "
"(spawngroupID, npcID, chance) "
"values(%i, %i, %i)",
last_insert_id, tmp2, 100);
if (!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO spawnentry (spawngroupID, npcID, chance) values(%i, %i, %i)", last_insert_id, tmp2, 100), errbuf, 0)) {
LogFile->write(EQEMuLog::Error, "NPCSpawnDB Error: %s %s", query, errbuf);
safe_delete(query);
if (!RunQuery(query, errbuf, 0)) {
LogFile->write(EQEMuLog::Error, "NPCSpawnDB Error: %s %s", query.c_str(), errbuf);
return false;
}
if(c) c->LogSQL(query);
safe_delete_array(query);
if(c)
c->LogSQL(query.c_str());
return spawnid;
break;
}
case 2: { // Update npc_type appearance and other data on targeted spawn
if (!RunQuery(query, MakeAnyLenString(&query, "UPDATE npc_types SET name=\"%s\", level=%i, race=%i, class=%i, hp=%i, gender=%i, texture=%i, helmtexture=%i, size=%i, loottable_id=%i, merchant_id=%i, face=%i, WHERE id=%i", spawn->GetName(), spawn->GetLevel(), spawn->GetRace(), spawn->GetClass(), spawn->GetMaxHP(), spawn->GetGender(), spawn->GetTexture(), spawn->GetHelmTexture(), spawn->GetSize(), spawn->GetLoottableID(), spawn->MerchantType, spawn->GetNPCTypeID()), errbuf, 0)) {
if(c) c->LogSQL(query);
safe_delete_array(query);
StringFormat(query, "UPDATE npc_types SET name=\"%s\", level=%i, race=%i, "
"class=%i, hp=%i, gender=%i, texture=%i, helmtexture=%i, "
"size=%i, loottable_id=%i, merchant_id=%i, face=%i, "
"WHERE id=%i",
spawn->GetName(), spawn->GetLevel(), spawn->GetRace(),
spawn->GetClass(), spawn->GetMaxHP(), spawn->GetGender(),
spawn->GetTexture(), spawn->GetHelmTexture(), spawn->GetSize(),
spawn->GetLoottableID(), spawn->MerchantType, spawn->GetNPCTypeID());
if (!RunQuery(query, errbuf, 0)) {
if(c)
c->LogSQL(query.c_str());
return true;
}
else {
safe_delete_array(query);
return false;
}
return false;
break;
}
case 3: { // delete spawn from spawning, but leave in npc_types table
if (!RunQuery(query, MakeAnyLenString(&query, "SELECT id,spawngroupID from spawn2 where zone='%s' AND spawngroupID=%i", zone, spawn->GetSp2()), errbuf, &result)) {
safe_delete_array(query);
StringFormat(query, "SELECT id,spawngroupID from "
"spawn2 where zone='%s' AND "
"spawngroupID=%i",
zone, spawn->GetSp2());
if (!RunQuery(query, errbuf, &result)) {
return 0;
}
safe_delete_array(query);
row = mysql_fetch_row(result);
if (row == nullptr) return false;
if (row[0]) tmp = atoi(row[0]);
if (row[1]) tmp2 = atoi(row[1]);
if (!RunQuery(query, MakeAnyLenString(&query, "DELETE FROM spawn2 WHERE id='%i'", tmp), errbuf,0)) {
safe_delete(query);
StringFormat(query, "DELETE FROM spawn2 WHERE id='%i'", tmp);
if (!RunQuery(query,errbuf,0)) {
return false;
}
if(c) c->LogSQL(query);
safe_delete_array(query);
if (!RunQuery(query, MakeAnyLenString(&query, "DELETE FROM spawngroup WHERE id='%i'", tmp2), errbuf,0)) {
safe_delete(query);
if(c)
c->LogSQL(query.c_str());
StringFormat(query, "DELETE FROM spawngroup WHERE id='%i'", tmp2);
if (!RunQuery(query, errbuf,0)) {
return false;
}
if(c) c->LogSQL(query);
safe_delete_array(query);
if (!RunQuery(query, MakeAnyLenString(&query, "DELETE FROM spawnentry WHERE spawngroupID='%i'", tmp2), errbuf,0)) {
safe_delete(query);
if(c)
c->LogSQL(query.c_str());
StringFormat(query, "DELETE FROM spawnentry WHERE spawngroupID='%i'", tmp2);
if (!RunQuery(query, errbuf,0)) {
return false;
}
if(c) c->LogSQL(query);
safe_delete_array(query);
if(c)
c->LogSQL(query.c_str());
return true;
break;
}
case 4: { //delete spawn from DB (including npc_type)
if (!RunQuery(query, MakeAnyLenString(&query, "SELECT id,spawngroupID from spawn2 where zone='%s' AND version=%u AND spawngroupID=%i", zone, zone_version, spawn->GetSp2()), errbuf, &result)) {
safe_delete_array(query);
StringFormat(query,"SELECT id,spawngroupID from spawn2 "
"where zone='%s' AND version=%u AND "
"spawngroupID=%i",
zone, zone_version, spawn->GetSp2());
if (!RunQuery(query, errbuf, &result)) {
return(0);
}
safe_delete_array(query);
row = mysql_fetch_row(result);
if (row == nullptr) return false;
@ -1163,40 +1239,59 @@ uint32 ZoneDatabase::NPCSpawnDB(uint8 command, const char* zone, uint32 zone_ver
if (row[1]) tmp2 = atoi(row[1]);
mysql_free_result(result);
if (!RunQuery(query, MakeAnyLenString(&query, "DELETE FROM spawn2 WHERE id='%i'", tmp), errbuf,0)) {
safe_delete(query);
StringFormat(query,"DELETE FROM spawn2 WHERE id='%i'", tmp);
if (!RunQuery(query,errbuf,0)) {
return false;
}
if(c) c->LogSQL(query);
safe_delete_array(query);
if (!RunQuery(query, MakeAnyLenString(&query, "DELETE FROM spawngroup WHERE id='%i'", tmp2), errbuf,0)) {
safe_delete(query);
if(c)
c->LogSQL(query.c_str());
StringFormat(query, "DELETE FROM spawngroup WHERE id='%i'", tmp2);
if (!RunQuery(query, errbuf,0)) {
return false;
}
if(c) c->LogSQL(query);
safe_delete_array(query);
if (!RunQuery(query, MakeAnyLenString(&query, "DELETE FROM spawnentry WHERE spawngroupID='%i'", tmp2), errbuf,0)) {
safe_delete(query);
if(c)
c->LogSQL(query.c_str());
StringFormat(query, "DELETE FROM spawnentry WHERE spawngroupID='%i'", tmp2);
if (!RunQuery(query, errbuf,0)) {
return false;
}
if(c) c->LogSQL(query);
safe_delete_array(query);
if (!RunQuery(query, MakeAnyLenString(&query, "DELETE FROM npc_types WHERE id='%i'", spawn->GetNPCTypeID()), errbuf,0)) {
safe_delete(query);
if(c)
c->LogSQL(query.c_str());
StringFormat(query,"DELETE FROM npc_types WHERE id='%i'", spawn->GetNPCTypeID());
if (!RunQuery(query,errbuf,0)) {
return false;
}
if(c) c->LogSQL(query);
safe_delete_array(query);
if(c)
c->LogSQL(query.c_str());
return true;
break;
}
case 5: { // add a spawn from spawngroup
if (!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO spawn2 (zone, version, x, y, z, respawntime, heading, spawngroupID) values('%s', %u, %f, %f, %f, %i, %f, %i)", zone, zone_version, c->GetX(), c->GetY(), c->GetZ(), 120, c->GetHeading(), extra), errbuf, 0, 0, &tmp)) {
safe_delete(query);
StringFormat(query, "INSERT INTO spawn2 "
"(zone, version, x, y, z, respawntime, heading, spawngroupID) "
"values('%s', %u, %f, %f, %f, %i, %f, %i)",
zone, zone_version, c->GetX(), c->GetY(), c->GetZ(), 120, c->GetHeading(), extra);
if (!RunQuery(query, errbuf, 0, 0, &tmp)) {
return false;
}
if(c) c->LogSQL(query);
safe_delete_array(query);
if(c)
c->LogSQL(query.c_str());
return true;
break;
@ -1204,14 +1299,31 @@ uint32 ZoneDatabase::NPCSpawnDB(uint8 command, const char* zone, uint32 zone_ver
case 6: { // add npc_type
uint32 npc_type_id;
char tmpstr[64];
EntityList::RemoveNumbers(strn0cpy(tmpstr, spawn->GetName(), sizeof(tmpstr)));
if (!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO npc_types (name, level, race, class, hp, gender, texture, helmtexture, size, loottable_id, merchant_id, face, runspeed, prim_melee_type, sec_melee_type) values(\"%s\",%i,%i,%i,%i,%i,%i,%i,%f,%i,%i,%i,%f,%i,%i)", tmpstr, spawn->GetLevel(), spawn->GetRace(), spawn->GetClass(), spawn->GetMaxHP(), spawn->GetGender(), spawn->GetTexture(), spawn->GetHelmTexture(), spawn->GetSize(), spawn->GetLoottableID(), spawn->MerchantType, 0, spawn->GetRunspeed(), 28, 28), errbuf, 0, 0, &npc_type_id)) {
safe_delete(query);
StringFormat(query,"INSERT INTO npc_types "
"(name, level, race, class, hp, gender, "
"texture, helmtexture, size, loottable_id, "
"merchant_id, face, runspeed, prim_melee_type, "
"sec_melee_type) "
"values(\"%s\",%i,%i,%i,%i,%i,%i,%i,%f,%i,%i,%i,%f,%i,%i)",
tmpstr, spawn->GetLevel(), spawn->GetRace(), spawn->GetClass(),
spawn->GetMaxHP(), spawn->GetGender(), spawn->GetTexture(),
spawn->GetHelmTexture(), spawn->GetSize(), spawn->GetLoottableID(),
spawn->MerchantType, 0, spawn->GetRunspeed(), 28, 28);
if (!RunQuery(query, errbuf, 0, 0, &npc_type_id)) {
return false;
}
if(c) c->LogSQL(query);
safe_delete_array(query);
if(c) c->Message(0, "%s npc_type ID %i created successfully!", tmpstr, npc_type_id);
if(c)
c->LogSQL(query.c_str());
if(c)
c->Message(0, "%s npc_type ID %i created successfully!", tmpstr, npc_type_id);
return true;
break;
}

28
zone/parser.cpp
View File

@ -316,16 +316,16 @@ void Parser::Event(QuestEventID event, uint32 npcid, const char * data, NPC* npc
if (npcmob->GetQglobal())
{
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
char tmpname[65];
int charid=0;
if (mob && mob->IsClient()) // some events like waypoint and spawn don't have a player involved
{
charid=mob->CastToClient()->CharacterID();
}
if (mob && mob->IsClient()) // some events like waypoint and spawn don't have a player involved
{
charid=mob->CastToClient()->CharacterID();
}
else
{
@ -333,11 +333,14 @@ void Parser::Event(QuestEventID event, uint32 npcid, const char * data, NPC* npc
}
AddVar("charid.g",itoa(charid));
database.RunQuery(query, MakeAnyLenString(&query,
"SELECT name,value FROM quest_globals WHERE (npcid=%i || npcid=0) && (charid=%i || charid=0) && (zoneid=%i || zoneid=0) && expdate >= unix_timestamp(now())",
npcmob->GetNPCTypeID(),charid,zone->GetZoneID()), errbuf, &result);
printf("%s\n",query);
StringFormat(query,"SELECT name, value FROM quest_globals WHERE "
"(npcid=%i || npcid=0) && (charid=%i || charid=0) && "
"(zoneid=%i || zoneid=0) && expdate >= unix_timestamp(now())",
npcmob->GetNPCTypeID(), charid, zone->GetZoneID());
database.RunQuery(query, errbuf, &result);
printf("%s\n",query.c_str());
printf("%s\n",errbuf);
if (result)
{
@ -349,11 +352,6 @@ void Parser::Event(QuestEventID event, uint32 npcid, const char * data, NPC* npc
}
mysql_free_result(result);
}
if (query)
{
safe_delete_array(query);
query=0;
}
}
if (event == EVENT_TIMER)

79
zone/petitions.cpp
View File

@ -217,30 +217,42 @@ void PetitionList::UpdatePetition(Petition* pet) {
void ZoneDatabase::DeletePetitionFromDB(Petition* wpet) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
uint32 affected_rows = 0;
uint8 checkedout = 0;
if (wpet->CheckedOut()) checkedout = 0;
else checkedout = 1;
if (!RunQuery(query, MakeAnyLenString(&query, "DELETE from petitions where petid = %i", wpet->GetID()), errbuf, 0, &affected_rows)) {
LogFile->write(EQEMuLog::Error, "Error in DeletePetitionFromDB query '%s': %s", query, errbuf);
if (wpet->CheckedOut())
checkedout = 0;
else
checkedout = 1;
StringFormat(query, "DELETE from petitions where petid = %i", wpet->GetID());
if (!RunQuery(query, errbuf, 0, &affected_rows)) {
LogFile->write(EQEMuLog::Error, "Error in DeletePetitionFromDB query '%s': %s", query.c_str(), errbuf);
}
safe_delete_array(query);
return;
}
void ZoneDatabase::UpdatePetitionToDB(Petition* wpet) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
uint32 affected_rows = 0;
uint8 checkedout = 0;
if (wpet->CheckedOut()) checkedout = 1;
else checkedout = 0;
if (!RunQuery(query, MakeAnyLenString(&query, "UPDATE petitions set gmtext = '%s', lastgm = '%s', urgency = %i, checkouts = %i, unavailables = %i, ischeckedout = %i where petid = %i", wpet->GetGMText(), wpet->GetLastGM(), wpet->GetUrgency(), wpet->GetCheckouts(), wpet->GetUnavails(), checkedout, wpet->GetID()), errbuf, 0, &affected_rows)) {
LogFile->write(EQEMuLog::Error, "Error in UpdatePetitionToDB query '%s': %s", query, errbuf);
if (wpet->CheckedOut())
checkedout = 1;
else
checkedout = 0;
StringFormat(query,"UPDATE petitions set gmtext = '%s', lastgm = '%s', urgency = %i, "
"checkouts = %i, unavailables = %i, ischeckedout = %i where petid = %i",
wpet->GetGMText(), wpet->GetLastGM(), wpet->GetUrgency(),
wpet->GetCheckouts(), wpet->GetUnavails(), checkedout, wpet->GetID());
if (!RunQuery(query, errbuf, 0, &affected_rows)) {
LogFile->write(EQEMuLog::Error, "Error in UpdatePetitionToDB query '%s': %s", query.c_str(), errbuf);
}
safe_delete_array(query);
return;
}
@ -249,7 +261,7 @@ void ZoneDatabase::UpdatePetitionToDB(Petition* wpet) {
void ZoneDatabase::InsertPetitionToDB(Petition* wpet)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
uint32 affected_rows = 0;
uint8 checkedout = 0;
if (wpet->CheckedOut())
@ -258,15 +270,22 @@ void ZoneDatabase::InsertPetitionToDB(Petition* wpet)
checkedout = 0;
uint32 len = strlen(wpet->GetPetitionText());
char* petitiontext = new char[2*len+1];
memset(petitiontext, 0, 2*len+1);
std::string petitiontext;
DoEscapeString(petitiontext, wpet->GetPetitionText(), len);
if (!RunQuery(query, MakeAnyLenString(&query, "INSERT INTO petitions (petid, charname, accountname, lastgm, petitiontext, zone, urgency, charclass, charrace, charlevel, checkouts, unavailables, ischeckedout, senttime, gmtext) values (%i,'%s','%s','%s','%s',%i,%i,%i,%i,%i,%i,%i,%i,%i, '%s')", wpet->GetID(), wpet->GetCharName(), wpet->GetAccountName(), wpet->GetLastGM(), petitiontext, wpet->GetZone(), wpet->GetUrgency(), wpet->GetCharClass(), wpet->GetCharRace(), wpet->GetCharLevel(), wpet->GetCheckouts(), wpet->GetUnavails(), checkedout, wpet->GetSentTime(), wpet->GetGMText()), errbuf, 0, &affected_rows)) {
LogFile->write(EQEMuLog::Error, "Error in InsertPetitionToDB query '%s': %s", query, errbuf);
StringFormat(query,"INSERT INTO petitions (petid, charname, accountname, lastgm, "
"petitiontext, zone, urgency, charclass, charrace, charlevel, "
"checkouts, unavailables, ischeckedout, senttime, gmtext) "
"values (%i,'%s','%s','%s','%s',%i,%i,%i,%i,%i,%i,%i,%i,%i, '%s')",
wpet->GetID(), wpet->GetCharName(), wpet->GetAccountName(), wpet->GetLastGM(),
petitiontext.c_str(), wpet->GetZone(), wpet->GetUrgency(), wpet->GetCharClass(),
wpet->GetCharRace(), wpet->GetCharLevel(), wpet->GetCheckouts(),
wpet->GetUnavails(), checkedout, wpet->GetSentTime(), wpet->GetGMText());
if (!RunQuery(query, errbuf, 0, &affected_rows)) {
LogFile->write(EQEMuLog::Error, "Error in InsertPetitionToDB query '%s': %s", query.c_str(), errbuf);
}
safe_delete_array(petitiontext);
safe_delete_array(query);
#if EQDEBUG >= 5
LogFile->write(EQEMuLog::Debug, "New petition created");
#endif
@ -276,13 +295,18 @@ void ZoneDatabase::InsertPetitionToDB(Petition* wpet)
void ZoneDatabase::RefreshPetitionsFromDB()
{
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
Petition* newpet;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT petid, charname, accountname, lastgm, petitiontext, zone, urgency, charclass, charrace, charlevel, checkouts, unavailables, ischeckedout, senttime, gmtext from petitions order by petid"), errbuf, &result))
query ="SELECT petid, charname, accountname, lastgm, "
"petitiontext, zone, urgency, charclass, charrace, "
"charlevel, checkouts, unavailables, ischeckedout, "
"senttime, gmtext from petitions order by petid";
if (RunQuery(query, errbuf, &result))
{
safe_delete_array(query);
while ((row = mysql_fetch_row(result))) {
newpet = new Petition(atoi(row[0]));
newpet->SetCName(row[1]);
@ -299,15 +323,18 @@ void ZoneDatabase::RefreshPetitionsFromDB()
newpet->SetSentTime2(atol(row[13]));
newpet->SetGMText(row[14]);
std::cout << "Petition " << row[0] << " pettime = " << newpet->GetSentTime() << std::endl;
if (atoi(row[12]) == 1) newpet->SetCheckedOut(true);
else newpet->SetCheckedOut(false);
if (atoi(row[12]) == 1)
newpet->SetCheckedOut(true);
else
newpet->SetCheckedOut(false);
petition_list.AddPetition(newpet);
}
mysql_free_result(result);
}
else {
LogFile->write(EQEMuLog::Error, "Error in RefreshPetitionsFromDB query '%s': %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in RefreshPetitionsFromDB query '%s': %s", query.c_str(), errbuf);
return;
}

68
zone/pets.cpp
View File

@ -362,18 +362,23 @@ void Mob::MakePoweredPet(uint16 spell_id, const char* pettype, int16 petpower, c
// handle monster summoning pet appearance
if(record.monsterflag) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result = nullptr;
MYSQL_ROW row = nullptr;
uint32 monsterid;
StringFormat(query, "SELECT npcID FROM (spawnentry INNER JOIN spawn2 ON "
"spawn2.spawngroupID = spawnentry.spawngroupID) "
"INNER JOIN npc_types ON npc_types.id = spawnentry.npcID "
"WHERE spawn2.zone = '%s' AND npc_types.bodytype NOT IN (11, 33, 66, 67) "
"AND npc_types.race NOT IN (0,1,2,3,4,5,6,7,8,9,10,11,12,44,55,67,"
"71,72,73,77,78,81,90,92,93,94,106,112,114,127,128,130,139,141,183,"
"236,237,238,239,254,266,330,378,379,380,381,382,383,404,522) "
"ORDER BY RAND() LIMIT 1",
zone->GetShortName());
// get a random npc id from the spawngroups assigned to this zone
if (database.RunQuery(query, MakeAnyLenString(&query,
"SELECT npcID FROM (spawnentry INNER JOIN spawn2 ON spawn2.spawngroupID = spawnentry.spawngroupID) "
"INNER JOIN npc_types ON npc_types.id = spawnentry.npcID "
"WHERE spawn2.zone = '%s' AND npc_types.bodytype NOT IN (11, 33, 66, 67) "
"AND npc_types.race NOT IN (0,1,2,3,4,5,6,7,8,9,10,11,12,44,55,67,71,72,73,77,78,81,90,92,93,94,106,112,114,127,128,130,139,141,183,236,237,238,239,254,266,330,378,379,380,381,382,383,404,522) "
"ORDER BY RAND() LIMIT 1", zone->GetShortName()), errbuf, &result))
if (database.RunQuery(query, errbuf, &result))
{
row = mysql_fetch_row(result);
if (row)
@ -398,7 +403,6 @@ void Mob::MakePoweredPet(uint16 spell_id, const char* pettype, int16 petpower, c
LogFile->write(EQEMuLog::Error, "Error loading NPC data for monster summoning pet (NPC ID %d)", monsterid);
}
safe_delete_array(query);
}
//this takes ownership of the npc_type data
@ -445,24 +449,28 @@ bool ZoneDatabase::GetPetEntry(const char *pet_type, PetRecord *into) {
bool ZoneDatabase::GetPoweredPetEntry(const char *pet_type, int16 petpower, PetRecord *into) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
uint32 querylen = 0;
MYSQL_RES *result;
MYSQL_ROW row;
if (petpower <= 0) {
querylen = MakeAnyLenString(&query,
"SELECT npcID, temp, petpower, petcontrol, petnaming, monsterflag, equipmentset FROM pets "
"WHERE type='%s' AND petpower<=0", pet_type);
StringFormat(query,"SELECT npcID, temp, petpower, petcontrol, "
"petnaming, monsterflag, equipmentset FROM pets "
"WHERE type='%s' AND petpower<=0",
pet_type);
}
else {
querylen = MakeAnyLenString(&query,
"SELECT npcID, temp, petpower, petcontrol, petnaming, monsterflag, equipmentset FROM pets "
"WHERE type='%s' AND petpower<=%d ORDER BY petpower DESC LIMIT 1", pet_type, petpower);
StringFormat(query, "SELECT npcID, temp, petpower, petcontrol, "
"petnaming, monsterflag, equipmentset FROM pets "
"WHERE type='%s' AND petpower<=%d ORDER BY petpower "
"DESC LIMIT 1",
pet_type, petpower);
}
if (RunQuery(query, querylen, errbuf, &result)) {
safe_delete_array(query);
if (RunQuery(query, errbuf, &result)) {
if (mysql_num_rows(result) == 1) {
row = mysql_fetch_row(result);
@ -480,8 +488,7 @@ bool ZoneDatabase::GetPoweredPetEntry(const char *pet_type, int16 petpower, PetR
mysql_free_result(result);
}
else {
LogFile->write(EQEMuLog::Error, "Error in GetPoweredPetEntry query '%s': %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in GetPoweredPetEntry query '%s': %s", query.c_str(), errbuf);
}
return(false);
}
@ -653,7 +660,7 @@ bool ZoneDatabase::GetBasePetItems(int32 equipmentset, uint32 *items) {
// an equipmentset can overload a slot for the set(s) it includes.
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
uint32 querylen = 0;
MYSQL_RES *result;
MYSQL_ROW row;
@ -670,21 +677,20 @@ bool ZoneDatabase::GetBasePetItems(int32 equipmentset, uint32 *items) {
// already. If no, add the item id to the equipment array.
while (curset >= 0 && depth < 5) {
if (RunQuery(query,
MakeAnyLenString(&query, "SELECT nested_set FROM pets_equipmentset WHERE set_id='%s'", curset),
errbuf, &result))
StringFormat(query,"SELECT nested_set FROM pets_equipmentset WHERE set_id='%s'", curset);
if (RunQuery(query, errbuf, &result))
{
safe_delete_array(query);
if (mysql_num_rows(result) == 1) {
row = mysql_fetch_row(result);
nextset = atoi(row[0]);
mysql_free_result(result);
StringFormat(query,"SELECT slot, item_id FROM pets_equipmentset_entries WHERE set_id='%s'", curset);
if (RunQuery(query,
MakeAnyLenString(&query, "SELECT slot, item_id FROM pets_equipmentset_entries WHERE set_id='%s'", curset),
errbuf, &result))
if (RunQuery(query, errbuf, &result))
{
safe_delete_array(query);
while ((row = mysql_fetch_row(result)))
{
slot = atoi(row[0]);
@ -697,8 +703,7 @@ bool ZoneDatabase::GetBasePetItems(int32 equipmentset, uint32 *items) {
mysql_free_result(result);
}
else {
LogFile->write(EQEMuLog::Error, "Error in GetBasePetItems query '%s': %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in GetBasePetItems query '%s': %s", query.c_str(), errbuf);
}
curset = nextset;
depth++;
@ -713,8 +718,7 @@ bool ZoneDatabase::GetBasePetItems(int32 equipmentset, uint32 *items) {
}
else
{
LogFile->write(EQEMuLog::Error, "Error in GetBasePetItems query '%s': %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in GetBasePetItems query '%s': %s", query.c_str(), errbuf);
return false;
}
} // end while

85
zone/questmgr.cpp
View File

@ -1235,13 +1235,10 @@ void QuestManager::setglobal(const char *varname, const char *newvalue, int opti
}
/* Inserts global variable into quest_globals table */
int QuestManager::InsertQuestGlobal(
int charid, int npcid, int zoneid,
const char *varname, const char *varvalue,
int duration)
int QuestManager::InsertQuestGlobal(int charid, int npcid, int zoneid,const char *varname, const char *varvalue,int duration)
{
char *query = 0;
char errbuf[MYSQL_ERRMSG_SIZE];
std::string query;
// Make duration string either "unix_timestamp(now()) + xxx" or "NULL"
std::stringstream duration_ss;
@ -1257,15 +1254,14 @@ int QuestManager::InsertQuestGlobal(
//NOTE: this should be escaping the contents of arglist
//npcwise a malicious script can arbitrarily alter the DB
uint32 last_id = 0;
if (!database.RunQuery(query, MakeAnyLenString(&query,
"REPLACE INTO quest_globals (charid, npcid, zoneid, name, value, expdate)"
"VALUES (%i, %i, %i, '%s', '%s', %s)",
charid, npcid, zoneid, varname, varvalue, duration_ss.str().c_str()
), errbuf, nullptr, nullptr, &last_id))
{
StringFormat(query, "REPLACE INTO quest_globals (charid, npcid, zoneid, name, value, expdate)"
"VALUES (%i, %i, %i, '%s', '%s', %s)",
charid, npcid, zoneid, varname, varvalue, duration_ss.str().c_str());
if (!database.RunQuery(query, errbuf, nullptr, nullptr, &last_id)) {
std::cerr << "setglobal error inserting " << varname << " : " << errbuf << std::endl;
}
safe_delete_array(query);
if(zone)
{
@ -1330,7 +1326,7 @@ void QuestManager::targlobal(const char *varname, const char *value, const char
void QuestManager::delglobal(const char *varname) {
// delglobal(varname)
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
int qgZoneid=zone->GetZoneID();
int qgCharid=0;
int qgNpcid=owner->GetNPCTypeID();
@ -1343,15 +1339,17 @@ void QuestManager::delglobal(const char *varname) {
{
qgCharid=-qgNpcid; // make char id negative npc id as a fudge
}
if (!database.RunQuery(query,
MakeAnyLenString(&query,
"DELETE FROM quest_globals WHERE name='%s'"
" && (npcid=0 || npcid=%i) && (charid=0 || charid=%i) && (zoneid=%i || zoneid=0)",
varname,qgNpcid,qgCharid,qgZoneid),errbuf))
StringFormat(query,"DELETE FROM quest_globals WHERE name='%s' && "
"(npcid=0 || npcid=%i) && "
"(charid=0 || charid=%i) "
"&& (zoneid=%i || zoneid=0)",
varname,qgNpcid,qgCharid,qgZoneid);
if (!database.RunQuery(query,errbuf))
{
std::cerr << "delglobal error deleting " << varname << " : " << errbuf << std::endl;
}
safe_delete_array(query);
if(zone)
{
@ -1563,7 +1561,7 @@ void QuestManager::showgrid(int grid) {
return;
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
@ -1576,7 +1574,12 @@ void QuestManager::showgrid(int grid) {
pts.push_back(pt);
// Retrieve all waypoints for this grid
if(database.RunQuery(query,MakeAnyLenString(&query,"SELECT `x`,`y`,`z` FROM grid_entries WHERE `gridid`=%i AND `zoneid`=%i ORDER BY `number`",grid,zone->GetZoneID()),errbuf,&result))
StringFormat(query,"SELECT `x`,`y`,`z` FROM "
"grid_entries WHERE `gridid`=%i "
"AND `zoneid`=%i ORDER BY `number`",
grid,zone->GetZoneID());
if(database.RunQuery(query,errbuf,&result))
{
while((row = mysql_fetch_row(result)))
{
@ -1594,7 +1597,6 @@ void QuestManager::showgrid(int grid) {
LogFile->write(EQEMuLog::Quest, "Error loading grid %d for showgrid(): %s", grid, errbuf);
return;
}
safe_delete_array(query);
}
//displays an in game path based on path finding.
@ -2137,10 +2139,13 @@ void QuestManager::clearspawntimers() {
while (iterator.MoreElements())
{
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
database.RunQuery(query, MakeAnyLenString(&query, "DELETE FROM respawn_times WHERE id=%lu AND "
"instance_id=%lu",(unsigned long)iterator.GetData()->GetID(), (unsigned long)zone->GetInstanceID()), errbuf);
safe_delete_array(query);
std::string query;
StringFormat(query,"DELETE FROM respawn_times WHERE id=%lu AND instance_id=%lu",
(unsigned long)iterator.GetData()->GetID(),
(unsigned long)zone->GetInstanceID());
database.RunQuery(query, errbuf);
iterator.Advance();
}
}
@ -2473,17 +2478,19 @@ const char* QuestManager::saylink(char* Phrase, bool silent, char* LinkName) {
const char *ERR_MYSQLERROR = "Error in saylink phrase queries";
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
int sayid = 0;
int sz = strlen(Phrase);
char *escaped_string = new char[sz * 2];
std::string escaped_string;
database.DoEscapeString(escaped_string, Phrase, sz);
// Query for an existing phrase and id in the saylink table
if(database.RunQuery(query,MakeAnyLenString(&query,"SELECT `id` FROM `saylink` WHERE `phrase` = '%s'", escaped_string),errbuf,&result))
StringFormat(query,"SELECT `id` FROM `saylink` WHERE `phrase` = '%s'", escaped_string.c_str());
if(database.RunQuery(query,errbuf,&result))
{
if (mysql_num_rows(result) >= 1)
{
@ -2495,12 +2502,13 @@ const char* QuestManager::saylink(char* Phrase, bool silent, char* LinkName) {
}
else // Add a new saylink entry to the database and query it again for the new sayid number
{
safe_delete_array(query);
database.RunQuery(query,MakeAnyLenString(&query,"INSERT INTO `saylink` (`phrase`) VALUES ('%s')", escaped_string),errbuf);
safe_delete_array(query);
if(database.RunQuery(query,MakeAnyLenString(&query,"SELECT `id` FROM saylink WHERE `phrase` = '%s'", escaped_string),errbuf,&result))
StringFormat(query,"INSERT INTO `saylink` (`phrase`) VALUES ('%s')", escaped_string.c_str());
database.RunQuery(query,errbuf);
StringFormat(query,"SELECT `id` FROM saylink WHERE `phrase` = '%s'", escaped_string.c_str());
if(database.RunQuery(query,errbuf,&result))
{
if (mysql_num_rows(result) >= 1)
{
@ -2515,19 +2523,16 @@ const char* QuestManager::saylink(char* Phrase, bool silent, char* LinkName) {
{
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR, errbuf);
}
safe_delete_array(query);
}
}
safe_delete_array(query);
safe_delete_array(escaped_string);
if(silent)
sayid = sayid + 750000;
else
sayid = sayid + 500000;
//Create the say link as an item link hash
char linktext[250];
//Create the say link as an item link hash
char linktext[250];
if(initiator)
{

137
zone/raids.cpp
View File

@ -75,13 +75,18 @@ void Raid::AddMember(Client *c, uint32 group, bool rleader, bool groupleader, bo
return;
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
if (database.RunQuery(query,MakeAnyLenString(&query, "INSERT INTO raid_members SET raidid=%lu, charid=%lu, groupid=%lu, _class=%d, level=%d, name='%s', isgroupleader=%d, israidleader=%d, islooter=%d", (unsigned long)GetID(), (unsigned long)c->CharacterID(), (unsigned long)group, c->GetClass(), c->GetLevel(), c->GetName(), groupleader, rleader, looter ),errbuf,&result)){
StringFormat(query,"INSERT INTO raid_members SET raidid=%lu, charid=%lu, groupid=%lu, "
"_class=%d, level=%d, name='%s', isgroupleader=%d, israidleader=%d, islooter=%d",
(unsigned long)GetID(), (unsigned long)c->CharacterID(), (unsigned long)group,
c->GetClass(), c->GetLevel(), c->GetName(), groupleader, rleader, looter );
if (database.RunQuery(query,errbuf,&result)){
mysql_free_result(result);
}
safe_delete_array(query);
LearnMembers();
VerifyRaid();
if(group < 12)
@ -103,14 +108,16 @@ void Raid::AddMember(Client *c, uint32 group, bool rleader, bool groupleader, bo
void Raid::RemoveMember(const char *c)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
if (database.RunQuery(query,MakeAnyLenString(&query, "DELETE FROM raid_members where name='%s'", c ),errbuf,&result)){
StringFormat(query,"DELETE FROM raid_members where name='%s'", c );
if (database.RunQuery(query,errbuf,&result)){
mysql_free_result(result);
}
Client *m = entity_list.GetClientByName(c);
safe_delete_array(query);
disbandCheck = true;
SendRaidRemoveAll(c);
SendRaidDisband(m);
@ -134,13 +141,15 @@ void Raid::RemoveMember(const char *c)
void Raid::DisbandRaid()
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
if (database.RunQuery(query,MakeAnyLenString(&query, "DELETE FROM raid_members WHERE raidid=%lu", (unsigned long)GetID()),errbuf,&result)){
StringFormat(query,"DELETE FROM raid_members WHERE raidid=%lu", (unsigned long)GetID());
if (database.RunQuery(query,errbuf,&result)){
mysql_free_result(result);
}
safe_delete_array(query);
LearnMembers();
VerifyRaid();
SendRaidDisbandAll();
@ -160,13 +169,16 @@ void Raid::DisbandRaid()
void Raid::MoveMember(const char *name, uint32 newGroup)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
if (database.RunQuery(query,MakeAnyLenString(&query, "UPDATE raid_members SET groupid=%lu WHERE name='%s'", (unsigned long)newGroup, name),errbuf,&result)){
StringFormat(query,"UPDATE raid_members SET groupid=%lu WHERE name='%s'",
(unsigned long)newGroup, name);
if (database.RunQuery(query,errbuf,&result)){
mysql_free_result(result);
}
safe_delete_array(query);
LearnMembers();
VerifyRaid();
SendRaidMoveAll(name);
@ -184,13 +196,15 @@ void Raid::MoveMember(const char *name, uint32 newGroup)
void Raid::SetGroupLeader(const char *who, bool glFlag)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
if (database.RunQuery(query,MakeAnyLenString(&query, "UPDATE raid_members SET isgroupleader=%lu WHERE name='%s'", (unsigned long)glFlag, who),errbuf,&result)){
StringFormat(query,"UPDATE raid_members SET isgroupleader=%lu WHERE name='%s'",
(unsigned long)glFlag, who);
if (database.RunQuery(query,errbuf,&result)){
mysql_free_result(result);
}
safe_delete_array(query);
LearnMembers();
VerifyRaid();
@ -211,25 +225,25 @@ void Raid::SetGroupLeader(const char *who, bool glFlag)
void Raid::SetRaidLeader(const char *wasLead, const char *name)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
if (!database.RunQuery(query,MakeAnyLenString(&query, "UPDATE raid_members SET israidleader=0 WHERE name='%s'", wasLead),errbuf,&result)){
StringFormat(query,"UPDATE raid_members SET israidleader=0 WHERE name='%s'", wasLead);
if (!database.RunQuery(query,errbuf,&result)){
printf("Set Raid Leader error: %s\n", errbuf);
}
else
mysql_free_result(result);
safe_delete_array(query);
query = 0;
StringFormat(query,"UPDATE raid_members SET israidleader=1 WHERE name='%s'", name);
if (!database.RunQuery(query,MakeAnyLenString(&query, "UPDATE raid_members SET israidleader=1 WHERE name='%s'", name),errbuf,&result)){
if (!database.RunQuery(query,errbuf,&result)){
printf("Set Raid Leader error: %s\n", errbuf);
}
else
mysql_free_result(result);
safe_delete_array(query);
strn0cpy(leadername, name, 64);
Client *c = entity_list.GetClientByName(name);
@ -265,13 +279,16 @@ bool Raid::IsGroupLeader(const char *who)
void Raid::UpdateLevel(const char *name, int newLevel)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
if (database.RunQuery(query,MakeAnyLenString(&query, "UPDATE raid_members SET level=%lu WHERE name='%s'", (unsigned long)newLevel, name),errbuf,&result)){
StringFormat(query,"UPDATE raid_members SET level=%lu WHERE name='%s'",
(unsigned long)newLevel, name);
if (database.RunQuery(query,errbuf,&result)){
mysql_free_result(result);
}
safe_delete_array(query);
LearnMembers();
VerifyRaid();
}
@ -720,27 +737,31 @@ void Raid::TeleportRaid(Mob* sender, uint32 zoneID, uint16 instance_id, float x,
void Raid::ChangeLootType(uint32 type)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
if (database.RunQuery(query,MakeAnyLenString(&query, "UPDATE raid_details SET loottype=%lu WHERE raidid=%lu", (unsigned long)type, (unsigned long)GetID()),errbuf,&result)){
StringFormat(query,"UPDATE raid_details SET loottype=%lu WHERE raidid=%lu",
(unsigned long)type, (unsigned long)GetID());
if (database.RunQuery(query,errbuf,&result)){
mysql_free_result(result);
}
safe_delete_array(query);
LootType = type;
}
void Raid::AddRaidLooter(const char* looter)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
if (database.RunQuery(query,MakeAnyLenString(&query, "UPDATE raid_members SET islooter=1 WHERE name='%s'", looter),errbuf,&result)){
StringFormat(query,"UPDATE raid_members SET islooter=1 WHERE name='%s'", looter);
if (database.RunQuery(query,errbuf,&result)){
mysql_free_result(result);
}
safe_delete_array(query);
for(int x = 0; x < MAX_RAID_MEMBERS; x++)
{
if(strcmp(looter, members[x].membername) == 0)
@ -770,14 +791,15 @@ void Raid::AddRaidLooter(const char* looter)
void Raid::RemoveRaidLooter(const char* looter)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
if (database.RunQuery(query,MakeAnyLenString(&query, "UPDATE raid_members SET islooter=0 WHERE name='%s'", looter),errbuf,&result)){
StringFormat(query, "UPDATE raid_members SET islooter=0 WHERE name='%s'", looter);
if (database.RunQuery(query, errbuf,&result)){
mysql_free_result(result);
}
safe_delete_array(query);
for(int x = 0; x < MAX_RAID_MEMBERS; x++)
{
if(strcmp(looter, members[x].membername) == 0)
@ -1226,13 +1248,16 @@ void Raid::SendRaidGroupRemove(const char *who, uint32 gid)
void Raid::LockRaid(bool lockFlag)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
if (database.RunQuery(query,MakeAnyLenString(&query, "UPDATE raid_details SET locked=%d WHERE raidid=%lu", lockFlag, (unsigned long)GetID()),errbuf,&result)){
StringFormat(query,"UPDATE raid_details SET locked=%d WHERE raidid=%lu",
lockFlag, (unsigned long)GetID());
if (database.RunQuery(query,errbuf,&result)){
mysql_free_result(result);
}
safe_delete_array(query);
locked = lockFlag;
if(lockFlag)
SendRaidLock();
@ -1252,23 +1277,29 @@ void Raid::LockRaid(bool lockFlag)
void Raid::SetRaidDetails()
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
if (database.RunQuery(query,MakeAnyLenString(&query, "INSERT INTO raid_details SET raidid=%lu, loottype=4, locked=0", (unsigned long)GetID()),errbuf,&result)){
StringFormat(query,"INSERT INTO raid_details SET raidid=%lu, loottype=4, locked=0",
(unsigned long)GetID());
if (database.RunQuery(query, errbuf,&result)){
mysql_free_result(result);
}
safe_delete_array(query);
}
void Raid::GetRaidDetails()
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (database.RunQuery(query,MakeAnyLenString(&query, "SELECT locked, loottype FROM raid_details WHERE raidid=%lu", (unsigned long)GetID()),errbuf,&result)){
safe_delete_array(query);
StringFormat(query,"SELECT locked, loottype FROM raid_details WHERE raidid=%lu",
(unsigned long)GetID());
if (database.RunQuery(query,errbuf,&result)){
if(mysql_num_rows(result) < 1) {
mysql_free_result(result);
LogFile->write(EQEMuLog::Error, "Error getting raid details for raid %lu: %s", (unsigned long)GetID(), errbuf);
@ -1287,11 +1318,15 @@ bool Raid::LearnMembers()
{
memset(members, 0, (sizeof(RaidMember)*MAX_RAID_MEMBERS));
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (database.RunQuery(query,MakeAnyLenString(&query, "SELECT name, groupid, _class, level, isgroupleader, israidleader, islooter FROM raid_members WHERE raidid=%lu", (unsigned long)GetID()),errbuf,&result)){
safe_delete_array(query);
StringFormat(query,"SELECT name, groupid, _class, level, isgroupleader, israidleader, islooter "
"FROM raid_members WHERE raidid=%lu",
(unsigned long)GetID());
if (database.RunQuery(query,errbuf,&result)){
if(mysql_num_rows(result) < 1) {
mysql_free_result(result);
LogFile->write(EQEMuLog::Error, "Error getting raid members for raid %lu: %s", (unsigned long)GetID(), errbuf);
@ -1318,7 +1353,7 @@ bool Raid::LearnMembers()
}
mysql_free_result(result);
}
return(true);
return true;
}
void Raid::VerifyRaid()

129
zone/spawn2.cpp
View File

@ -355,16 +355,19 @@ void Spawn2::DeathReset(bool realdeath)
bool ZoneDatabase::PopulateZoneSpawnList(uint32 zoneid, LinkedList<Spawn2*> &spawn2_list, int16 version, uint32 repopdelay) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
const char *zone_name = database.GetZoneName(zoneid);
MakeAnyLenString(&query, "SELECT id, spawngroupID, x, y, z, heading, respawntime, variance, pathgrid, _condition, cond_value, enabled, animation FROM spawn2 WHERE zone='%s' AND version=%u", zone_name, version);
if (RunQuery(query, strlen(query), errbuf, &result))
StringFormat(query, "SELECT id, spawngroupID, x, y, z, heading, respawntime, variance, "
"pathgrid, _condition, cond_value, enabled, animation FROM spawn2 "
"WHERE zone='%s' AND version=%u",
zone_name, version);
if (RunQuery(query, errbuf, &result))
{
safe_delete_array(query);
while((row = mysql_fetch_row(result)))
{
Spawn2* newSpawn = 0;
@ -378,8 +381,7 @@ bool ZoneDatabase::PopulateZoneSpawnList(uint32 zoneid, LinkedList<Spawn2*> &spa
}
else
{
LogFile->write(EQEMuLog::Error, "Error in PopulateZoneLists query '%s': %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in PopulateZoneLists query '%s': %s", query.c_str(), errbuf);
return false;
}
@ -389,11 +391,15 @@ bool ZoneDatabase::PopulateZoneSpawnList(uint32 zoneid, LinkedList<Spawn2*> &spa
Spawn2* ZoneDatabase::LoadSpawn2(LinkedList<Spawn2*> &spawn2_list, uint32 spawn2id, uint32 timeleft) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT id, spawngroupID, x, y, z, heading, respawntime, variance, pathgrid, _condition, cond_value, enabled, animation FROM spawn2 WHERE id=%i", spawn2id), errbuf, &result)) {
StringFormat(query,"SELECT id, spawngroupID, x, y, z, heading, respawntime, "
"variance, pathgrid, _condition, cond_value, enabled, animation "
"FROM spawn2 WHERE id=%i", spawn2id);
if (RunQuery(query, errbuf, &result)) {
if (mysql_num_rows(result) == 1)
{
row = mysql_fetch_row(result);
@ -401,14 +407,12 @@ Spawn2* ZoneDatabase::LoadSpawn2(LinkedList<Spawn2*> &spawn2_list, uint32 spawn2
Spawn2* newSpawn = new Spawn2(atoi(row[0]), atoi(row[1]), atof(row[2]), atof(row[3]), atof(row[4]), atof(row[5]), atoi(row[6]), atoi(row[7]), timeleft, atoi(row[8]), atoi(row[9]), atoi(row[10]), perl_enabled, (EmuAppearance)atoi(row[12]));
spawn2_list.Insert( newSpawn );
mysql_free_result(result);
safe_delete_array(query);
return newSpawn;
}
mysql_free_result(result);
}
LogFile->write(EQEMuLog::Error, "Error in LoadSpawn2 query '%s': %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in LoadSpawn2 query '%s': %s", query.c_str(), errbuf);
return 0;
}
@ -416,7 +420,7 @@ bool ZoneDatabase::CreateSpawn2(Client *c, uint32 spawngroup, const char* zone,
{
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
uint32 affected_rows = 0;
// if(GetInverseXY()==1) {
@ -424,22 +428,22 @@ bool ZoneDatabase::CreateSpawn2(Client *c, uint32 spawngroup, const char* zone,
// x=y;
// y=temp;
// }
if (RunQuery(query, MakeAnyLenString(&query,
"INSERT INTO spawn2 (spawngroupID,zone,x,y,z,heading,respawntime,variance,_condition,cond_value) Values (%i, '%s', %f, %f, %f, %f, %i, %i, %u, %i)",
spawngroup, zone, x, y, z, heading, respawn, variance, condition, cond_value
), errbuf, 0, &affected_rows)) {
safe_delete_array(query);
StringFormat(query,"INSERT INTO spawn2 (spawngroupID,zone,x,y,z,heading,respawntime,variance,_condition,cond_value) "
"Values (%i, '%s', %f, %f, %f, %f, %i, %i, %u, %i)",
spawngroup, zone, x, y, z, heading, respawn, variance, condition, cond_value);
if (RunQuery(query, errbuf, 0, &affected_rows)) {
if (affected_rows == 1) {
if(c) c->LogSQL(query);
return true;
if(c) c->LogSQL(query.c_str());
return true;
}
else {
return false;
}
}
else {
LogFile->write(EQEMuLog::Error, "Error in CreateSpawn2 query '%s': %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in CreateSpawn2 query '%s': %s", query.c_str(), errbuf);
return false;
}
@ -691,7 +695,7 @@ void SpawnConditionManager::UpdateDBEvent(SpawnEvent &event) {
event.next.minute, event.next.hour, event.next.day, event.next.month,
event.next.year, event.enabled?1:0, event.id
);
if(!database.RunQuery(query, len, errbuf)) {
if(!database.RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Unable to update spawn event '%s': %s\n", query, errbuf);
}
safe_delete_array(query);
@ -699,34 +703,37 @@ void SpawnConditionManager::UpdateDBEvent(SpawnEvent &event) {
void SpawnConditionManager::UpdateDBCondition(const char* zone_name, uint32 instance_id, uint16 cond_id, int16 value) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
int len;
SpawnCondition cond;
len = MakeAnyLenString(&query,
"REPLACE INTO spawn_condition_values (id, value, zone, instance_id) VALUES(%u, %u, '%s', %u)",
cond_id, value, zone_name, instance_id
);
if(!database.RunQuery(query, len, errbuf)) {
LogFile->write(EQEMuLog::Error, "Unable to update spawn condition '%s': %s\n", query, errbuf);
StringFormat(query, "REPLACE INTO spawn_condition_values "
"(id, value, zone, instance_id) "
"VALUES(%u, %u, '%s', %u)",
cond_id, value, zone_name, instance_id);
if(!database.RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Unable to update spawn condition '%s': %s\n", query.c_str(), errbuf);
}
safe_delete_array(query);
}
bool SpawnConditionManager::LoadDBEvent(uint32 event_id, SpawnEvent &event, std::string &zone_name) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
int len;
bool ret = false;
len = MakeAnyLenString(&query,
"SELECT id,cond_id,period,next_minute,next_hour,next_day,next_month,next_year,enabled,action,argument,zone "
"FROM spawn_events WHERE id=%d", event_id);
if (database.RunQuery(query, len, errbuf, &result)) {
safe_delete_array(query);
StringFormat(query, "SELECT id, cond_id, period, "
"next_minute, next_hour, next_day, "
"next_month, next_year, enabled, "
"action, argument,zone "
"FROM spawn_events WHERE id=%d",
event_id);
if (database.RunQuery(query,errbuf, &result)) {
if((row = mysql_fetch_row(result))) {
event.id = atoi(row[0]);
event.condition_id = atoi(row[1]);
@ -752,8 +759,7 @@ bool SpawnConditionManager::LoadDBEvent(uint32 event_id, SpawnEvent &event, std:
}
mysql_free_result(result);
} else {
LogFile->write(EQEMuLog::Error, "Error in LoadDBEvent query '%s': %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in LoadDBEvent query '%s': %s", query.c_str(), errbuf);
}
return(ret);
}
@ -761,7 +767,7 @@ bool SpawnConditionManager::LoadDBEvent(uint32 event_id, SpawnEvent &event, std:
bool SpawnConditionManager::LoadSpawnConditions(const char* zone_name, uint32 instance_id)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
int len;
@ -771,9 +777,10 @@ bool SpawnConditionManager::LoadSpawnConditions(const char* zone_name, uint32 in
//load spawn conditions
SpawnCondition cond;
len = MakeAnyLenString(&query, "SELECT id, onchange, value FROM spawn_conditions WHERE zone='%s'", zone_name);
if (database.RunQuery(query, len, errbuf, &result)) {
safe_delete_array(query);
StringFormat(query, "SELECT id, onchange, value FROM spawn_conditions WHERE zone='%s'", zone_name);
if (database.RunQuery(query, errbuf, &result)) {
while((row = mysql_fetch_row(result))) {
cond.condition_id = atoi(row[0]);
cond.value = atoi(row[2]);
@ -784,15 +791,14 @@ bool SpawnConditionManager::LoadSpawnConditions(const char* zone_name, uint32 in
}
mysql_free_result(result);
} else {
LogFile->write(EQEMuLog::Error, "Error in LoadSpawnConditions query '%s': %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in LoadSpawnConditions query '%s': %s", query.c_str(), errbuf);
return false;
}
//load values
len = MakeAnyLenString(&query, "SELECT id, value FROM spawn_condition_values WHERE zone='%s' and instance_id=%u", zone_name, instance_id);
if (database.RunQuery(query, len, errbuf, &result)) {
safe_delete_array(query);
StringFormat(query, "SELECT id, value FROM spawn_condition_values WHERE zone='%s' and instance_id=%u", zone_name, instance_id);
if (database.RunQuery(query, errbuf, &result)) {
while((row = mysql_fetch_row(result)))
{
std::map<uint16, SpawnCondition>::iterator iter = spawn_conditions.find(atoi(row[0]));
@ -805,19 +811,19 @@ bool SpawnConditionManager::LoadSpawnConditions(const char* zone_name, uint32 in
}
else
{
LogFile->write(EQEMuLog::Error, "Error in LoadSpawnConditions query '%s': %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in LoadSpawnConditions query '%s': %s", query.c_str(), errbuf);
spawn_conditions.clear();
return false;
}
//load spawn events
SpawnEvent event;
len = MakeAnyLenString(&query,
"SELECT id,cond_id,period,next_minute,next_hour,next_day,next_month,next_year,enabled,action,argument "
"FROM spawn_events WHERE zone='%s'", zone_name);
if (database.RunQuery(query, len, errbuf, &result)) {
safe_delete_array(query);
StringFormat(query, "SELECT id, cond_id, period, next_minute, "
"next_hour, next_day, next_month, next_year, enabled, action, argument "
"FROM spawn_events WHERE zone='%s'",
zone_name);
if (database.RunQuery(query,errbuf, &result)) {
while((row = mysql_fetch_row(result))) {
event.id = atoi(row[0]);
event.condition_id = atoi(row[1]);
@ -843,8 +849,7 @@ bool SpawnConditionManager::LoadSpawnConditions(const char* zone_name, uint32 in
}
mysql_free_result(result);
} else {
LogFile->write(EQEMuLog::Error, "Error in LoadSpawnConditions events query '%s': %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in LoadSpawnConditions events query '%s': %s", query.c_str(), errbuf);
return false;
}
@ -1156,7 +1161,7 @@ int16 SpawnConditionManager::GetCondition(const char *zone_short, uint32 instanc
} else {
//this is a remote spawn condition, grab it from the DB
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
int len;
@ -1165,10 +1170,11 @@ int16 SpawnConditionManager::GetCondition(const char *zone_short, uint32 instanc
//load spawn conditions
SpawnCondition cond;
len = MakeAnyLenString(&query, "SELECT value FROM spawn_condition_values WHERE zone='%s' AND instance_id=%u AND id=%d",
zone_short, instance_id, condition_id);
if (database.RunQuery(query, len, errbuf, &result)) {
safe_delete_array(query);
StringFormat(query, "SELECT value FROM spawn_condition_values "
"WHERE zone='%s' AND instance_id=%u AND id=%d",
zone_short, instance_id, condition_id);
if (database.RunQuery(query, errbuf, &result)) {
if((row = mysql_fetch_row(result))) {
value = atoi(row[0]);
} else {
@ -1178,7 +1184,6 @@ int16 SpawnConditionManager::GetCondition(const char *zone_short, uint32 instanc
mysql_free_result(result);
} else {
_log(SPAWNS__CONDITIONS, "Unable to query remote condition %d from zone %s in Get request.", condition_id, zone_short);
safe_delete_array(query);
value = 0; //dunno a better thing to do...
}
return(value);

60
zone/spawngroup.cpp
View File

@ -144,15 +144,21 @@ bool SpawnGroupList::RemoveSpawnGroup(uint32 in_id) {
bool ZoneDatabase::LoadSpawnGroups(const char* zone_name, uint16 version, SpawnGroupList* spawn_group_list) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
// CODER new spawn code
query = 0;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT DISTINCT(spawngroupID), spawngroup.name, spawngroup.spawn_limit, spawngroup.dist, spawngroup.max_x, spawngroup.min_x, spawngroup.max_y, spawngroup.min_y, spawngroup.delay, spawngroup.despawn, spawngroup.despawn_timer FROM spawn2,spawngroup WHERE spawn2.spawngroupID=spawngroup.ID and spawn2.version=%u and zone='%s'", version, zone_name), errbuf, &result))
StringFormat(query, "SELECT DISTINCT(spawngroupID), spawngroup.name, "
"spawngroup.spawn_limit, spawngroup.dist, spawngroup.max_x, "
"spawngroup.min_x, spawngroup.max_y, spawngroup.min_y, "
"spawngroup.delay, spawngroup.despawn, spawngroup.despawn_timer "
"FROM spawn2,spawngroup WHERE spawn2.spawngroupID=spawngroup.ID "
"and spawn2.version=%u and zone='%s'",
version, zone_name);
if (RunQuery(query, errbuf, &result))
{
safe_delete_array(query);
while((row = mysql_fetch_row(result))) {
SpawnGroup* newSpawnGroup = new SpawnGroup( atoi(row[0]), row[1], atoi(row[2]), atof(row[3]), atof(row[4]), atof(row[5]), atof(row[6]), atof(row[7]), atoi(row[8]), atoi(row[9]), atoi(row[10]));
spawn_group_list->AddSpawnGroup(newSpawnGroup);
@ -162,18 +168,18 @@ bool ZoneDatabase::LoadSpawnGroups(const char* zone_name, uint16 version, SpawnG
else
{
std::cerr << "Error2 in PopulateZoneLists query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return false;
}
query = 0;
if (RunQuery(query, MakeAnyLenString(&query,
"SELECT DISTINCT spawnentry.spawngroupID, npcid, chance, "
"npc_types.spawn_limit AS sl "
"FROM spawnentry, spawn2, npc_types "
"WHERE spawnentry.npcID=npc_types.id AND spawnentry.spawngroupID=spawn2.spawngroupID "
"AND zone='%s'", zone_name), errbuf, &result)) {
safe_delete_array(query);
StringFormat(query,"SELECT DISTINCT spawnentry.spawngroupID, npcid, chance, "
"npc_types.spawn_limit AS sl "
"FROM spawnentry, spawn2, npc_types "
"WHERE spawnentry.npcID=npc_types.id AND spawnentry.spawngroupID=spawn2.spawngroupID "
"AND zone='%s'",
zone_name);
if (RunQuery(query,errbuf, &result)) {
while((row = mysql_fetch_row(result)))
{
SpawnEntry* newSpawnEntry = new SpawnEntry( atoi(row[1]), atoi(row[2]), row[3]?atoi(row[3]):0);
@ -188,7 +194,6 @@ bool ZoneDatabase::LoadSpawnGroups(const char* zone_name, uint16 version, SpawnG
else
{
std::cerr << "Error3 in PopulateZoneLists query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return false;
}
@ -198,16 +203,22 @@ bool ZoneDatabase::LoadSpawnGroups(const char* zone_name, uint16 version, SpawnG
bool ZoneDatabase::LoadSpawnGroupsByID(int spawngroupid, SpawnGroupList* spawn_group_list) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
// CODER new spawn code
query = 0;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT DISTINCT spawngroup.id, spawngroup.name, spawngroup.spawn_limit, spawngroup.dist, spawngroup.max_x, spawngroup.min_x, spawngroup.max_y, spawngroup.min_y, spawngroup.delay, spawngroup.despawn, spawngroup.despawn_timer FROM spawngroup WHERE spawngroup.ID='%i'", spawngroupid), errbuf, &result))
StringFormat(query, "SELECT DISTINCT spawngroup.id, spawngroup.name, "
"spawngroup.spawn_limit, spawngroup.dist, "
"spawngroup.max_x, spawngroup.min_x, spawngroup.max_y, "
"spawngroup.min_y, spawngroup.delay, spawngroup.despawn, "
"spawngroup.despawn_timer FROM spawngroup "
"WHERE spawngroup.ID='%i'",
spawngroupid);
if (RunQuery(query, errbuf, &result))
{
safe_delete_array(query);
while((row = mysql_fetch_row(result))) {
SpawnGroup* newSpawnGroup = new SpawnGroup( atoi(row[0]), row[1], atoi(row[2]), atof(row[3]), atof(row[4]), atof(row[5]), atof(row[6]), atof(row[7]), atoi(row[8]), atoi(row[9]), atoi(row[10]));
spawn_group_list->AddSpawnGroup(newSpawnGroup);
@ -217,14 +228,16 @@ bool ZoneDatabase::LoadSpawnGroupsByID(int spawngroupid, SpawnGroupList* spawn_g
else
{
std::cerr << "Error2 in PopulateZoneLists query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return false;
}
query = 0;
if (RunQuery(query, MakeAnyLenString(&query,
"SELECT DISTINCT spawnentry.spawngroupID, spawnentry.npcid, spawnentry.chance, spawngroup.spawn_limit FROM spawnentry,spawngroup WHERE spawnentry.spawngroupID='%i' AND spawngroup.spawn_limit='0' ORDER by chance", spawngroupid), errbuf, &result)) {
safe_delete_array(query);
StringFormat(query,"SELECT DISTINCT spawnentry.spawngroupID, spawnentry.npcid, "
"spawnentry.chance, spawngroup.spawn_limit "
"FROM spawnentry,spawngroup WHERE spawnentry.spawngroupID='%i' "
"AND spawngroup.spawn_limit='0' ORDER by chance",
spawngroupid);
if (RunQuery(query, errbuf, &result)) {
while((row = mysql_fetch_row(result)))
{
SpawnEntry* newSpawnEntry = new SpawnEntry( atoi(row[1]), atoi(row[2]), row[3]?atoi(row[3]):0);
@ -239,7 +252,6 @@ bool ZoneDatabase::LoadSpawnGroupsByID(int spawngroupid, SpawnGroupList* spawn_g
else
{
std::cerr << "Error3 in PopulateZoneLists query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return false;
}

23
zone/spells.cpp
View File

@ -4606,12 +4606,15 @@ bool Client::SpellGlobalCheck(uint16 Spell_ID, uint16 Char_ID) {
int Global_Value;
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (database.RunQuery(query,MakeAnyLenString(&query, "SELECT qglobal, value FROM spell_globals WHERE spellid=%i", Spell_ID), errbuf, &result)) {
safe_delete_array(query);
StringFormat(query,"SELECT qglobal, value FROM "
"spell_globals WHERE spellid=%i",
Spell_ID);
if (database.RunQuery(query,errbuf, &result)) {
if (mysql_num_rows(result) == 1) {
row = mysql_fetch_row(result);
@ -4619,12 +4622,16 @@ bool Client::SpellGlobalCheck(uint16 Spell_ID, uint16 Char_ID) {
Spell_Global_Value = atoi(row[1]);
mysql_free_result(result);
StringFormat(query,"SELECT value FROM "
"quest_globals WHERE "
"charid=%i AND name='%s'",
Char_ID, Spell_Global_Name.c_str());
if (Spell_Global_Name.empty()) { // If the entry in the spell_globals table has nothing set for the qglobal name
return true;
}
else if (database.RunQuery(query,MakeAnyLenString(&query, "SELECT value FROM quest_globals WHERE charid=%i AND name='%s'", Char_ID, Spell_Global_Name.c_str()), errbuf, &result)) {
safe_delete_array(query);
else if (database.RunQuery(query, errbuf, &result)) {
if (mysql_num_rows(result) == 1) {
row = mysql_fetch_row(result);
@ -4645,7 +4652,6 @@ bool Client::SpellGlobalCheck(uint16 Spell_ID, uint16 Char_ID) {
}
else
LogFile->write(EQEMuLog::Error, "Char ID: %i does not have the Qglobal Name: '%s' for Spell ID %i", Char_ID, Spell_Global_Name.c_str(), Spell_ID);
safe_delete_array(query);
}
else
LogFile->write(EQEMuLog::Error, "Spell ID %i query of spell_globals with Name: '%s' Value: '%i' failed", Spell_ID, Spell_Global_Name.c_str(), Spell_Global_Value);
@ -4656,8 +4662,7 @@ bool Client::SpellGlobalCheck(uint16 Spell_ID, uint16 Char_ID) {
mysql_free_result(result);
}
else {
LogFile->write(EQEMuLog::Error, "Error while querying Spell ID %i spell_globals table query '%s': %s", Spell_ID, query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error while querying Spell ID %i spell_globals table query '%s': %s", Spell_ID, query.c_str(), errbuf);
return false; // Query failed, so prevent spell from scribing just in case
}
return false; // Default is false

214
zone/tasks.cpp
View File

@ -61,15 +61,8 @@ TaskManager::~TaskManager() {
}
bool TaskManager::LoadTaskSets() {
const char *TaskSetQuery = "SELECT `id`, `taskid` from `tasksets` WHERE `id` > 0 AND `id` < %i "
"AND `taskid` >= 0 AND `taskid` < %i ORDER BY `id`, `taskid` ASC";
const char *ERR_MYSQLERROR = "[TASKS]Error in TaskManager::LoadTaskSets: %s";
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
@ -79,7 +72,11 @@ bool TaskManager::LoadTaskSets() {
TaskSets[i].clear();
}
if(database.RunQuery(query,MakeAnyLenString(&query,TaskSetQuery,MAXTASKSETS,MAXTASKS),errbuf,&result)) {
StringFormat(query,"SELECT `id`, `taskid` from `tasksets` WHERE `id` > 0 AND `id` < %i "
"AND `taskid` >= 0 AND `taskid` < %i ORDER BY `id`, `taskid` ASC",
MAXTASKSETS, MAXTASKS);
if(database.RunQuery(query,errbuf,&result)) {
while((row = mysql_fetch_row(result))) {
int TaskSet = atoi(row[0]);
@ -89,11 +86,9 @@ bool TaskManager::LoadTaskSets() {
_log(TASKS__GLOBALLOAD, "Adding TaskID %4i to TaskSet %4i", TaskID, TaskSet);
}
mysql_free_result(result);
safe_delete_array(query);
}
else {
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "[TASKS]Error in TaskManager::LoadTaskSets: %s", errbuf);
return false;
}
@ -164,7 +159,7 @@ bool TaskManager::LoadTasks(int SingleTask) {
const char *ERR_MYSQLERROR = "[TASKS]Error in TaskManager::LoadTasks: %s";
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
int QueryLength = 0;
MYSQL_RES *result;
MYSQL_ROW row;
@ -177,13 +172,15 @@ bool TaskManager::LoadTasks(int SingleTask) {
if(!LoadTaskSets())
_log(TASKS__GLOBALLOAD,"TaskManager::LoadTasks LoadTaskSets failed");
QueryLength = MakeAnyLenString(&query,AllTaskQuery,MAXTASKS);
StringFormat(query,AllTaskQuery,MAXTASKS);
}
else
QueryLength = MakeAnyLenString(&query,SingleTaskQuery,SingleTask);
{
StringFormat(query,SingleTaskQuery,SingleTask);
}
if(database.RunQuery(query,QueryLength,errbuf,&result)) {
if(database.RunQuery(query,errbuf,&result)) {
while((row = mysql_fetch_row(result))) {
int TaskID = atoi(row[0]);
@ -221,21 +218,23 @@ bool TaskManager::LoadTasks(int SingleTask) {
}
mysql_free_result(result);
safe_delete_array(query);
}
else {
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR, errbuf);
safe_delete_array(query);
return false;
}
if(SingleTask==0)
QueryLength = MakeAnyLenString(&query,AllActivityQuery,MAXTASKS, MAXACTIVITIESPERTASK);
{
StringFormat(query, AllActivityQuery,MAXTASKS, MAXACTIVITIESPERTASK);
}
else
QueryLength = MakeAnyLenString(&query,SingleTaskActivityQuery, SingleTask, MAXACTIVITIESPERTASK);
{
StringFormat(query, SingleTaskActivityQuery, SingleTask, MAXACTIVITIESPERTASK);
}
if(database.RunQuery(query,QueryLength, errbuf, &result)) {
if(database.RunQuery(query, errbuf, &result)) {
while((row = mysql_fetch_row(result))) {
int TaskID = atoi(row[0]);
@ -319,12 +318,9 @@ bool TaskManager::LoadTasks(int SingleTask) {
}
mysql_free_result(result);
safe_delete_array(query);
}
else {
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR, errbuf);
safe_delete_array(query);
return false;
}
return true;
@ -356,7 +352,7 @@ bool TaskManager::SaveClientState(Client *c, ClientTaskState *state) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
if(state->ActiveTaskCount > 0) {
for(int Task=0; Task<MAXACTIVETASKS; Task++) {
@ -366,19 +362,16 @@ bool TaskManager::SaveClientState(Client *c, ClientTaskState *state) {
_log(TASKS__CLIENTSAVE, "TaskManager::SaveClientState for character ID %d, Updating TaskIndex %i TaskID %i",
CharacterID, Task, TaskID);
if(!database.RunQuery(query,MakeAnyLenString(&query, TaskQuery,
CharacterID,
TaskID,
Task,
state->ActiveTasks[Task].AcceptedTime), errbuf)) {
StringFormat(query, TaskQuery, CharacterID,
TaskID, Task, state->ActiveTasks[Task].AcceptedTime);
if(!database.RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR, errbuf);
}
else
state->ActiveTasks[Task].Updated = false;
safe_delete_array(query);
}
int UpdatedActivityCount = 0;
@ -415,8 +408,10 @@ bool TaskManager::SaveClientState(Client *c, ClientTaskState *state) {
if(UpdatedActivityCount > 0) {
_log(TASKS__CLIENTSAVE, "Executing query %s", UpdateActivityQuery.c_str());
if(!database.RunQuery(query,MakeAnyLenString(&query, UpdateActivityQuery.c_str()),
errbuf)) {
query = UpdateActivityQuery;
if(!database.RunQuery(query,errbuf)) {
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR, errbuf);
}
@ -427,7 +422,6 @@ bool TaskManager::SaveClientState(Client *c, ClientTaskState *state) {
}
safe_delete_array(query);
}
}
@ -445,15 +439,16 @@ bool TaskManager::SaveClientState(Client *c, ClientTaskState *state) {
// This indicates this task was completed at the given time. We infer that all
// none optional activities were completed.
//
if(!database.RunQuery(query,MakeAnyLenString(&query, CompletedTaskQuery,
CharacterID,
state->CompletedTasks[i].CompletedTime,
TaskID, -1), errbuf)) {
StringFormat(query,CompletedTaskQuery, CharacterID,
state->CompletedTasks[i].CompletedTime,
TaskID, -1);
if(!database.RunQuery(query,errbuf)) {
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR, errbuf);
continue;
}
safe_delete_array(query);
// If the Rule to record non-optional task completion is not enabled, don't save it
if(!RuleB(TaskSystem, RecordCompletedOptionalActivities)) continue;
@ -462,15 +457,15 @@ bool TaskManager::SaveClientState(Client *c, ClientTaskState *state) {
for(int j=0; j<Tasks[TaskID]->ActivityCount; j++) {
if(Tasks[TaskID]->Activity[j].Optional && state->CompletedTasks[i].ActivityDone[j]) {
if(!database.RunQuery(query,MakeAnyLenString(&query, CompletedTaskQuery,
CharacterID,
state->CompletedTasks[i].CompletedTime,
TaskID, j), errbuf)) {
StringFormat(query,CompletedTaskQuery,
CharacterID, state->CompletedTasks[i].CompletedTime,
TaskID, j);
if(!database.RunQuery(query,errbuf)) {
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR, errbuf);
}
safe_delete_array(query);
}
}
}
@ -521,7 +516,7 @@ bool TaskManager::LoadClientState(Client *c, ClientTaskState *state) {
const char *ERR_MYSQLERROR1 = "[TASKS]Error in TaskManager::LoadClientState load Tasks: %s";
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
@ -533,7 +528,9 @@ bool TaskManager::LoadClientState(Client *c, ClientTaskState *state) {
_log(TASKS__CLIENTLOAD, "TaskManager::LoadClientSate for character ID %d", CharacterID);
if(database.RunQuery(query,MakeAnyLenString(&query, TaskQuery, CharacterID), errbuf, &result)) {
StringFormat(query, TaskQuery, CharacterID);
if(database.RunQuery(query, errbuf, &result)) {
while((row = mysql_fetch_row(result))) {
@ -580,11 +577,9 @@ bool TaskManager::LoadClientState(Client *c, ClientTaskState *state) {
CharacterID, TaskID,acceptedtime);
}
mysql_free_result(result);
safe_delete_array(query);
}
else {
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR1, errbuf);
safe_delete_array(query);
safe_delete(state);
return false;
}
@ -593,7 +588,7 @@ bool TaskManager::LoadClientState(Client *c, ClientTaskState *state) {
const char *ActivityQuery = "SELECT `taskid`, `activityid`, `donecount`, `completed` "
" from `character_activities` WHERE `charid` = %i "
"ORDER BY `taskid` ASC, `activityid` ASC";
"ORDER BY `taskid` ASC, `activityid` ASC";
const char *ERR_TASK_OOR2 = "[TASKS]Task ID %i out of range while loading character activities from database";
@ -605,11 +600,9 @@ bool TaskManager::LoadClientState(Client *c, ClientTaskState *state) {
_log(TASKS__CLIENTLOAD, "LoadClientState. Loading activities for character ID %d", CharacterID);
StringFormat(query, ActivityQuery, CharacterID);
if(database.RunQuery(query,MakeAnyLenString(&query, ActivityQuery,
CharacterID), errbuf, &result)) {
if(database.RunQuery(query, errbuf, &result)) {
while((row = mysql_fetch_row(result))) {
int TaskID = atoi(row[0]);
@ -654,11 +647,9 @@ bool TaskManager::LoadClientState(Client *c, ClientTaskState *state) {
}
mysql_free_result(result);
safe_delete_array(query);
}
else {
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR2, errbuf);
safe_delete_array(query);
safe_delete(state);
return false;
}
@ -675,8 +666,10 @@ bool TaskManager::LoadClientState(Client *c, ClientTaskState *state) {
if(RuleB(TaskSystem, RecordCompletedTasks)) {
if(database.RunQuery(query,MakeAnyLenString(&query, CompletedTaskQuery,
CharacterID), errbuf, &result)) {
StringFormat(query, CompletedTaskQuery, CharacterID);
if(database.RunQuery(query, errbuf, &result)) {
CompletedTaskInformation cti;
@ -733,11 +726,9 @@ bool TaskManager::LoadClientState(Client *c, ClientTaskState *state) {
state->LastCompletedTaskLoaded = state->CompletedTasks.size();
mysql_free_result(result);
safe_delete_array(query);
}
else {
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR3, errbuf);
safe_delete_array(query);
safe_delete(state);
return false;
}
@ -748,8 +739,9 @@ bool TaskManager::LoadClientState(Client *c, ClientTaskState *state) {
const char *ERR_MYSQLERROR4 = "[TASKS]Error in TaskManager::LoadClientState load enabled tasks: %s";
if(database.RunQuery(query,MakeAnyLenString(&query, EnabledTaskQuery,
CharacterID, MAXTASKS), errbuf, &result)) {
StringFormat(query, EnabledTaskQuery, CharacterID, MAXTASKS);
if(database.RunQuery(query, errbuf, &result)) {
while((row = mysql_fetch_row(result))) {
int TaskID = atoi(row[0]);
@ -757,11 +749,9 @@ bool TaskManager::LoadClientState(Client *c, ClientTaskState *state) {
_log(TASKS__CLIENTLOAD, "Adding TaskID %i to enabled tasks", TaskID);
}
mysql_free_result(result);
safe_delete_array(query);
}
else {
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR4, errbuf);
safe_delete_array(query);
}
// Check that there is an entry in the client task state for every activity in each task
@ -849,7 +839,7 @@ void ClientTaskState::EnableTask(int CharID, int TaskCount, int *TaskList) {
const char *ERR_MYSQLERROR = "[TASKS]Error in ClientTaskState::EnableTask %s %s";
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
char *buf = 0;
@ -864,13 +854,12 @@ void ClientTaskState::EnableTask(int CharID, int TaskCount, int *TaskList) {
}
_log(TASKS__UPDATE, "Executing query %s", TaskQuery.c_str());
query = TaskQuery;
if(!database.RunQuery(query, errbuf)) {
if(!database.RunQuery(query,MakeAnyLenString(&query, TaskQuery.c_str()), errbuf)) {
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR, query, errbuf);
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR, query.c_str(), errbuf);
}
safe_delete_array(query);
}
void ClientTaskState::DisableTask(int CharID, int TaskCount, int *TaskList) {
@ -909,7 +898,7 @@ void ClientTaskState::DisableTask(int CharID, int TaskCount, int *TaskList) {
const char *ERR_MYSQLERROR = "[TASKS]Error in ClientTaskState::DisableTask %s %s";
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
char *buf = 0;
@ -929,13 +918,14 @@ void ClientTaskState::DisableTask(int CharID, int TaskCount, int *TaskList) {
TaskQuery = TaskQuery + ")";
_log(TASKS__UPDATE, "Executing query %s", TaskQuery.c_str());
query = TaskQuery;
if(!database.RunQuery(query, errbuf)) {
if(!database.RunQuery(query,MakeAnyLenString(&query, TaskQuery.c_str()), errbuf)) {
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR, query, errbuf);
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR, query.c_str(), errbuf);
}
safe_delete_array(query);
}
bool ClientTaskState::IsTaskEnabled(int TaskID) {
@ -1437,21 +1427,21 @@ int ClientTaskState::GetActiveTaskID(int index) {
static void DeleteCompletedTaskFromDatabase(int CharID, int TaskID) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
const char *TaskQuery="DELETE FROM completed_tasks WHERE charid=%i AND taskid = %i";
_log(TASKS__UPDATE, "DeleteCompletedTasksFromDatabase. CharID = %i, TaskID = %i",
CharID, TaskID);
StringFormat(query, TaskQuery, CharID, TaskID);
if(!database.RunQuery(query, errbuf)) {
if(!database.RunQuery(query,MakeAnyLenString(&query, TaskQuery, CharID, TaskID), errbuf)) {
LogFile->write(EQEMuLog::Error, "[TASKS]Error in CientTaskState::CancelTask %s, %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "[TASKS]Error in CientTaskState::CancelTask %s, %s", query.c_str(), errbuf);
return;
}
_log(TASKS__UPDATE, "Delete query %s", query);
safe_delete_array(query);
_log(TASKS__UPDATE, "Delete query %s", query.c_str());
}
bool ClientTaskState::UnlockActivities(int CharID, int TaskIndex) {
@ -3141,33 +3131,31 @@ void ClientTaskState::RemoveTask(Client *c, int SequenceNumber) {
int CharacterID = c->CharacterID();
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
const char *TaskQuery="DELETE FROM character_tasks WHERE charid=%i AND taskid = %i";
const char *ActivityQuery="DELETE FROM character_activities WHERE charid=%i AND taskid = %i";
_log(TASKS__UPDATE, "ClientTaskState Cancel Task %i ", SequenceNumber);
if(!database.RunQuery(query,MakeAnyLenString(&query, ActivityQuery,
CharacterID,
ActiveTasks[SequenceNumber].TaskID), errbuf)) {
StringFormat(query,ActivityQuery, CharacterID, ActiveTasks[SequenceNumber].TaskID);
if(!database.RunQuery(query,errbuf)) {
LogFile->write(EQEMuLog::Error, "[TASKS]Error in CientTaskState::CancelTask %s", errbuf);
safe_delete_array(query);
return;
}
_log(TASKS__UPDATE, "CancelTask: %s", query);
safe_delete_array(query);
if(!database.RunQuery(query,MakeAnyLenString(&query, TaskQuery,
CharacterID,
ActiveTasks[SequenceNumber].TaskID), errbuf)) {
_log(TASKS__UPDATE, "CancelTask: %s", query.c_str());
StringFormat(query,TaskQuery, CharacterID, ActiveTasks[SequenceNumber].TaskID);
if(!database.RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "[TASKS]Error in CientTaskState::CancelTask %s", errbuf);
}
_log(TASKS__UPDATE, "CancelTask: %s", query);
safe_delete_array(query);
_log(TASKS__UPDATE, "CancelTask: %s", query.c_str());
ActiveTasks[SequenceNumber].TaskID = TASKSLOTEMPTY;
ActiveTaskCount--;
@ -3305,7 +3293,7 @@ bool TaskGoalListManager::LoadLists() {
const char *ERR_MYSQLERROR = "Error in TaskGoalListManager::LoadLists: %s %s";
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
@ -3319,8 +3307,10 @@ bool TaskGoalListManager::LoadLists() {
safe_delete_array(TaskGoalLists);
NumberOfLists = 0;
if(database.RunQuery(query,MakeAnyLenString(&query,CountQuery),errbuf,&result)) {
query = CountQuery;
if(database.RunQuery(query,errbuf,&result)) {
NumberOfLists = mysql_num_rows(result);
_log(TASKS__GLOBALLOAD, "Database returned a count of %i lists", NumberOfLists);
@ -3342,11 +3332,9 @@ bool TaskGoalListManager::LoadLists() {
ListIndex++;
}
mysql_free_result(result);
safe_delete_array(query);
}
else {
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR, query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR, query.c_str(), errbuf);
return false;
}
@ -3355,7 +3343,9 @@ bool TaskGoalListManager::LoadLists() {
int ListID = TaskGoalLists[ListIndex].ListID;
unsigned int Size = TaskGoalLists[ListIndex].Size;
if(database.RunQuery(query,MakeAnyLenString(&query,ListQuery,ListID,Size),errbuf,&result)) {
StringFormat(query,ListQuery,ListID,Size);
if(database.RunQuery(query,errbuf,&result)) {
// This should only happen if a row is deleted in between us retrieving the counts
// at the start of this method and getting to here. It should not be possible for
// an INSERT to cause a problem, as the SELECT is used with a LIMIT
@ -3379,12 +3369,10 @@ bool TaskGoalListManager::LoadLists() {
}
mysql_free_result(result);
safe_delete_array(query);
}
else {
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR, query, errbuf);
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR, query.c_str(), errbuf);
TaskGoalLists[ListIndex].Size = 0;
safe_delete_array(query);
}
}
return true;
@ -3493,7 +3481,7 @@ bool TaskProximityManager::LoadProximities(int ZoneID) {
const char *ERR_MYSQLERROR = "Error in TaskProximityManager::LoadProximities %s %s";
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
@ -3502,8 +3490,10 @@ bool TaskProximityManager::LoadProximities(int ZoneID) {
_log(TASKS__GLOBALLOAD, "TaskProximityManager::LoadProximities Called for zone %i", ZoneID);
TaskProximities.clear();
if(database.RunQuery(query,MakeAnyLenString(&query,ProximityQuery, ZoneID),errbuf,&result)) {
StringFormat(query,ProximityQuery, ZoneID);
if(database.RunQuery(query, errbuf,&result)) {
while((row = mysql_fetch_row(result))) {
Proximity.ExploreID = atoi(row[0]);
@ -3520,11 +3510,9 @@ bool TaskProximityManager::LoadProximities(int ZoneID) {
mysql_free_result(result);
}
else {
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR, query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, ERR_MYSQLERROR, query.c_str(), errbuf);
return false;
}
safe_delete_array(query);
return true;

111
zone/titles.cpp
View File

@ -34,20 +34,21 @@ bool TitleManager::LoadTitles()
TitleEntry Title;
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = nullptr;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
if (!database.RunQuery(query, MakeAnyLenString(&query,
"SELECT `id`, `skill_id`, `min_skill_value`, `max_skill_value`, `min_aa_points`, `max_aa_points`, `class`, `gender`, "
"`char_id`, `status`, `item_id`, `prefix`, `suffix`, `title_set` from titles"), errbuf, &result))
query = "SELECT `id`, `skill_id`, `min_skill_value`, `max_skill_value`, "
"`min_aa_points`, `max_aa_points`, `class`, `gender`, "
"`char_id`, `status`, `item_id`, `prefix`, `suffix`, "
"`title_set` from titles";
if (!database.RunQuery(query, errbuf, &result))
{
LogFile->write(EQEMuLog::Error, "Unable to load titles: %s : %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Unable to load titles: %s : %s", query.c_str(), errbuf);
return(false);
}
safe_delete_array(query);
while ((row = mysql_fetch_row(result))) {
Title.TitleID = atoi(row[0]);
@ -250,42 +251,38 @@ void TitleManager::CreateNewPlayerTitle(Client *c, const char *Title)
return;
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = nullptr;
std::string query;
MYSQL_RES *result;
char *EscTitle = new char[strlen(Title) * 2 + 1];
std::string escTitle;
c->SetAATitle(Title);
database.DoEscapeString(EscTitle, Title, strlen(Title));
if (database.RunQuery(query, MakeAnyLenString(&query,
"SELECT `id` from titles where `prefix` = '%s' and char_id = %i", EscTitle, c->CharacterID()), errbuf, &result))
database.DoEscapeString(escTitle, Title, strlen(Title));
StringFormat(query,"SELECT `id` from titles where `prefix` = '%s' and char_id = %i", escTitle.c_str(), c->CharacterID());
if (database.RunQuery(query, errbuf, &result))
{
if(mysql_num_rows(result) > 0)
{
mysql_free_result(result);
safe_delete_array(query);
safe_delete_array(EscTitle);
return;
}
mysql_free_result(result);
}
safe_delete_array(query);
if(!database.RunQuery(query,MakeAnyLenString(&query, "INSERT into titles (`char_id`, `prefix`) VALUES(%i, '%s')",
c->CharacterID(), EscTitle), errbuf))
LogFile->write(EQEMuLog::Error, "Error adding title: %s %s", query, errbuf);
StringFormat(query, "INSERT into titles (`char_id`, `prefix`) VALUES(%i, '%s')",
c->CharacterID(), escTitle.c_str());
if(!database.RunQuery(query,errbuf))
LogFile->write(EQEMuLog::Error, "Error adding title: %s %s", query.c_str(), errbuf);
else
{
ServerPacket* pack = new ServerPacket(ServerOP_ReloadTitles, 0);
worldserver.SendPacket(pack);
safe_delete(pack);
}
safe_delete_array(query);
safe_delete_array(EscTitle);
}
void TitleManager::CreateNewPlayerSuffix(Client *c, const char *Suffix)
@ -294,41 +291,39 @@ void TitleManager::CreateNewPlayerSuffix(Client *c, const char *Suffix)
return;
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = nullptr;
std::string query;
MYSQL_RES *result;
char *EscSuffix = new char[strlen(Suffix) * 2 + 1];
std::string escSuffix;
c->SetTitleSuffix(Suffix);
database.DoEscapeString(EscSuffix, Suffix, strlen(Suffix));
database.DoEscapeString(escSuffix, Suffix, strlen(Suffix));
if (database.RunQuery(query, MakeAnyLenString(&query,
"SELECT `id` from titles where `suffix` = '%s' and char_id = %i", EscSuffix, c->CharacterID()), errbuf, &result))
StringFormat(query, "SELECT `id` from titles where `suffix` = '%s' and char_id = %i",
escSuffix.c_str(), c->CharacterID());
if (database.RunQuery(query, errbuf, &result))
{
if(mysql_num_rows(result) > 0)
{
mysql_free_result(result);
safe_delete_array(query);
safe_delete_array(EscSuffix);
return;
}
mysql_free_result(result);
}
safe_delete_array(query);
StringFormat(query, "INSERT into titles (`char_id`, `suffix`) VALUES(%i, '%s')",
c->CharacterID(), escSuffix.c_str());
if(!database.RunQuery(query,MakeAnyLenString(&query, "INSERT into titles (`char_id`, `suffix`) VALUES(%i, '%s')",
c->CharacterID(), EscSuffix), errbuf))
LogFile->write(EQEMuLog::Error, "Error adding title suffix: %s %s", query, errbuf);
if(!database.RunQuery(query, errbuf))
LogFile->write(EQEMuLog::Error, "Error adding title suffix: %s %s", query.c_str(), errbuf);
else
{
ServerPacket* pack = new ServerPacket(ServerOP_ReloadTitles, 0);
worldserver.SendPacket(pack);
safe_delete(pack);
}
safe_delete_array(query);
safe_delete_array(EscSuffix);
}
@ -375,27 +370,31 @@ void Client::EnableTitle(int titleset) {
}
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
if(!database.RunQuery(query,MakeAnyLenString(&query, "INSERT INTO player_titlesets (char_id, title_set) VALUES (%i, %i)", CharacterID(), titleset), errbuf)) {
StringFormat(query, "INSERT INTO player_titlesets "
"(char_id, title_set) VALUES (%i, %i)",
CharacterID(), titleset);
if(!database.RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error in EnableTitle query for titleset %i and charid %i", titleset, CharacterID());
safe_delete_array(query);
return;
}
else {
safe_delete_array(query);
return;
}
return;
}
bool Client::CheckTitle(int titleset) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
if (database.RunQuery(query, MakeAnyLenString(&query, "SELECT `id` FROM player_titlesets WHERE `title_set`=%i AND `char_id`=%i LIMIT 1", titleset, CharacterID()), errbuf, &result)) {
safe_delete_array(query);
StringFormat(query, "SELECT `id` FROM player_titlesets "
"WHERE `title_set`=%i AND "
"`char_id`=%i LIMIT 1",
titleset, CharacterID());
if (database.RunQuery(query, errbuf, &result)) {
if (mysql_num_rows(result) >= 1) {
mysql_free_result(result);
return(true);
@ -404,11 +403,10 @@ bool Client::CheckTitle(int titleset) {
}
else {
LogFile->write(EQEMuLog::Error, "Error in CheckTitle query '%s': %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in CheckTitle query '%s': %s", query.c_str(), errbuf);
}
return(false);
return false;
}
void Client::RemoveTitle(int titleset) {
@ -418,15 +416,14 @@ void Client::RemoveTitle(int titleset) {
}
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
if (database.RunQuery(query, MakeAnyLenString(&query, "DELETE FROM player_titlesets WHERE `title_set`=%i AND `char_id`=%i", titleset, CharacterID()), errbuf)) {
safe_delete_array(query);
}
StringFormat(query, "DELETE FROM player_titlesets WHERE "
"`title_set`=%i AND `char_id`=%i",
titleset, CharacterID());
else {
LogFile->write(EQEMuLog::Error, "Error in RemoveTitle query '%s': %s", query, errbuf);
safe_delete_array(query);
if (!database.RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error in RemoveTitle query '%s': %s", query.c_str(), errbuf);
}
return;

223
zone/tradeskills.cpp
View File

@ -393,24 +393,23 @@ void Object::HandleAutoCombine(Client* user, const RecipeAutoCombine_Struct* rac
char errbuf[MYSQL_ERRMSG_SIZE];
MYSQL_RES *result;
MYSQL_ROW row;
char *query = 0;
std::string query;
uint32 qlen = 0;
uint8 qcount = 0;
//pull the list of components
qlen = MakeAnyLenString(&query, "SELECT tre.item_id,tre.componentcount "
" FROM tradeskill_recipe_entries AS tre "
" WHERE tre.componentcount > 0 AND tre.recipe_id=%u", rac->recipe_id);
StringFormat(query, "SELECT tre.item_id,tre.componentcount "
"FROM tradeskill_recipe_entries AS tre "
"WHERE tre.componentcount > 0 AND "
"tre.recipe_id=%u", rac->recipe_id);
if (!database.RunQuery(query, qlen, errbuf, &result)) {
LogFile->write(EQEMuLog::Error, "Error in HandleAutoCombine query '%s': %s", query, errbuf);
safe_delete_array(query);
if (!database.RunQuery(query, errbuf, &result)) {
LogFile->write(EQEMuLog::Error, "Error in HandleAutoCombine query '%s': %s", query.c_str(), errbuf);
user->QueuePacket(outapp);
safe_delete(outapp);
return;
}
safe_delete_array(query);
qcount = mysql_num_rows(result);
if(qcount < 1) {
@ -608,14 +607,13 @@ SkillType Object::TypeToSkill(uint32 type) {
return(tradeskill);
}
void Client::TradeskillSearchResults(const char *query, unsigned long qlen, unsigned long objtype, unsigned long someid) {
void Client::TradeskillSearchResults(const std::string query, unsigned long qlen, unsigned long objtype, unsigned long someid) {
char errbuf[MYSQL_ERRMSG_SIZE];
MYSQL_RES *result;
MYSQL_ROW row;
if (!database.RunQuery(query, qlen, errbuf, &result)) {
LogFile->write(EQEMuLog::Error, "Error in TradeskillSearchResults query '%s': %s", query, errbuf);
if (!database.RunQuery(query, errbuf, &result)) {
LogFile->write(EQEMuLog::Error, "Error in TradeskillSearchResults query '%s': %s", query.c_str(), errbuf);
return;
}
@ -627,7 +625,7 @@ void Client::TradeskillSearchResults(const char *query, unsigned long qlen, unsi
return;
}
if(mysql_num_fields(result) != 6) {
LogFile->write(EQEMuLog::Error, "Error in TradeskillSearchResults query '%s': Invalid column count in result", query);
LogFile->write(EQEMuLog::Error, "Error in TradeskillSearchResults query '%s': Invalid column count in result", query.c_str());
return;
}
@ -673,23 +671,21 @@ void Client::SendTradeskillDetails(uint32 recipe_id) {
char errbuf[MYSQL_ERRMSG_SIZE];
MYSQL_RES *result;
MYSQL_ROW row;
char *query = 0;
std::string query;
uint32 qlen = 0;
uint8 qcount = 0;
//pull the list of components
qlen = MakeAnyLenString(&query, "SELECT tre.item_id,tre.componentcount,i.icon,i.Name "
" FROM tradeskill_recipe_entries AS tre "
" LEFT JOIN items AS i ON tre.item_id = i.id "
" WHERE tre.componentcount > 0 AND tre.recipe_id=%u", recipe_id);
StringFormat(query, "SELECT tre.item_id,tre.componentcount,i.icon,i.Name "
"FROM tradeskill_recipe_entries AS tre "
"LEFT JOIN items AS i ON tre.item_id = i.id "
"WHERE tre.componentcount > 0 AND tre.recipe_id=%u", recipe_id);
if (!database.RunQuery(query, qlen, errbuf, &result)) {
LogFile->write(EQEMuLog::Error, "Error in SendTradeskillDetails query '%s': %s", query, errbuf);
safe_delete_array(query);
if (!database.RunQuery(query, errbuf, &result)) {
LogFile->write(EQEMuLog::Error, "Error in SendTradeskillDetails query '%s': %s", query.c_str(), errbuf);
return;
}
safe_delete_array(query);
qcount = mysql_num_rows(result);
if(qcount < 1) {
@ -1131,7 +1127,7 @@ bool ZoneDatabase::GetTradeRecipe(const ItemInst* container, uint8 c_type, uint3
char errbuf[MYSQL_ERRMSG_SIZE];
MYSQL_RES *result;
MYSQL_ROW row;
char *query = 0;
std::string query;
char buf2[4096];
uint32 sum = 0;
@ -1178,20 +1174,19 @@ bool ZoneDatabase::GetTradeRecipe(const ItemInst* container, uint8 c_type, uint3
return(false); //no items == no recipe
}
qlen = MakeAnyLenString(&query, "SELECT tre.recipe_id "
" FROM tradeskill_recipe_entries AS tre"
" WHERE ( tre.item_id IN(%s) AND tre.componentcount>0 )"
" OR ( tre.item_id %s AND tre.iscontainer=1 )"
" GROUP BY tre.recipe_id HAVING sum(tre.componentcount) = %u"
" AND sum(tre.item_id * tre.componentcount) = %u", buf2, containers, count, sum);
StringFormat(query, "SELECT tre.recipe_id "
"FROM tradeskill_recipe_entries AS tre "
"WHERE ( tre.item_id IN(%s) AND tre.componentcount>0 ) "
"OR ( tre.item_id %s AND tre.iscontainer=1 ) "
"GROUP BY tre.recipe_id HAVING sum(tre.componentcount) = %u "
"AND sum(tre.item_id * tre.componentcount) = %u",
buf2, containers, count, sum);
if (!RunQuery(query, qlen, errbuf, &result)) {
LogFile->write(EQEMuLog::Error, "Error in GetTradeRecipe search, query: %s", query);
safe_delete_array(query);
if (!RunQuery(query, errbuf, &result)) {
LogFile->write(EQEMuLog::Error, "Error in GetTradeRecipe search, query: %s", query.c_str());
LogFile->write(EQEMuLog::Error, "Error in GetTradeRecipe search, error: %s", errbuf);
return(false);
return false;
}
safe_delete_array(query);
qcount = mysql_num_rows(result);
if(qcount > 1) {
@ -1217,19 +1212,18 @@ bool ZoneDatabase::GetTradeRecipe(const ItemInst* container, uint8 c_type, uint3
}
}
qlen = MakeAnyLenString(&query, "SELECT tre.recipe_id"
" FROM tradeskill_recipe_entries AS tre"
" WHERE tre.recipe_id IN (%s)"
" GROUP BY tre.recipe_id HAVING sum(tre.componentcount) = %u"
" AND sum(tre.item_id * tre.componentcount) = %u", buf2, count, sum);
StringFormat(query, "SELECT tre.recipe_id "
"FROM tradeskill_recipe_entries AS tre "
"WHERE tre.recipe_id IN (%s) "
"GROUP BY tre.recipe_id HAVING sum(tre.componentcount) = %u "
"AND sum(tre.item_id * tre.componentcount) = %u",
buf2, count, sum);
if (!RunQuery(query, qlen, errbuf, &result)) {
LogFile->write(EQEMuLog::Error, "Error in GetTradeRecipe, re-query: %s", query);
safe_delete_array(query);
if (!RunQuery(query, errbuf, &result)) {
LogFile->write(EQEMuLog::Error, "Error in GetTradeRecipe, re-query: %s", query.c_str());
LogFile->write(EQEMuLog::Error, "Error in GetTradeRecipe, error: %s", errbuf);
return(false);
return false;
}
safe_delete_array(query);
qcount = mysql_num_rows(result);
}
@ -1253,22 +1247,22 @@ bool ZoneDatabase::GetTradeRecipe(const ItemInst* container, uint8 c_type, uint3
return(false);
}
qlen = MakeAnyLenString(&query,"SELECT tre.recipe_id FROM tradeskill_recipe_entries as tre WHERE tre.recipe_id IN (%s)"
" AND tre.item_id = %u;",buf2,containerId);
StringFormat(query,"SELECT tre.recipe_id FROM "
"tradeskill_recipe_entries as tre WHERE tre.recipe_id IN (%s) "
"AND tre.item_id = %u;",
buf2, containerId);
if (!RunQuery(query, qlen, errbuf, &result)) {
LogFile->write(EQEMuLog::Error, "Error in GetTradeRecipe, re-query: %s", query);
safe_delete_array(query);
if (!RunQuery(query, errbuf, &result)) {
LogFile->write(EQEMuLog::Error, "Error in GetTradeRecipe, re-query: %s", query.c_str());
LogFile->write(EQEMuLog::Error, "Error in GetTradeRecipe, error: %s", errbuf);
return(false);
return false;
}
safe_delete_array(query);
uint32 resultRowTotal = mysql_num_rows(result);
if(resultRowTotal == 0) { //Recipe contents matched more than 1 recipe, but not in this container
LogFile->write(EQEMuLog::Error, "Combine error: Incorrect container is being used!");
return(false);
return false;
}
if(resultRowTotal > 1) { //Recipe contents matched more than 1 recipe in this container
LogFile->write(EQEMuLog::Error, "Combine error: Recipe is not unique! %u matches found for container %u. Continuing with first recipe match.", resultRowTotal, containerId);
@ -1284,10 +1278,15 @@ bool ZoneDatabase::GetTradeRecipe(const ItemInst* container, uint8 c_type, uint3
//This is here because something's up with the query above.. it needs to be rethought out
bool has_components = true;
char TSerrbuf[MYSQL_ERRMSG_SIZE];
char *TSquery = 0;
MYSQL_RES *TSresult;
MYSQL_ROW TSrow;
if (RunQuery(TSquery, MakeAnyLenString(&TSquery, "SELECT item_id, componentcount from tradeskill_recipe_entries where recipe_id=%i AND componentcount > 0", recipe_id), TSerrbuf, &TSresult)) {
StringFormat(query, "SELECT item_id, componentcount from "
"tradeskill_recipe_entries where "
"recipe_id=%i AND componentcount > 0",
recipe_id);
if (RunQuery(query, TSerrbuf, &TSresult)) {
while((TSrow = mysql_fetch_row(TSresult))!=nullptr) {
int ccnt = 0;
for(int x = 0; x < 10; x++){
@ -1306,15 +1305,14 @@ bool ZoneDatabase::GetTradeRecipe(const ItemInst* container, uint8 c_type, uint3
}
mysql_free_result(TSresult);
} else {
LogFile->write(EQEMuLog::Error, "Error in tradeskill verify query: '%s': %s", TSquery, TSerrbuf);
LogFile->write(EQEMuLog::Error, "Error in tradeskill verify query: '%s': %s", query.c_str(), TSerrbuf);
}
safe_delete_array(TSquery);
if(has_components == false){
return false;
}
return(GetTradeRecipe(recipe_id, c_type, some_id, char_id, spec));
return GetTradeRecipe(recipe_id, c_type, some_id, char_id, spec);
}
bool ZoneDatabase::GetTradeRecipe(uint32 recipe_id, uint8 c_type, uint32 some_id,
@ -1323,7 +1321,7 @@ bool ZoneDatabase::GetTradeRecipe(uint32 recipe_id, uint8 c_type, uint32 some_id
char errbuf[MYSQL_ERRMSG_SIZE];
MYSQL_RES *result;
MYSQL_ROW row;
char *query = 0;
std::string query;
uint32 qcount = 0;
uint32 qlen;
@ -1338,22 +1336,24 @@ bool ZoneDatabase::GetTradeRecipe(uint32 recipe_id, uint8 c_type, uint32 some_id
snprintf(containers,29, "in (%u,%u)", c_type, some_id);
}
qlen = MakeAnyLenString(&query, "SELECT tr.id, tr.tradeskill, tr.skillneeded,"
" tr.trivial, tr.nofail, tr.replace_container, tr.name, tr.must_learn, tr.quest, crl.madecount"
" FROM tradeskill_recipe AS tr inner join tradeskill_recipe_entries as tre"
" ON tr.id = tre.recipe_id"
" LEFT JOIN (SELECT recipe_id, madecount from char_recipe_list WHERE char_id = %u) AS crl "
" ON tr.id = crl.recipe_id "
" WHERE tr.id = %lu AND tre.item_id %s"
" GROUP BY tr.id", char_id, (unsigned long)recipe_id, containers);
StringFormat(query, "SELECT tr.id, tr.tradeskill, tr.skillneeded, "
"tr.trivial, tr.nofail, tr.replace_container, "
"tr.name, tr.must_learn, tr.quest, crl.madecount "
"FROM tradeskill_recipe AS tr "
"inner join "
"tradeskill_recipe_entries as tre "
"ON tr.id = tre.recipe_id "
"LEFT JOIN (SELECT recipe_id, madecount from char_recipe_list WHERE char_id = %u) AS crl "
"ON tr.id = crl.recipe_id "
"WHERE tr.id = %lu AND tre.item_id %s "
"GROUP BY tr.id",
char_id, (unsigned long)recipe_id, containers);
if (!RunQuery(query, qlen, errbuf, &result)) {
LogFile->write(EQEMuLog::Error, "Error in GetTradeRecipe, query: %s", query);
safe_delete_array(query);
if (!RunQuery(query, errbuf, &result)) {
LogFile->write(EQEMuLog::Error, "Error in GetTradeRecipe, query: %s", query.c_str());
LogFile->write(EQEMuLog::Error, "Error in GetTradeRecipe, error: %s", errbuf);
return(false);
return false;
}
safe_delete_array(query);
qcount = mysql_num_rows(result);
if(qcount != 1) {
@ -1381,15 +1381,14 @@ bool ZoneDatabase::GetTradeRecipe(uint32 recipe_id, uint8 c_type, uint32 some_id
mysql_free_result(result);
//Pull the on-success items...
qlen = MakeAnyLenString(&query, "SELECT item_id,successcount FROM tradeskill_recipe_entries"
" WHERE successcount>0 AND recipe_id=%u", recipe_id);
StringFormat(query, "SELECT item_id,successcount FROM tradeskill_recipe_entries "
"WHERE successcount>0 AND recipe_id=%u",
recipe_id);
if (!RunQuery(query, qlen, errbuf, &result)) {
LogFile->write(EQEMuLog::Error, "Error in GetTradeRecept success query '%s': %s", query, errbuf);
safe_delete_array(query);
return(false);
if (!RunQuery(query, errbuf, &result)) {
LogFile->write(EQEMuLog::Error, "Error in GetTradeRecept success query '%s': %s", query.c_str(), errbuf);
return false;
}
safe_delete_array(query);
qcount = mysql_num_rows(result);
if(qcount < 1) {
@ -1407,11 +1406,12 @@ bool ZoneDatabase::GetTradeRecipe(uint32 recipe_id, uint8 c_type, uint32 some_id
mysql_free_result(result);
//Pull the on-fail items...
qlen = MakeAnyLenString(&query, "SELECT item_id,failcount FROM tradeskill_recipe_entries"
" WHERE failcount>0 AND recipe_id=%u", recipe_id);
StringFormat(query, "SELECT item_id,failcount FROM tradeskill_recipe_entries "
"WHERE failcount>0 AND recipe_id=%u",
recipe_id);
spec->onfail.clear();
if (RunQuery(query, qlen, errbuf, &result)) {
if (RunQuery(query, errbuf, &result)) {
qcount = mysql_num_rows(result);
uint8 r;
@ -1425,11 +1425,14 @@ bool ZoneDatabase::GetTradeRecipe(uint32 recipe_id, uint8 c_type, uint32 some_id
}
// Pull the salvage list
qlen = MakeAnyLenString(&query, "SELECT item_id,salvagecount FROM tradeskill_recipe_entries WHERE salvagecount>0 AND recipe_id=%u", recipe_id);
StringFormat(query, "SELECT item_id,salvagecount FROM "
"tradeskill_recipe_entries WHERE "
"salvagecount>0 AND recipe_id=%u",
recipe_id);
spec->salvage.clear();
// Don't bother with the query if TS is nofail
if (!spec->nofail && RunQuery(query, qlen, errbuf, &result)) {
if (!spec->nofail && RunQuery(query, errbuf, &result)) {
qcount = mysql_num_rows(result);
uint8 r;
for(r = 0; r < qcount; r++) {
@ -1441,46 +1444,45 @@ bool ZoneDatabase::GetTradeRecipe(uint32 recipe_id, uint8 c_type, uint32 some_id
mysql_free_result(result);
}
safe_delete_array(query);
return(true);
return true;
}
void ZoneDatabase::UpdateRecipeMadecount(uint32 recipe_id, uint32 char_id, uint32 madecount)
{
char *query = 0;
std::string query;
uint32 qlen;
char errbuf[MYSQL_ERRMSG_SIZE];
qlen = MakeAnyLenString(&query, "INSERT INTO char_recipe_list "
" SET recipe_id = %u, char_id = %u, madecount = %u "
" ON DUPLICATE KEY UPDATE madecount = %u;"
, recipe_id, char_id, madecount, madecount);
StringFormat(query, "INSERT INTO char_recipe_list "
"SET recipe_id = %u, char_id = %u, madecount = %u "
"ON DUPLICATE KEY UPDATE madecount = %u;",
recipe_id, char_id, madecount, madecount);
if (!RunQuery(query, qlen, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error in UpdateRecipeMadecount query '%s': %s", query, errbuf);
if (!RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error in UpdateRecipeMadecount query '%s': %s", query.c_str(), errbuf);
}
safe_delete_array(query);
}
void Client::LearnRecipe(uint32 recipeID)
{
char *query = 0;
std::string query;
uint32 qlen;
uint32 qcount = 0;
char errbuf[MYSQL_ERRMSG_SIZE];
MYSQL_RES *result;
MYSQL_ROW row;
qlen = MakeAnyLenString(&query, "SELECT tr.name, crl.madecount "
" FROM tradeskill_recipe as tr "
" LEFT JOIN (SELECT recipe_id, madecount FROM char_recipe_list WHERE char_id = %u) AS crl "
" ON tr.id = crl.recipe_id "
" WHERE tr.id = %u ;", CharacterID(), recipeID);
StringFormat(query, "SELECT tr.name, crl.madecount "
"FROM tradeskill_recipe as tr "
"LEFT JOIN (SELECT recipe_id, madecount "
"FROM char_recipe_list WHERE char_id = %u) AS crl "
"ON tr.id = crl.recipe_id "
"WHERE tr.id = %u ;",
CharacterID(), recipeID);
if (!database.RunQuery(query, qlen, errbuf, &result)) {
LogFile->write(EQEMuLog::Error, "Error in Client::LearnRecipe query '%s': %s", query, errbuf);
safe_delete_array(query);
if (!database.RunQuery(query, errbuf, &result)) {
LogFile->write(EQEMuLog::Error, "Error in Client::LearnRecipe query '%s': %s", query.c_str(), errbuf);
return;
}
@ -1488,10 +1490,8 @@ void Client::LearnRecipe(uint32 recipeID)
if (qcount != 1) {
LogFile->write(EQEMuLog::Normal, "Client::LearnRecipe - RecipeID: %d had %d occurences.", recipeID, qcount);
mysql_free_result(result);
safe_delete_array(query);
return;
}
safe_delete_array(query);
row = mysql_fetch_row(result);
@ -1500,15 +1500,14 @@ void Client::LearnRecipe(uint32 recipeID)
if (row[1] == nullptr) {
Message_StringID(4, TRADESKILL_LEARN_RECIPE, row[0]);
// Actually learn the recipe now
qlen = MakeAnyLenString(&query, "INSERT INTO char_recipe_list "
" SET recipe_id = %u, char_id = %u, madecount = 0 "
" ON DUPLICATE KEY UPDATE madecount = madecount;"
, recipeID, CharacterID());
StringFormat(query, "INSERT INTO char_recipe_list "
"SET recipe_id = %u, char_id = %u, madecount = 0 "
"ON DUPLICATE KEY UPDATE madecount = madecount;",
recipeID, CharacterID());
if (!database.RunQuery(query, qlen, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error in LearnRecipe query '%s': %s", query, errbuf);
if (!database.RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error in LearnRecipe query '%s': %s", query.c_str(), errbuf);
}
safe_delete_array(query);
}
}

70
zone/trading.cpp
View File

@ -1188,19 +1188,21 @@ static void BazaarAuditTrail(const char *Seller, const char *Buyer, const char *
"VALUES (NOW(), '%s', '%s', '%s', %i, %i, %i)";
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
if(!database.RunQuery(query, MakeAnyLenString(&query, AuditQuery, Seller, Buyer, ItemName, Quantity, TotalCost, TranType), errbuf))
_log(TRADING__CLIENT, "Audit write error: %s : %s", query, errbuf);
StringFormat(query, AuditQuery, Seller, Buyer, ItemName, Quantity, TotalCost, TranType);
if(!database.RunQuery(query, errbuf))
_log(TRADING__CLIENT, "Audit write error: %s : %s", query.c_str(), errbuf);
safe_delete_array(query);
}
void Client::BuyTraderItem(TraderBuy_Struct* tbs,Client* Trader,const EQApplicationPacket* app){
if(!Trader) return;
if(!Trader)
return;
if(!Trader->IsTrader()) {
TradeRequestFailed(app);
@ -1334,14 +1336,12 @@ void Client::BuyTraderItem(TraderBuy_Struct* tbs,Client* Trader,const EQApplicat
void Client::SendBazaarWelcome(){
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
if (database.RunQuery(query,MakeAnyLenString(&query, "select count(distinct char_id),count(char_id) from trader"),errbuf,&result)){
std::string query = "select count(distinct char_id),count(char_id) from trader";
if (database.RunQuery(query,errbuf,&result)){
if(mysql_num_rows(result)==1){
row = mysql_fetch_row(result);
@ -1364,9 +1364,10 @@ void Client::SendBazaarWelcome(){
}
mysql_free_result(result);
}
safe_delete_array(query);
query = "select count(distinct charid) from buyer";
if (database.RunQuery(query,MakeAnyLenString(&query, "select count(distinct charid) from buyer"),errbuf,&result)){
if (database.RunQuery(query,errbuf,&result)){
if(mysql_num_rows(result)==1) {
row = mysql_fetch_row(result);
@ -1376,14 +1377,13 @@ void Client::SendBazaarWelcome(){
}
mysql_free_result(result);
}
safe_delete_array(query);
}
void Client::SendBazaarResults(uint32 TraderID, uint32 Class_, uint32 Race, uint32 ItemStat, uint32 Slot, uint32 Type,
char Name[64], uint32 MinPrice, uint32 MaxPrice) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* Query = 0;
std::string query;
std::string Search, Values;
MYSQL_RES *Result;
MYSQL_ROW Row;
@ -1573,11 +1573,13 @@ void Client::SendBazaarResults(uint32 TraderID, uint32 Class_, uint32 Race, uint
Values.append(",sum(charges), items.stackable ");
if (database.RunQuery(Query,MakeAnyLenString(&Query, "select %s from trader,items %s group by items.id,charges,char_id limit %i",
Values.c_str(),Search.c_str(), RuleI(Bazaar, MaxSearchResults)),errbuf,&Result)){
StringFormat(query, "select %s from trader,items %s group by "
"items.id,charges,char_id limit %i",
Values.c_str(),Search.c_str(), RuleI(Bazaar, MaxSearchResults));
_log(TRADING__CLIENT, "SRCH: %s", Query);
safe_delete_array(Query);
if (database.RunQuery(query,errbuf,&Result)){
_log(TRADING__CLIENT, "SRCH: %s", query.c_str());
int Size = 0;
uint32 ID = 0;
@ -1686,8 +1688,7 @@ void Client::SendBazaarResults(uint32 TraderID, uint32 Class_, uint32 Race, uint
}
else{
_log(TRADING__CLIENT, "Failed to retrieve Bazaar Search!! %s %s\n", Query, errbuf);
safe_delete_array(Query);
_log(TRADING__CLIENT, "Failed to retrieve Bazaar Search!! %s %s\n", query.c_str(), errbuf);
return;
}
}
@ -2018,17 +2019,19 @@ void Client::SendBuyerResults(char* SearchString, uint32 SearchID) {
_log(TRADING__BARTER, "Client::SendBuyerResults %s\n", SearchString);
char errbuf[MYSQL_ERRMSG_SIZE];
char* Query = 0;
std::string query;
char ItemName[64];
std::string Search, Values;
MYSQL_RES *Result;
MYSQL_ROW Row;
char*EscSearchString = new char[strlen(SearchString) * 2 + 1];
database.DoEscapeString(EscSearchString, SearchString, strlen(SearchString));
std::string escSearchString;
database.DoEscapeString(escSearchString, SearchString, strlen(SearchString));
if (database.RunQuery(Query,MakeAnyLenString(&Query, "select * from buyer where itemname like '%%%s%%' order by charid limit %i",
EscSearchString, RuleI(Bazaar, MaxBarterSearchResults)), errbuf, &Result)) {
StringFormat(query, "select * from buyer where itemname like '%%%s%%' order by charid limit %i",
escSearchString.c_str(), RuleI(Bazaar, MaxBarterSearchResults));
if (database.RunQuery(query,errbuf, &Result)) {
int NumberOfRows = mysql_num_rows(Result);
@ -2044,7 +2047,6 @@ void Client::SendBuyerResults(char* SearchString, uint32 SearchID) {
if(NumberOfRows == 0) {
mysql_free_result(Result);
safe_delete_array(Query);
return;
}
@ -2104,10 +2106,8 @@ void Client::SendBuyerResults(char* SearchString, uint32 SearchID) {
mysql_free_result(Result);
}
else{
_log(TRADING__CLIENT, "Failed to retrieve Barter Search!! %s %s\n", Query, errbuf);
_log(TRADING__CLIENT, "Failed to retrieve Barter Search!! %s %s\n", query.c_str(), errbuf);
}
safe_delete_array(Query);
safe_delete_array(EscSearchString);
}
void Client::ShowBuyLines(const EQApplicationPacket *app) {
@ -2151,19 +2151,18 @@ void Client::ShowBuyLines(const EQApplicationPacket *app) {
safe_delete(outapp);
char errbuf[MYSQL_ERRMSG_SIZE];
char* Query = 0;
std::string query;
char ItemName[64];
std::string Search, Values;
MYSQL_RES *Result;
MYSQL_ROW Row;
if (database.RunQuery(Query,MakeAnyLenString(&Query, "select * from buyer where charid = %i",
Buyer->CharacterID()),errbuf,&Result)){
StringFormat(query, "select * from buyer where charid = %i",
Buyer->CharacterID());
if (database.RunQuery(query,errbuf,&Result)){
if(mysql_num_rows(Result) == 0) {
safe_delete_array(Query);
mysql_free_result(Result);
return;
@ -2203,7 +2202,6 @@ void Client::ShowBuyLines(const EQApplicationPacket *app) {
}
mysql_free_result(Result);
}
safe_delete_array(Query);
}
void Client::SellToBuyer(const EQApplicationPacket *app) {

16
zone/trap.cpp
View File

@ -267,15 +267,20 @@ Mob* EntityList::GetTrapTrigger(Trap* trap) {
//todo: rewrite this to not need direct access to trap members.
bool ZoneDatabase::LoadTraps(const char* zonename, int16 version) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
// int char_num = 0;
unsigned long* lengths;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT id,x,y,z,effect,effectvalue,effectvalue2,skill,maxzdiff,radius,chance,message,respawn_time,respawn_var,level FROM traps WHERE zone='%s' AND version=%u", zonename, version), errbuf, &result)) {
safe_delete_array(query);
StringFormat(query, "SELECT id, x, y, z, effect, effectvalue, "
"effectvalue2, skill, maxzdiff, radius, "
"chance, message, respawn_time, respawn_var, "
"level FROM traps WHERE zone='%s' "
"AND version=%u",
zonename, version);
if (RunQuery(query, errbuf, &result)) {
while ((row = mysql_fetch_row(result)))
{
lengths = mysql_fetch_lengths(result);
@ -301,8 +306,7 @@ bool ZoneDatabase::LoadTraps(const char* zonename, int16 version) {
mysql_free_result(result);
}
else {
LogFile->write(EQEMuLog::Error, "Error in LoadTraps query '%s': %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in LoadTraps query '%s': %s", query.c_str(), errbuf);
return false;
}

14
zone/tribute.cpp
View File

@ -388,8 +388,9 @@ bool ZoneDatabase::LoadTributes() {
tribute_list.clear();
const char *query = "SELECT id,name,descr,unknown,isguild FROM tributes";
if (RunQuery(query, strlen(query), errbuf, &result)) {
std::string query = "SELECT id,name,descr,unknown,isguild FROM tributes";
if (RunQuery(query, errbuf, &result)) {
int r;
while ((row = mysql_fetch_row(result))) {
r = 0;
@ -403,13 +404,14 @@ bool ZoneDatabase::LoadTributes() {
}
mysql_free_result(result);
} else {
LogFile->write(EQEMuLog::Error, "Error in LoadTributes first query '%s': %s", query, errbuf);
LogFile->write(EQEMuLog::Error, "Error in LoadTributes first query '%s': %s", query.c_str(), errbuf);
return false;
}
const char *query2 = "SELECT tribute_id,level,cost,item_id FROM tribute_levels ORDER BY tribute_id,level";
if (RunQuery(query2, strlen(query2), errbuf, &result)) {
std::string query2 = "SELECT tribute_id,level,cost,item_id FROM tribute_levels ORDER BY tribute_id,level";
if (RunQuery(query2, errbuf, &result)) {
int r;
while ((row = mysql_fetch_row(result))) {
r = 0;
@ -436,7 +438,7 @@ bool ZoneDatabase::LoadTributes() {
}
mysql_free_result(result);
} else {
LogFile->write(EQEMuLog::Error, "Error in LoadTributes level query '%s': %s", query, errbuf);
LogFile->write(EQEMuLog::Error, "Error in LoadTributes level query '%s': %s", query.c_str(), errbuf);
return false;
}

294
zone/waypoints.cpp
View File

@ -839,7 +839,7 @@ void NPC::AssignWaypoints(int32 grid) {
}
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
@ -847,7 +847,11 @@ void NPC::AssignWaypoints(int32 grid) {
Waypoints.clear();
// Retrieve the wander and pause types for this grid
if(database.RunQuery(query,MakeAnyLenString(&query,"SELECT `type`,`type2` FROM `grid` WHERE `id`=%i AND `zoneid`=%i",grid,zone->GetZoneID()),errbuf, &result))
StringFormat(query, "SELECT `type`,`type2` FROM `grid` "
"WHERE `id`=%i AND `zoneid`=%i",
grid, zone->GetZoneID());
if(database.RunQuery(query, errbuf, &result))
{
if((row = mysql_fetch_row(result)))
{
@ -869,7 +873,6 @@ void NPC::AssignWaypoints(int32 grid) {
GridErr = true;
LogFile->write(EQEMuLog::Error, "MySQL Error while trying to assign grid %u to mob %s: %s", grid, name, errbuf);
}
safe_delete_array(query);
if(!GridErr)
{
@ -877,7 +880,12 @@ void NPC::AssignWaypoints(int32 grid) {
adverrorinfo = 7561;
// Retrieve all waypoints for this grid
if(database.RunQuery(query,MakeAnyLenString(&query,"SELECT `x`,`y`,`z`,`pause`,`heading` FROM grid_entries WHERE `gridid`=%i AND `zoneid`=%i ORDER BY `number`",grid,zone->GetZoneID()),errbuf,&result))
StringFormat(query, "SELECT `x`,`y`,`z`,`pause`,`heading` FROM "
"grid_entries WHERE `gridid`=%i AND "
"`zoneid`=%i ORDER BY `number`",
grid,zone->GetZoneID());
if(database.RunQuery(query,errbuf,&result))
{
roamer = true;
max_wp = -1; // Initialize it; will increment it for each waypoint successfully added to the list
@ -919,7 +927,6 @@ void NPC::AssignWaypoints(int32 grid) {
WPErr = true;
LogFile->write(EQEMuLog::Error, "MySQL Error while trying to assign waypoints from grid %u to mob %s: %s", grid, name, errbuf);
}
safe_delete_array(query);
} // end if (!GridErr)
if(Waypoints.size() < 2) {
roamer = false;
@ -989,44 +996,46 @@ void Mob::SendToFixZ(float new_x, float new_y, float new_z) {
}
int ZoneDatabase::GetHighestGrid(uint32 zoneid) {
char *query = 0;
std::string query;
char errbuff[MYSQL_ERRMSG_SIZE];
MYSQL_RES *result;
MYSQL_ROW row;
int res = 0;
if (RunQuery(query, MakeAnyLenString(&query,
"SELECT COALESCE(MAX(id), 0) FROM grid WHERE zoneid = %i",
zoneid),errbuff,&result)) {
safe_delete_array(query);
StringFormat(query, "SELECT COALESCE(MAX(id), 0) FROM grid WHERE zoneid = %i",
zoneid);
if (RunQuery(query, errbuff,&result)) {
if (mysql_num_rows(result) == 1) {
row = mysql_fetch_row(result);
res = atoi( row[0] );
}
mysql_free_result(result);
} else {
LogFile->write(EQEMuLog::Error, "Error in GetHighestGrid query '%s': %s", query, errbuff);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in GetHighestGrid query '%s': %s", query.c_str(), errbuff);
}
return(res);
}
uint8 ZoneDatabase::GetGridType2(uint32 grid, uint16 zoneid) {
char *query = 0;
std::string query;
char errbuff[MYSQL_ERRMSG_SIZE];
MYSQL_RES *result;
MYSQL_ROW row;
int type2 = 0;
if (RunQuery(query, MakeAnyLenString(&query,"SELECT type2 from grid where id = %i and zoneid = %i",grid,zoneid),errbuff,&result)) {
safe_delete_array(query);
StringFormat(query, "SELECT type2 from grid where id = %i and zoneid = %i",
grid,zoneid);
if (RunQuery(query, errbuff,&result)) {
if (mysql_num_rows(result) == 1) {
row = mysql_fetch_row(result);
type2 = atoi( row[0] );
}
mysql_free_result(result);
} else {
LogFile->write(EQEMuLog::Error, "Error in GetGridType2 query '%s': %s", query, errbuff);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in GetGridType2 query '%s': %s", query.c_str(), errbuff);
}
return(type2);
@ -1034,12 +1043,16 @@ uint8 ZoneDatabase::GetGridType2(uint32 grid, uint16 zoneid) {
bool ZoneDatabase::GetWaypoints(uint32 grid, uint16 zoneid, uint32 num, wplist* wp) {
_CP(Database_GetWaypoints);
char *query = 0;
std::string query;
char errbuff[MYSQL_ERRMSG_SIZE];
MYSQL_RES *result;
MYSQL_ROW row;
if (RunQuery(query, MakeAnyLenString(&query,"SELECT x, y, z, pause, heading from grid_entries where gridid = %i and number = %i and zoneid = %i",grid,num,zoneid),errbuff,&result)) {
safe_delete_array(query);
StringFormat(query, "SELECT x, y, z, pause, heading from grid_entries where "
"gridid = %i and number = %i and zoneid = %i",
grid,num,zoneid);
if (RunQuery(query, errbuff,&result)) {
if (mysql_num_rows(result) == 1) {
row = mysql_fetch_row(result);
if ( wp ) {
@ -1055,15 +1068,14 @@ bool ZoneDatabase::GetWaypoints(uint32 grid, uint16 zoneid, uint32 num, wplist*
mysql_free_result(result);
}
else {
LogFile->write(EQEMuLog::Error, "Error in GetWaypoints query '%s': %s", query, errbuff);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in GetWaypoints query '%s': %s", query.c_str(), errbuff);
}
return false;
}
void ZoneDatabase::AssignGrid(Client *client, float x, float y, uint32 grid)
{
char *query = 0;
std::string query;
char errbuf[MYSQL_ERRMSG_SIZE];
MYSQL_RES *result;
MYSQL_ROW row;
@ -1073,42 +1085,31 @@ void ZoneDatabase::AssignGrid(Client *client, float x, float y, uint32 grid)
// looks like most of the stuff in spawn2 is straight integers
// so let's try that first
if(!RunQuery(
query,
MakeAnyLenString(
&query,
"SELECT id,x,y FROM spawn2 WHERE zone='%s' AND x=%i AND y=%i",
zone->GetShortName(), (int)x, (int)y
),
errbuf,
&result
)) {
LogFile->write(EQEMuLog::Error, "Error querying spawn2 '%s': '%s'", query, errbuf);
return;
StringFormat(query, "SELECT id,x,y FROM spawn2 WHERE zone='%s' AND x=%i AND y=%i",
zone->GetShortName(), (int)x, (int)y);
if(!RunQuery(query,errbuf,&result)) {
LogFile->write(EQEMuLog::Error, "Error querying spawn2 '%s': '%s'", query.c_str(), errbuf);
return;
}
safe_delete_array(query);
// how much it's allowed to be off by
#define _GASSIGN_TOLERANCE 1.0
if(!(matches = mysql_num_rows(result))) // try a fuzzy match if that didn't find it
{
mysql_free_result(result);
if(!RunQuery(
query,
MakeAnyLenString(
&query,
"SELECT id,x,y FROM spawn2 WHERE zone='%s' AND "
"ABS( ABS(x) - ABS(%f) ) < %f AND "
"ABS( ABS(y) - ABS(%f) ) < %f",
zone->GetShortName(), x, _GASSIGN_TOLERANCE, y, _GASSIGN_TOLERANCE
),
errbuf,
&result
)) {
LogFile->write(EQEMuLog::Error, "Error querying fuzzy spawn2 '%s': '%s'", query, errbuf);
StringFormat(query, "SELECT id,x,y FROM spawn2 WHERE zone='%s' AND "
"ABS( ABS(x) - ABS(%f) ) < %f AND "
"ABS( ABS(y) - ABS(%f) ) < %f",
zone->GetShortName(), x, _GASSIGN_TOLERANCE,
y, _GASSIGN_TOLERANCE);
if(!RunQuery(query,errbuf,&result)) {
LogFile->write(EQEMuLog::Error, "Error querying fuzzy spawn2 '%s': '%s'", query.c_str(), errbuf);
return;
}
safe_delete_array(query);
fuzzy = 1;
if(!(matches = mysql_num_rows(result)))
mysql_free_result(result);
@ -1126,30 +1127,22 @@ void ZoneDatabase::AssignGrid(Client *client, float x, float y, uint32 grid)
spawn2id = atoi(row[0]);
dbx = atof(row[1]);
dby = atof(row[2]);
if(!RunQuery(
query,
MakeAnyLenString(
&query,
"UPDATE spawn2 SET pathgrid = %d WHERE id = %d", grid, spawn2id
),
errbuf,
&result,
&affected_rows
)) {
LogFile->write(EQEMuLog::Error, "Error updating spawn2 '%s': '%s'", query, errbuf);
StringFormat(query, "UPDATE spawn2 SET pathgrid = %d WHERE id = %d", grid, spawn2id);
if(!RunQuery(query,errbuf,&result, &affected_rows)) {
LogFile->write(EQEMuLog::Error, "Error updating spawn2 '%s': '%s'", query.c_str(), errbuf);
return;
}
if(affected_rows == 1)
{
if(client) client->LogSQL(query);
if(client) client->LogSQL(query.c_str());
if(fuzzy)
{
float difference;
difference = sqrtf(pow(fabs(x-dbx),2) + pow(fabs(y-dby),2));
client->Message(0,
"Grid assign: spawn2 id = %d updated - fuzzy match: deviation %f",
spawn2id, difference
);
client->Message(0,"Grid assign: spawn2 id = %d updated - fuzzy match: deviation %f",
spawn2id, difference);
}
else
{
@ -1177,32 +1170,43 @@ void ZoneDatabase::AssignGrid(Client *client, float x, float y, uint32 grid)
*/
void ZoneDatabase::ModifyGrid(Client *c, bool remove, uint32 id, uint8 type, uint8 type2, uint16 zoneid) {
char *query = 0;
std::string query;
char errbuf[MYSQL_ERRMSG_SIZE];
if (!remove)
{
if(!RunQuery(query, MakeAnyLenString(&query,"INSERT INTO grid(id,zoneid,type,type2) VALUES(%i,%i,%i,%i)",id,zoneid,type,type2), errbuf)) {
LogFile->write(EQEMuLog::Error, "Error creating grid entry '%s': '%s'", query, errbuf);
} else {
if(c) c->LogSQL(query);
StringFormat(query, "INSERT INTO grid(id,zoneid,type,type2) "
"VALUES(%i,%i,%i,%i)",
id,zoneid,type,type2);
if(!RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error creating grid entry '%s': '%s'", query.c_str(), errbuf);
}
else {
if(c)
c->LogSQL(query.c_str());
}
safe_delete_array(query);
}
else
{
if(!RunQuery(query, MakeAnyLenString(&query,"DELETE FROM grid where id=%i",id), errbuf)) {
LogFile->write(EQEMuLog::Error, "Error deleting grid '%s': '%s'", query, errbuf);
StringFormat(query, "DELETE FROM grid where id=%i",id);
if(!RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error deleting grid '%s': '%s'", query.c_str(), errbuf);
} else {
if(c) c->LogSQL(query);
if(c)
c->LogSQL(query.c_str());
}
safe_delete_array(query);
query = 0;
if(!RunQuery(query, MakeAnyLenString(&query,"DELETE FROM grid_entries WHERE zoneid=%i AND gridid=%i",zoneid,id), errbuf)) {
LogFile->write(EQEMuLog::Error, "Error deleting grid entries '%s': '%s'", query, errbuf);
StringFormat(query, "DELETE FROM grid_entries WHERE zoneid=%i AND gridid=%i", zoneid, id);
if(!RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error deleting grid entries '%s': '%s'", query.c_str(), errbuf);
} else {
if(c) c->LogSQL(query);
if(c)
c->LogSQL(query.c_str());
}
safe_delete_array(query);
}
} /*** END ZoneDatabase::ModifyGrid() ***/
@ -1212,15 +1216,19 @@ void ZoneDatabase::ModifyGrid(Client *c, bool remove, uint32 id, uint8 type, uin
void ZoneDatabase::AddWP(Client *c, uint32 gridid, uint32 wpnum, float xpos, float ypos, float zpos, uint32 pause, uint16 zoneid, float heading)
{
char *query = 0;
std::string query;
char errbuf[MYSQL_ERRMSG_SIZE];
if(!RunQuery(query,MakeAnyLenString(&query,"INSERT INTO grid_entries (gridid,zoneid,`number`,x,y,z,pause,heading) values (%i,%i,%i,%f,%f,%f,%i,%f)",gridid,zoneid,wpnum,xpos,ypos,zpos,pause,heading), errbuf)) {
LogFile->write(EQEMuLog::Error, "Error adding waypoint '%s': '%s'", query, errbuf);
StringFormat(query, "INSERT INTO grid_entries (gridid,zoneid,`number`,x,y,z,pause,heading) "
"values (%i, %i, %i, %f, %f, %f, %i, %f)",
gridid, zoneid, wpnum, xpos, ypos, zpos, pause, heading);
if(!RunQuery(query,errbuf)) {
LogFile->write(EQEMuLog::Error, "Error adding waypoint '%s': '%s'", query.c_str(), errbuf);
} else {
if(c) c->LogSQL(query);
if(c)
c->LogSQL(query.c_str());
}
safe_delete_array(query);
} /*** END ZoneDatabase::AddWP() ***/
@ -1237,15 +1245,21 @@ void ZoneDatabase::AddWP(Client *c, uint32 gridid, uint32 wpnum, float xpos, flo
void ZoneDatabase::DeleteWaypoint(Client *c, uint32 grid_num, uint32 wp_num, uint16 zoneid)
{
char *query=0;
std::string query;
char errbuf[MYSQL_ERRMSG_SIZE];
if(!RunQuery(query, MakeAnyLenString(&query,"DELETE FROM grid_entries where gridid=%i and zoneid=%i and `number`=%i",grid_num,zoneid,wp_num), errbuf)) {
LogFile->write(EQEMuLog::Error, "Error deleting waypoint '%s': '%s'", query, errbuf);
} else {
if(c) c->LogSQL(query);
StringFormat(query, "DELETE FROM grid_entries where "
"gridid=%i and zoneid=%i and `number`=%i",
grid_num,zoneid,wp_num);
if(!RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error deleting waypoint '%s': '%s'", query.c_str(), errbuf);
}
else {
if(c)
c->LogSQL(query.c_str());
}
safe_delete_array(query);
} /*** END ZoneDatabase::DeleteWaypoint() ***/
@ -1258,30 +1272,31 @@ void ZoneDatabase::DeleteWaypoint(Client *c, uint32 grid_num, uint32 wp_num, uin
*/
uint32 ZoneDatabase::AddWPForSpawn(Client *c, uint32 spawn2id, float xpos, float ypos, float zpos, uint32 pause, int type1, int type2, uint16 zoneid, float heading) {
char *query = 0;
uint32 grid_num, // The grid number the spawn is assigned to (if spawn has no grid, will be the grid number we end up creating)
next_wp_num; // The waypoint number we should be assigning to the new waypoint
std::string query;
uint32 grid_num, // The grid number the spawn is assigned to (if spawn has no grid, will be the grid number we end up creating)
next_wp_num; // The waypoint number we should be assigning to the new waypoint
bool CreatedNewGrid; // Did we create a new grid in this function?
MYSQL_RES *result;
MYSQL_ROW row;
char errbuf[MYSQL_ERRMSG_SIZE];
// See what grid number our spawn is assigned
if(RunQuery(query, MakeAnyLenString(&query,"SELECT pathgrid FROM spawn2 WHERE id=%i",spawn2id),errbuf,&result))
StringFormat(query, "SELECT pathgrid FROM spawn2 WHERE id=%i",spawn2id);
if(RunQuery(query, errbuf,&result))
{
safe_delete_array(query);
if(mysql_num_rows(result) > 0)
{
row = mysql_fetch_row(result);
grid_num = atoi(row[0]);
}
else // This spawn ID was not found in the `spawn2` table
return 0;
return 0;
mysql_free_result(result);
}
else { // Query error
LogFile->write(EQEMuLog::Error, "Error setting pathgrid '%s': '%s'", query, errbuf);
LogFile->write(EQEMuLog::Error, "Error setting pathgrid '%s': '%s'", query.c_str(), errbuf);
return 0;
}
@ -1289,52 +1304,63 @@ uint32 ZoneDatabase::AddWPForSpawn(Client *c, uint32 spawn2id, float xpos, float
{
CreatedNewGrid = true;
if((grid_num = GetFreeGrid(zoneid)) == 0) // There are no grids for the current zone -- create Grid #1
grid_num = 1;
if(!RunQuery(query, MakeAnyLenString(&query,"insert into grid set id='%i',zoneid= %i, type='%i', type2='%i'",grid_num,zoneid,type1,type2), errbuf)) {
LogFile->write(EQEMuLog::Error, "Error adding grid '%s': '%s'", query, errbuf);
grid_num = 1;
StringFormat(query,"insert into grid set id='%i',zoneid= %i, type='%i', type2='%i'",
grid_num,zoneid,type1,type2);
if(!RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error adding grid '%s': '%s'", query.c_str(), errbuf);
} else {
if(c) c->LogSQL(query);
if(c)
c->LogSQL(query.c_str());
}
safe_delete_array(query);
query = 0;
if(!RunQuery(query, MakeAnyLenString(&query,"update spawn2 set pathgrid='%i' where id='%i'",grid_num,spawn2id), errbuf)) {
LogFile->write(EQEMuLog::Error, "Error updating spawn2 pathing '%s': '%s'", query, errbuf);
StringFormat(query, "update spawn2 set pathgrid='%i' where id='%i'",
grid_num, spawn2id);
if(!RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error updating spawn2 pathing '%s': '%s'", query.c_str(), errbuf);
} else {
if(c) c->LogSQL(query);
if(c)
c->LogSQL(query.c_str());
}
safe_delete_array(query);
}
else // NPC had a grid assigned to it
CreatedNewGrid = false;
// Find out what the next waypoint is for this grid
query = 0;
if(RunQuery(query, MakeAnyLenString(&query,"SELECT max(`number`) FROM grid_entries WHERE zoneid='%i' AND gridid='%i'",zoneid,grid_num),errbuf,&result))
StringFormat(query,"SELECT max(`number`) FROM "
"grid_entries WHERE zoneid='%i' "
"AND gridid='%i'",
zoneid, grid_num);
if(RunQuery(query,errbuf,&result))
{
safe_delete_array(query);
row = mysql_fetch_row(result);
if(row[0] != 0)
next_wp_num = atoi(row[0]) + 1;
next_wp_num = atoi(row[0]) + 1;
else // No waypoints in this grid yet
next_wp_num = 1;
next_wp_num = 1;
mysql_free_result(result);
}
else { // Query error
LogFile->write(EQEMuLog::Error, "Error getting next waypoint id '%s': '%s'", query, errbuf);
LogFile->write(EQEMuLog::Error, "Error getting next waypoint id '%s': '%s'", query.c_str(), errbuf);
return 0;
}
query = 0;
if(!RunQuery(query, MakeAnyLenString(&query,"INSERT INTO grid_entries(gridid,zoneid,`number`,x,y,z,pause,heading) VALUES (%i,%i,%i,%f,%f,%f,%i,%f)",grid_num,zoneid,next_wp_num,xpos,ypos,zpos,pause,heading), errbuf)) {
LogFile->write(EQEMuLog::Error, "Error adding grid entry '%s': '%s'", query, errbuf);
StringFormat(query, "INSERT INTO grid_entries(gridid,zoneid,`number`,x,y,z,pause,heading) "
"VALUES (%i,%i,%i,%f,%f,%f,%i,%f)",
grid_num, zoneid, next_wp_num, xpos, ypos, zpos, pause, heading);
if(!RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error adding grid entry '%s': '%s'", query.c_str(), errbuf);
} else {
if(c) c->LogSQL(query);
if(c)
c->LogSQL(query.c_str());
}
safe_delete_array(query);
if(CreatedNewGrid)
return grid_num;
@ -1344,12 +1370,14 @@ uint32 ZoneDatabase::AddWPForSpawn(Client *c, uint32 spawn2id, float xpos, float
uint32 ZoneDatabase::GetFreeGrid(uint16 zoneid) {
char *query = 0;
std::string query;
char errbuf[MYSQL_ERRMSG_SIZE];
MYSQL_RES *result;
MYSQL_ROW row;
if (RunQuery(query, MakeAnyLenString(&query,"SELECT max(id) from grid where zoneid = %i",zoneid),errbuf,&result)) {
safe_delete_array(query);
StringFormat(query, "SELECT max(id) from grid where zoneid = %i",zoneid);
if (RunQuery(query, errbuf,&result)) {
if (mysql_num_rows(result) == 1) {
row = mysql_fetch_row(result);
uint32 tmp=0;
@ -1362,30 +1390,30 @@ uint32 ZoneDatabase::GetFreeGrid(uint16 zoneid) {
mysql_free_result(result);
}
else {
LogFile->write(EQEMuLog::Error, "Error in GetFreeGrid query '%s': %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in GetFreeGrid query '%s': %s", query.c_str(), errbuf);
}
return 0;
}
int ZoneDatabase::GetHighestWaypoint(uint32 zoneid, uint32 gridid) {
char *query = 0;
std::string query;
char errbuff[MYSQL_ERRMSG_SIZE];
MYSQL_RES *result;
MYSQL_ROW row;
int res = 0;
if (RunQuery(query, MakeAnyLenString(&query,
"SELECT COALESCE(MAX(number), 0) FROM grid_entries WHERE zoneid = %i AND gridid = %i",
zoneid, gridid),errbuff,&result)) {
safe_delete_array(query);
StringFormat(query, "SELECT COALESCE(MAX(number), 0) FROM "
"grid_entries WHERE zoneid = %i AND gridid = %i",
zoneid, gridid);
if (RunQuery(query,errbuff,&result)) {
if (mysql_num_rows(result) == 1) {
row = mysql_fetch_row(result);
res = atoi( row[0] );
}
mysql_free_result(result);
} else {
LogFile->write(EQEMuLog::Error, "Error in GetHighestWaypoint query '%s': %s", query, errbuff);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in GetHighestWaypoint query '%s': %s", query.c_str(), errbuff);
}
return(res);

360
zone/zone.cpp
View File

@ -178,17 +178,17 @@ bool Zone::Bootup(uint32 iZoneID, uint32 iInstanceID, bool iStaticZone) {
//this really loads the objects into entity_list
bool Zone::LoadZoneObjects() {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = nullptr;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
uint32 len_query = MakeAnyLenString(&query, "SELECT "
"id,zoneid,xpos,ypos,zpos,heading,itemid,charges,objectname,type,icon,"
"unknown08,unknown10,unknown20,unknown24,unknown76"
" from object where zoneid=%i and (version=%u or version=-1)", zoneid, instanceversion);
StringFormat(query, "SELECT id, zoneid, xpos, ypos, zpos, "
"heading, itemid, charges, objectname, type, icon, "
"unknown08, unknown10, unknown20, unknown24, unknown76 "
"from object where zoneid=%i and (version=%u or version=-1)",
zoneid, instanceversion);
if (database.RunQuery(query, len_query, errbuf, &result)) {
safe_delete_array(query);
if (database.RunQuery(query, errbuf, &result)) {
LogFile->write(EQEMuLog::Status, "Loading Objects from DB...");
while ((row = mysql_fetch_row(result))) {
if (atoi(row[9]) == 0)
@ -306,11 +306,10 @@ bool Zone::LoadZoneObjects() {
mysql_free_result(result);
}
else {
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error Loading Objects from DB: %s",errbuf);
return(false);
return false;
}
return(true);
return true;
}
//this also just loads into entity_list, not really into zone
@ -436,57 +435,30 @@ uint32 Zone::GetTempMerchantQuantity(uint32 NPCID, uint32 Slot) {
void Zone::LoadTempMerchantData(){
LogFile->write(EQEMuLog::Status, "Loading Temporary Merchant Lists...");
char* query = 0;
std::string query;
uint32_breakdown workpt;
workpt.b4() = DBA_b4_Zone;
workpt.w2_3() = 0;
workpt.b1() = DBA_b1_Zone_MerchantListsTemp;
DBAsyncWork* dbaw = new DBAsyncWork(&database, &MTdbafq, workpt, DBAsync::Read);
dbaw->AddQuery(1, &query, MakeAnyLenString(&query,
"select ml.npcid,ml.slot,ml.itemid,ml.charges "
"from "
" merchantlist_temp ml, "
" spawnentry se, "
" spawn2 s2 "
"where "
" ml.npcid=se.npcid "
" and se.spawngroupid=s2.spawngroupid "
" and s2.zone='%s' and s2.version=%u", GetShortName(), GetInstanceVersion()));
StringFormat(query, "select ml.npcid,ml.slot,ml.itemid,ml.charges "
"from "
" merchantlist_temp ml, "
" spawnentry se, "
" spawn2 s2 "
"where "
" ml.npcid=se.npcid "
" and se.spawngroupid=s2.spawngroupid "
" and s2.zone='%s' and s2.version=%u",
GetShortName(), GetInstanceVersion());
dbaw->AddQuery(1, query);
if (!(pQueuedMerchantsWorkID = dbasync->AddWork(&dbaw))) {
safe_delete(dbaw);
LogFile->write(EQEMuLog::Error, "dbasync->AddWork() failed adding merchant list query");
return;
}
/* char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
std::list<TempMerchantList> merlist;
if (database.RunQuery(query, MakeAnyLenString(&query, "select ml.npcid,ml.slot,ml.itemid,ml.charges from merchantlist_temp ml, npc_types nt, spawnentry se, spawn2 s2 where nt.id=ml.npcid and nt.id=se.npcid and se.spawngroupid=s2.spawngroupid and s2.zone='%s' group by ml.npcid,slot order by npcid,slot asc", GetShortName()), errbuf, &result)) {
uint32 npcid = 0;
while((row = mysql_fetch_row(result))) {
if(npcid != atoul(row[0])){
if(npcid > 0)
tmpmerchanttable[npcid] = merlist;
npcid = atoul(row[0]);
merlist.clear();
}
TempMerchantList ml;
ml.npcid = npcid;
ml.slot = atoul(row[1]);
ml.item = atoul(row[2]);
ml.charges = atoul(row[3]);
ml.origslot = ml.slot;
merlist.push_back(ml);
}
if(npcid > 0)
tmpmerchanttable[npcid] = merlist;
mysql_free_result(result);
}
else
cerr << "Error in LoadTempMerchantData query '" << query << "' " << errbuf << endl;
safe_delete_array(query);
*/
}
void Zone::LoadTempMerchantData_result(MYSQL_RES* result) {
@ -511,18 +483,22 @@ void Zone::LoadTempMerchantData_result(MYSQL_RES* result) {
ml.origslot = ml.slot;
cur->second.push_back(ml);
}
//mysql_free_result(result);
//LogFile->write(EQEMuLog::Status, "Finished Loading Temporary Merchant Lists...");
}
//there should prolly be a temp counterpart of this...
void Zone::LoadNewMerchantData(uint32 merchantid){
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
std::list<MerchantList> merlist;
if (database.RunQuery(query, MakeAnyLenString(&query, "SELECT item, slot, faction_required, level_required, alt_currency_cost FROM merchantlist WHERE merchantid=%d", merchantid), errbuf, &result)) {
StringFormat(query,"SELECT item, slot, faction_required, "
"level_required, alt_currency_cost "
"FROM merchantlist WHERE merchantid=%d",
merchantid);
if (database.RunQuery(query, errbuf, &result)) {
while((row = mysql_fetch_row(result))) {
MerchantList ml;
ml.id = merchantid;
@ -537,8 +513,7 @@ void Zone::LoadNewMerchantData(uint32 merchantid){
mysql_free_result(result);
}
else
LogFile->write(EQEMuLog::Error, "Error in LoadNewMerchantData query '%s' %s", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in LoadNewMerchantData query '%s' %s", query.c_str(), errbuf);
}
void Zone::LoadMerchantData_result(MYSQL_RES* result) {
@ -583,65 +558,45 @@ void Zone::LoadMerchantData_result(MYSQL_RES* result) {
void Zone::GetMerchantDataForZoneLoad(){
LogFile->write(EQEMuLog::Status, "Loading Merchant Lists...");
char* query = 0;
std::string query;
uint32_breakdown workpt;
workpt.b4() = DBA_b4_Zone;
workpt.w2_3() = 0;
workpt.b1() = DBA_b1_Zone_MerchantLists;
DBAsyncWork* dbaw = new DBAsyncWork(&database, &MTdbafq, workpt, DBAsync::Read);
dbaw->AddQuery(1, &query, MakeAnyLenString(&query,
"select ml.merchantid,ml.slot,ml.item,ml.faction_required,ml.level_required,ml.alt_currency_cost "
"from merchantlist ml, npc_types nt, spawnentry se, spawn2 s2 "
"where nt.merchant_id=ml.merchantid and nt.id=se.npcid "
"and se.spawngroupid=s2.spawngroupid and s2.zone='%s' and s2.version=%u "
//"group by ml.merchantid,slot order by merchantid,slot asc" //this made the query use a temp table/filesort (very slow)... so we handle unsorted data on our end.
, GetShortName(), GetInstanceVersion()));
StringFormat(query,"select ml.merchantid,ml.slot,ml.item,ml.faction_required,ml.level_required, "
"ml.alt_currency_cost "
"from merchantlist ml, npc_types nt, spawnentry se, spawn2 s2 "
"where nt.merchant_id=ml.merchantid and nt.id=se.npcid "
"and se.spawngroupid=s2.spawngroupid and s2.zone='%s' and s2.version=%u ",
//
//"group by ml.merchantid,slot order by merchantid,slot asc"
//
//this made the query use a temp table/filesort (very slow)...
//so we handle unsorted data on our end.
GetShortName(), GetInstanceVersion());
dbaw->AddQuery(1, query);
if (!(pQueuedMerchantsWorkID = dbasync->AddWork(&dbaw))) {
safe_delete(dbaw);
LogFile->write(EQEMuLog::Error,"dbasync->AddWork() failed adding merchant list query");
return;
}
/* char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
std::list<MerchantList> merlist;
if (database.RunQuery(query, MakeAnyLenString(&query, "select ml.merchantid,ml.slot,ml.item from merchantlist ml, npc_types nt, spawnentry se, spawn2 s2 where nt.merchant_id=ml.merchantid and nt.id=se.npcid and se.spawngroupid=s2.spawngroupid and s2.zone='%s' group by ml.merchantid,slot order by merchantid,slot asc", GetShortName()), errbuf, &result)) {
uint32 npcid = 0;
while((row = mysql_fetch_row(result))) {
if(npcid != atoul(row[0])){
if(npcid > 0)
merchanttable[npcid] = merlist;
npcid = atoul(row[0]);
merlist.clear();
}
MerchantList ml;
ml.id = npcid;
ml.slot = atoul(row[1]);
ml.item = atoul(row[2]);
merlist.push_back(ml);
}
if(npcid > 0)
merchanttable[npcid] = merlist;
mysql_free_result(result);
}
else
cerr << "Error in GetMerchantDataForZoneLoad query '" << query << "' " << errbuf << endl;
safe_delete_array(query);
*/
}
void Zone::LoadMercTemplates(){
std::string errorMessage;
char* Query = 0;
char TempErrorMessageBuffer[MYSQL_ERRMSG_SIZE];
MYSQL_RES* DatasetResult;
MYSQL_ROW DataRow;
std::list<MercStanceInfo> merc_stances;
merc_templates.clear();
if(!database.RunQuery(Query, MakeAnyLenString(&Query, "SELECT `class_id`, `proficiency_id`, `stance_id`, `isdefault` FROM `merc_stance_entries` order by `class_id`, `proficiency_id`, `stance_id`"), TempErrorMessageBuffer, &DatasetResult)) {
std::string query = "SELECT `class_id`, `proficiency_id`, `stance_id`, `isdefault` "
"FROM `merc_stance_entries` order by `class_id`, `proficiency_id`, `stance_id`";
if(!database.RunQuery(query, TempErrorMessageBuffer, &DatasetResult)) {
errorMessage = std::string(TempErrorMessageBuffer);
}
else {
@ -659,7 +614,14 @@ void Zone::LoadMercTemplates(){
mysql_free_result(DatasetResult);
}
if(!database.RunQuery(Query, MakeAnyLenString(&Query, "SELECT DISTINCT MTem.merc_template_id, MTyp.dbstring AS merc_type_id, MTem.dbstring AS merc_subtype_id, MTyp.race_id, MS.class_id, MTyp.proficiency_id, MS.tier_id, 0 AS CostFormula, MTem.clientversion, MTem.merc_npc_type_id FROM merc_types MTyp, merc_templates MTem, merc_subtypes MS WHERE MTem.merc_type_id = MTyp.merc_type_id AND MTem.merc_subtype_id = MS.merc_subtype_id ORDER BY MTyp.race_id, MS.class_id, MTyp.proficiency_id;"), TempErrorMessageBuffer, &DatasetResult)) {
query = "SELECT DISTINCT MTem.merc_template_id, MTyp.dbstring AS merc_type_id, MTem.dbstring AS "
"merc_subtype_id, MTyp.race_id, MS.class_id, MTyp.proficiency_id, MS.tier_id, 0 AS "
"CostFormula, MTem.clientversion, MTem.merc_npc_type_id FROM merc_types MTyp, "
"merc_templates MTem, merc_subtypes MS WHERE "
"MTem.merc_type_id = MTyp.merc_type_id AND MTem.merc_subtype_id = MS.merc_subtype_id "
"ORDER BY MTyp.race_id, MS.class_id, MTyp.proficiency_id;";
if(!database.RunQuery(query, TempErrorMessageBuffer, &DatasetResult)) {
errorMessage = std::string(TempErrorMessageBuffer);
}
else {
@ -696,9 +658,6 @@ void Zone::LoadMercTemplates(){
mysql_free_result(DatasetResult);
}
safe_delete_array(Query);
Query = 0;
if(!errorMessage.empty()) {
LogFile->write(EQEMuLog::Error, "Error in ZoneDatabase::LoadMercTemplates()");
}
@ -707,13 +666,14 @@ void Zone::LoadMercTemplates(){
void Zone::LoadLevelEXPMods(){
std::string errorMessage;
char* Query = 0;
char TempErrorMessageBuffer[MYSQL_ERRMSG_SIZE];
MYSQL_RES* DatasetResult;
MYSQL_ROW DataRow;
level_exp_mod.clear();
if(!database.RunQuery(Query, MakeAnyLenString(&Query, "SELECT level, exp_mod, aa_exp_mod FROM level_exp_mods"), TempErrorMessageBuffer, &DatasetResult)) {
std::string query = "SELECT level, exp_mod, aa_exp_mod FROM level_exp_mods";
if(!database.RunQuery(query, TempErrorMessageBuffer, &DatasetResult)) {
errorMessage = std::string(TempErrorMessageBuffer);
}
else {
@ -727,9 +687,6 @@ void Zone::LoadLevelEXPMods(){
mysql_free_result(DatasetResult);
}
safe_delete(Query);
Query = 0;
if(!errorMessage.empty()) {
LogFile->write(EQEMuLog::Error, "Error in ZoneDatabase::LoadEXPLevelMods()");
}
@ -737,13 +694,14 @@ void Zone::LoadLevelEXPMods(){
void Zone::LoadMercSpells(){
std::string errorMessage;
char* Query = 0;
char TempErrorMessageBuffer[MYSQL_ERRMSG_SIZE];
MYSQL_RES* DatasetResult;
MYSQL_ROW DataRow;
merc_spells_list.clear();
if(!database.RunQuery(Query, MakeAnyLenString(&Query, "SELECT msl.class_id, msl.proficiency_id, msle.spell_id, msle.spell_type, msle.stance_id, msle.minlevel, msle.maxlevel, msle.slot, msle.procChance FROM merc_spell_lists msl, merc_spell_list_entries msle WHERE msle.merc_spell_list_id = msl.merc_spell_list_id ORDER BY msl.class_id, msl.proficiency_id, msle.spell_type, msle.minlevel, msle.slot;"), TempErrorMessageBuffer, &DatasetResult)) {
std::string query = "SELECT msl.class_id, msl.proficiency_id, msle.spell_id, msle.spell_type, msle.stance_id, msle.minlevel, msle.maxlevel, msle.slot, msle.procChance FROM merc_spell_lists msl, merc_spell_list_entries msle WHERE msle.merc_spell_list_id = msl.merc_spell_list_id ORDER BY msl.class_id, msl.proficiency_id, msle.spell_type, msle.minlevel, msle.slot;";
if(!database.RunQuery(query, TempErrorMessageBuffer, &DatasetResult)) {
errorMessage = std::string(TempErrorMessageBuffer);
}
else {
@ -770,9 +728,6 @@ void Zone::LoadMercSpells(){
LogFile->write(EQEMuLog::Debug, "Mercenary Debug: Loaded %i merc spells.", merc_spells_list[1].size() + merc_spells_list[2].size() + merc_spells_list[9].size() + merc_spells_list[12].size());
}
safe_delete_array(Query);
Query = 0;
if(!errorMessage.empty()) {
LogFile->write(EQEMuLog::Error, "Error in Zone::LoadMercSpells()");
}
@ -1684,18 +1639,20 @@ ZonePoint* Zone::GetClosestZonePointWithoutZone(float x, float y, float z, Clien
bool ZoneDatabase::LoadStaticZonePoints(LinkedList<ZonePoint*>* zone_point_list, const char* zonename, uint32 version)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
zone_point_list->Clear();
zone->numzonepoints = 0;
MakeAnyLenString(&query, "SELECT x, y, z, target_x, target_y, "
"target_z, target_zone_id, heading, target_heading, number, "
"target_instance, client_version_mask FROM zone_points "
"WHERE zone='%s' AND (version=%i OR version=-1) order by number", zonename, version);
if (RunQuery(query, strlen(query), errbuf, &result))
StringFormat(query, "SELECT x, y, z, target_x, target_y, "
"target_z, target_zone_id, heading, target_heading, number, "
"target_instance, client_version_mask FROM zone_points "
"WHERE zone='%s' AND (version=%i OR version=-1) order by number",
zonename, version);
if (RunQuery(query, errbuf, &result))
{
safe_delete_array(query);
while((row = mysql_fetch_row(result)))
{
ZonePoint* zp = new ZonePoint;
@ -1719,24 +1676,21 @@ bool ZoneDatabase::LoadStaticZonePoints(LinkedList<ZonePoint*>* zone_point_list,
else
{
std::cerr << "Error1 in LoadStaticZonePoints query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return false;
}
return true;
return true;
}
bool ZoneDatabase::DumpZoneState() {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
if (!RunQuery(query, MakeAnyLenString(&query, "DELETE FROM zone_state_dump WHERE zonename='%s'", zone->GetShortName()), errbuf)) {
StringFormat(query, "DELETE FROM zone_state_dump WHERE zonename='%s'", zone->GetShortName());
if (!RunQuery(query, errbuf)) {
std::cerr << "Error in DumpZoneState query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return false;
}
safe_delete_array(query);
uint32 spawn2_count = zone->CountSpawn2();
uint32 npc_count = 0;
@ -1774,47 +1728,61 @@ bool ZoneDatabase::DumpZoneState() {
}
entity_list.DoZoneDump(spawn2_dump, npc_dump, npcloot_dump, gmspawntype_dump);
query = new char[512 + ((sizeof(ZSDump_Spawn2) * spawn2_count + sizeof(ZSDump_NPC) * npc_count + sizeof(ZSDump_NPC_Loot) * npcloot_count + sizeof(NPCType) * gmspawntype_count) * 2)];
char* end = query;
end += sprintf(end, "Insert Into zone_state_dump (zonename, spawn2_count, npc_count, npcloot_count, gmspawntype_count, spawn2, npcs, npc_loot, gmspawntype) values ('%s', %i, %i, %i, %i, ", zone->GetShortName(), spawn2_count, npc_count, npcloot_count, gmspawntype_count);
*end++ = '\'';
// Should be more than enough. need to come back and
// clean this up further.
std::string spawn2Buffer;
std::string zsDumpNPCBuffer;
std::string zsDumpNPCLootBuffer;
std::string gmspawnTypeBuffer;
StringFormat(query, "Insert Into zone_state_dump "
"(zonename, spawn2_count, npc_count, npcloot_count, "
"gmspawntype_count, spawn2, npcs, npc_loot, gmspawntype) "
"values ('%s', %i, %i, %i, %i, \'",
zone->GetShortName(), spawn2_count, npc_count, npcloot_count, gmspawntype_count);
if (spawn2_dump != 0) {
end += DoEscapeString(end, (char*)spawn2_dump, sizeof(ZSDump_Spawn2) * spawn2_count);
DoEscapeString(spawn2Buffer, (char*)spawn2_dump, sizeof(ZSDump_Spawn2) * spawn2_count);
query.append(spawn2Buffer);
safe_delete_array(spawn2_dump);
}
*end++ = '\'';
end += sprintf(end, ", ");
*end++ = '\'';
query.append("\', \'");
if (npc_dump != 0) {
end += DoEscapeString(end, (char*)npc_dump, sizeof(ZSDump_NPC) * npc_count);
DoEscapeString(zsDumpNPCBuffer, (char*)npc_dump, sizeof(ZSDump_NPC) * npc_count);
query.append(zsDumpNPCBuffer);
safe_delete_array(npc_dump);
}
*end++ = '\'';
end += sprintf(end, ", ");
*end++ = '\'';
query.append("\', \'");
if (npcloot_dump != 0) {
end += DoEscapeString(end, (char*)npcloot_dump, sizeof(ZSDump_NPC_Loot) * npcloot_count);
DoEscapeString(zsDumpNPCLootBuffer, (char*)npcloot_dump, sizeof(ZSDump_NPC_Loot) * npcloot_count);
query.append(zsDumpNPCLootBuffer);
safe_delete_array(npcloot_dump);
}
*end++ = '\'';
end += sprintf(end, ", ");
*end++ = '\'';
query.append("\', \'");
if (gmspawntype_dump != 0) {
end += DoEscapeString(end, (char*)gmspawntype_dump, sizeof(NPCType) * gmspawntype_count);
DoEscapeString(gmspawnTypeBuffer, (char*)gmspawntype_dump, sizeof(NPCType) * gmspawntype_count);
query.append(gmspawnTypeBuffer);
safe_delete_array(gmspawntype_dump);
}
*end++ = '\'';
end += sprintf(end, ")");
query.append("\')");
uint32 affected_rows = 0;
if (!RunQuery(query, (uint32) (end - query), errbuf, 0, &affected_rows)) {
// if (DoEscapeString(query, (unsigned int) (end - query))) {
safe_delete_array(query);
if (!RunQuery(query, errbuf, 0, &affected_rows)) {
std::cerr << "Error in ZoneDump query " << errbuf << std::endl;
return false;
}
safe_delete_array(query);
if (affected_rows == 0) {
std::cerr << "Zone dump failed. (affected rows = 0)" << std::endl;
@ -1825,7 +1793,7 @@ bool ZoneDatabase::DumpZoneState() {
int8 ZoneDatabase::LoadZoneState(const char* zonename, LinkedList<Spawn2*>& spawn2_list) {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
@ -1843,8 +1811,11 @@ int8 ZoneDatabase::LoadZoneState(const char* zonename, LinkedList<Spawn2*>& spaw
Spawn2** spawn2_loaded = 0;
NPC** npc_loaded = 0;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT spawn2_count, npc_count, npcloot_count, gmspawntype_count, spawn2, npcs, npc_loot, gmspawntype, (UNIX_TIMESTAMP()-UNIX_TIMESTAMP(time)) as elapsedtime FROM zone_state_dump WHERE zonename='%s'", zonename), errbuf, &result)) {
safe_delete_array(query);
StringFormat(query, "SELECT spawn2_count, npc_count, npcloot_count, gmspawntype_count, spawn2, "
"npcs, npc_loot, gmspawntype, (UNIX_TIMESTAMP()-UNIX_TIMESTAMP(time)) "
"as elapsedtime FROM zone_state_dump WHERE zonename='%s'", zonename);
if (RunQuery(query, errbuf, &result)) {
if (mysql_num_rows(result) == 1) {
row = mysql_fetch_row(result);
std::cout << "Elapsed time: " << row[8] << std::endl;
@ -1997,7 +1968,6 @@ int8 ZoneDatabase::LoadZoneState(const char* zonename, LinkedList<Spawn2*>& spaw
else {
std::cerr << "Error in LoadZoneState query '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return -1;
}
@ -2144,13 +2114,13 @@ bool Zone::RemoveSpawnGroup(uint32 in_id) {
// Added By Hogie
bool ZoneDatabase::GetDecayTimes(npcDecayTimes_Struct* npcCorpseDecayTimes) {
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
int i = 0;
MYSQL_RES *result;
MYSQL_ROW row;
if (RunQuery(query, MakeAnyLenString(&query, "SELECT varname, value FROM variables WHERE varname like 'decaytime%%' ORDER BY varname"), errbuf, &result)) {
safe_delete_array(query);
std::string query = "SELECT varname, value FROM variables WHERE varname like 'decaytime%%' ORDER BY varname";
if (RunQuery(query, errbuf, &result)) {
while((row = mysql_fetch_row(result))) {
Seperator sep(row[0]);
npcCorpseDecayTimes[i].minlvl = atoi(sep.arg[1]);
@ -2164,7 +2134,6 @@ bool ZoneDatabase::GetDecayTimes(npcDecayTimes_Struct* npcCorpseDecayTimes) {
mysql_free_result(result);
}
else {
safe_delete_array(query);
return false;
}
return true;
@ -2355,12 +2324,13 @@ void Zone::SetInstanceTimer(uint32 new_duration)
void Zone::LoadLDoNTraps()
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
if(database.RunQuery(query,MakeAnyLenString(&query,"SELECT id, type, spell_id, "
"skill, locked FROM ldon_trap_templates"), errbuf, &result))
std::string query = "SELECT id, type, spell_id, "
"skill, locked FROM ldon_trap_templates";
if(database.RunQuery(query, errbuf, &result))
{
while((row = mysql_fetch_row(result)))
{
@ -2374,12 +2344,10 @@ void Zone::LoadLDoNTraps()
ldon_trap_list[lt->id] = lt;
}
mysql_free_result(result);
safe_delete_array(query);
}
else
{
LogFile->write(EQEMuLog::Error, "Error in Zone::LoadLDoNTraps: %s (%s)", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in Zone::LoadLDoNTraps: %s (%s)", query.c_str(), errbuf);
return;
}
}
@ -2387,11 +2355,12 @@ void Zone::LoadLDoNTraps()
void Zone::LoadLDoNTrapEntries()
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
if(database.RunQuery(query,MakeAnyLenString(&query,"SELECT id, trap_id FROM ldon_trap_entries"),errbuf,&result)) {
std::string query = "SELECT id, trap_id FROM ldon_trap_entries";
if(database.RunQuery(query,errbuf,&result)) {
while((row = mysql_fetch_row(result)))
{
uint32 id = atoi(row[0]);
@ -2426,12 +2395,10 @@ void Zone::LoadLDoNTrapEntries()
}
}
mysql_free_result(result);
safe_delete_array(query);
}
else
{
LogFile->write(EQEMuLog::Error, "Error in Zone::LoadLDoNTrapEntries: %s (%s)", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in Zone::LoadLDoNTrapEntries: %s (%s)", query.c_str(), errbuf);
return;
}
}
@ -2440,7 +2407,6 @@ void Zone::LoadVeteranRewards()
{
VeteranRewards.clear();
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
InternalVeteranReward current_reward;
@ -2448,10 +2414,11 @@ void Zone::LoadVeteranRewards()
current_reward.claim_id = 0;
std::string query = "SELECT claim_id, name, item_id, charges FROM "
"veteran_reward_templates WHERE reward_slot < 8 "
"and claim_id > 0 ORDER by claim_id, reward_slot";
if(database.RunQuery(query,MakeAnyLenString(&query,"SELECT claim_id, name, item_id, charges FROM"
" veteran_reward_templates WHERE reward_slot < 8 and claim_id > 0 ORDER by claim_id, reward_slot"),
errbuf,&result))
if(database.RunQuery(query,errbuf,&result))
{
while((row = mysql_fetch_row(result)))
{
@ -2482,12 +2449,10 @@ void Zone::LoadVeteranRewards()
VeteranRewards.push_back(current_reward);
}
mysql_free_result(result);
safe_delete_array(query);
}
else
{
LogFile->write(EQEMuLog::Error, "Error in Zone::LoadVeteranRewards: %s (%s)", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in Zone::LoadVeteranRewards: %s (%s)", query.c_str(), errbuf);
}
}
@ -2495,13 +2460,13 @@ void Zone::LoadAlternateCurrencies()
{
AlternateCurrencies.clear();
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
AltCurrencyDefinition_Struct current_currency;
if(database.RunQuery(query,MakeAnyLenString(&query,"SELECT id, item_id from alternate_currency"),
errbuf,&result))
std::string query = "SELECT id, item_id from alternate_currency";
if(database.RunQuery(query,errbuf,&result))
{
while((row = mysql_fetch_row(result)))
{
@ -2511,12 +2476,10 @@ void Zone::LoadAlternateCurrencies()
}
mysql_free_result(result);
safe_delete_array(query);
}
else
{
LogFile->write(EQEMuLog::Error, "Error in Zone::LoadAlternateCurrencies: %s (%s)", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in Zone::LoadAlternateCurrencies: %s (%s)", query.c_str(), errbuf);
}
}
@ -2553,11 +2516,12 @@ void Zone::DeleteQGlobal(std::string name, uint32 npcID, uint32 charID, uint32 z
void Zone::LoadAdventureFlavor()
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
if(database.RunQuery(query,MakeAnyLenString(&query,"SELECT id, text FROM adventure_template_entry_flavor"), errbuf, &result))
std::string query = "SELECT id, text FROM adventure_template_entry_flavor";
if(database.RunQuery(query,errbuf, &result))
{
while((row = mysql_fetch_row(result)))
{
@ -2566,12 +2530,10 @@ void Zone::LoadAdventureFlavor()
adventure_entry_list_flavor[id] = in_str;
}
mysql_free_result(result);
safe_delete_array(query);
}
else
{
LogFile->write(EQEMuLog::Error, "Error in Zone::LoadAdventureFlavor: %s (%s)", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in Zone::LoadAdventureFlavor: %s (%s)", query.c_str(), errbuf);
return;
}
}
@ -2636,12 +2598,13 @@ void Zone::DoAdventureActions()
void Zone::LoadNPCEmotes(LinkedList<NPC_Emote_Struct*>* NPCEmoteList)
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
MYSQL_RES *result;
MYSQL_ROW row;
NPCEmoteList->Clear();
if(database.RunQuery(query,MakeAnyLenString(&query,"SELECT emoteid, event_, type, text FROM npc_emotes"), errbuf, &result))
std::string query = "SELECT emoteid, event_, type, text FROM npc_emotes";
if(database.RunQuery(query, errbuf, &result))
{
while((row = mysql_fetch_row(result)))
{
@ -2653,12 +2616,10 @@ void Zone::LoadNPCEmotes(LinkedList<NPC_Emote_Struct*>* NPCEmoteList)
NPCEmoteList->Insert(nes);
}
mysql_free_result(result);
safe_delete_array(query);
}
else
{
LogFile->write(EQEMuLog::Error, "Error in Zone::LoadNPCEmotes: %s (%s)", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in Zone::LoadNPCEmotes: %s (%s)", query.c_str(), errbuf);
}
}
@ -2672,12 +2633,14 @@ void Zone::ReloadWorld(uint32 Option){
void Zone::LoadTickItems()
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
tick_items.clear();
if(database.RunQuery(query, MakeAnyLenString(&query, "SELECT it_itemid, it_chance, it_level, it_qglobal, it_bagslot FROM item_tick"), errbuf, &result))
query = "SELECT it_itemid, it_chance, it_level, it_qglobal, it_bagslot FROM item_tick";
if(database.RunQuery(query, errbuf, &result))
{
while((row = mysql_fetch_row(result)))
{
@ -2693,12 +2656,10 @@ void Zone::LoadTickItems()
}
}
mysql_free_result(result);
safe_delete_array(query);
}
else
{
LogFile->write(EQEMuLog::Error, "Error in Zone::LoadTickItems: %s (%s)", query, errbuf);
safe_delete_array(query);
LogFile->write(EQEMuLog::Error, "Error in Zone::LoadTickItems: %s (%s)", query.c_str(), errbuf);
}
}
@ -2720,12 +2681,14 @@ uint32 Zone::GetSpawnKillCount(uint32 in_spawnid) {
void Zone::UpdateHotzone()
{
char errbuf[MYSQL_ERRMSG_SIZE];
char* query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
bool updh;
if(database.RunQuery(query, MakeAnyLenString(&query,"SELECT hotzone FROM zone WHERE short_name = '%s'", GetShortName()), errbuf, &result) )
StringFormat(query, "SELECT hotzone FROM zone WHERE short_name = '%s'",GetShortName());
if(database.RunQuery(query, errbuf, &result) )
{
if( (row = mysql_fetch_row(result)) )
{
@ -2738,5 +2701,4 @@ void Zone::UpdateHotzone()
}
mysql_free_result(result);
}
safe_delete_array(query);
}

1612
zone/zonedb.cpp
View File

File diff suppressed because it is too large Load Diff

34
zone/zonedbasync.cpp
View File

@ -57,7 +57,7 @@ bool DBAsyncCB_CharacterBackup(DBAsyncWork* iWork) { // return true means delete
char errbuf[MYSQL_ERRMSG_SIZE] = "dbaq == 0";
MYSQL_RES* result = 0;
MYSQL_ROW row;
char* query = 0;
std::string query;
uint32 i;
uint8 ToDeleteIndex = 0;
uint32 ToDelete[MAX_TO_DELETE];
@ -90,16 +90,22 @@ bool DBAsyncCB_CharacterBackup(DBAsyncWork* iWork) { // return true means delete
}
if (ToDelete[0]) {
uint32 len = 0, size = 0;
AppendAnyLenString(&query, &size, &len, "Delete from character_backup where id=%u", ToDelete[0]);
std::string toAppend;
StringFormat(toAppend, "Delete from character_backup where id=%u", ToDelete[0]);
query.append(toAppend);
for (uint8 i=1; i<ToDeleteIndex; i++) {
AppendAnyLenString(&query, &size, &len, " or id=%u", ToDelete[i]);
StringFormat(toAppend, " or id=%u", ToDelete[i]);
query.append(toAppend);
}
if (!database.RunQuery(query, len, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error in DBAsyncCB_CharacterBackup query2 '%s' %s", query, errbuf);
safe_delete_array(query);
if (!database.RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "Error in DBAsyncCB_CharacterBackup query2 '%s' %s", query.c_str(), errbuf);
return true;
}
safe_delete_array(query);
}
bool needtoinsert = false;
for (i=0; i<MAX_BACKUPS; i++) {
@ -107,20 +113,20 @@ bool DBAsyncCB_CharacterBackup(DBAsyncWork* iWork) { // return true means delete
needtoinsert = true;
}
if (needtoinsert) {
if (!database.RunQuery(query, MakeAnyLenString(&query,
"Insert Delayed into character_backup (charid, account_id, name, profile, level, class, x, y, z, zoneid) "
"select id, account_id, name, profile, level, class, x, y, z, zoneid "
"from character_ where id=%u", iWork->WPT()), errbuf)) {
StringFormat(query, "Insert Delayed into character_backup "
"(charid, account_id, name, profile, level, class, x, y, z, zoneid) "
"select id, account_id, name, profile, level, class, x, y, z, zoneid "
"from character_ where id=%u", iWork->WPT());
if (!database.RunQuery(query, errbuf)) {
std::cout << "Error in DBAsyncCB_CharacterBackup query3 '" << query << "' " << errbuf << std::endl;
safe_delete_array(query);
return true;
}
safe_delete_array(query);
}
}
else {
// cout << "Error in DBAsyncCB_CharacterBackup query1 '" << query << "' " << errbuf << endl;
safe_delete_array(query);
return true;
}
return true;

31
zone/zoning.cpp
View File

@ -731,12 +731,14 @@ void Client::SetZoneFlag(uint32 zone_id) {
//update the DB
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
// Retrieve all waypoints for this grid
if(!database.RunQuery(query,MakeAnyLenString(&query,
"INSERT INTO zone_flags (charID,zoneID) VALUES(%d,%d)",
CharacterID(),zone_id),errbuf)) {
StringFormat(query, "INSERT INTO zone_flags (charID,zoneID) VALUES(%d,%d)",
CharacterID(),zone_id);
if(!database.RunQuery(query, errbuf)) {
LogFile->write(EQEMuLog::Error, "MySQL Error while trying to set zone flag for %s: %s", GetName(), errbuf);
}
}
@ -749,26 +751,30 @@ void Client::ClearZoneFlag(uint32 zone_id) {
//update the DB
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
// Retrieve all waypoints for this grid
if(!database.RunQuery(query,MakeAnyLenString(&query,
"DELETE FROM zone_flags WHERE charID=%d AND zoneID=%d",
CharacterID(),zone_id),errbuf)) {
StringFormat(query, "DELETE FROM zone_flags WHERE charID=%d AND zoneID=%d",
CharacterID(),zone_id);
if(!database.RunQuery(query,errbuf)) {
LogFile->write(EQEMuLog::Error, "MySQL Error while trying to clear zone flag for %s: %s", GetName(), errbuf);
}
}
void Client::LoadZoneFlags() {
char errbuf[MYSQL_ERRMSG_SIZE];
char *query = 0;
std::string query;
MYSQL_RES *result;
MYSQL_ROW row;
// Retrieve all waypoints for this grid
if(database.RunQuery(query,MakeAnyLenString(&query,
"SELECT zoneID from zone_flags WHERE charID=%d",
CharacterID()),errbuf,&result))
StringFormat(query,"SELECT zoneID from zone_flags WHERE charID=%d",
CharacterID());
if(database.RunQuery(query,errbuf,&result))
{
while((row = mysql_fetch_row(result))) {
zone_flags.insert(atoi(row[0]));
@ -779,7 +785,6 @@ void Client::LoadZoneFlags() {
{
LogFile->write(EQEMuLog::Error, "MySQL Error while trying to load zone flags for %s: %s", GetName(), errbuf);
}
safe_delete_array(query);
}
bool Client::HasZoneFlag(uint32 zone_id) const {