void sendRewards() {
QueryResult res = CharacterDatabase.PQuery("SELECT id,receiver,type,miscA,miscB,miscC,miscD FROM donations LEFT JOIN characters ON receiver=guid WHERE online=1");
if(res)
{
do
{
Field * field = res->Fetch();
uint32 id = field[0].GetUInt32();
uint32 receiver = field[1].GetUInt32();
uint32 type = field[2].GetUInt32();
uint32 misc[REWARD_SIZE];
misc[0] = field[3].GetUInt32();
misc[1] = field[4].GetUInt32();
misc[2] = field[5].GetUInt32();
misc[3] = field[6].GetUInt32();
Player * plr = sObjectAccessor->FindPlayer(receiver);
if(!plr || !plr->IsInWorld())
continue;
uint8 code = 0;
SQLTransaction trans = CharacterDatabase.BeginTransaction();
switch(type)
{
case REWARD_TYPE_GOLD:
plr->SetMoney(plr->GetMoney() + misc[0]);
break;
case REWARD_TYPE_RENAME:
plr->SetAtLoginFlag(AT_LOGIN_RENAME);
CharacterDatabase.PExecute("UPDATE characters SET at_login = at_login | '1' WHERE guid = '%u'", plr->GetGUIDLow());
break;
case REWARD_TYPE_CUSTOMIZE:
plr->SetAtLoginFlag(AT_LOGIN_CUSTOMIZE);
CharacterDatabase.PExecute("UPDATE characters SET at_login = at_login | '8' WHERE guid = '%u'", plr->GetGUIDLow());
break;
case REWARD_TYPE_RACECHANGE:
plr->SetAtLoginFlag(AT_LOGIN_CHANGE_RACE);
CharacterDatabase.PExecute("UPDATE characters SET at_login = at_login | '128' WHERE guid = '%u'", plr->GetGUIDLow());
break;
case REWARD_TYPE_FACTIONCHANGE:
plr->SetAtLoginFlag(AT_LOGIN_CHANGE_FACTION);
CharacterDatabase.PExecute("UPDATE characters SET at_login = at_login | '64' WHERE guid = '%u'", plr->GetGUIDLow());
break;
case REWARD_TYPE_SINGLEITEM:
{
for(int i = 0; i < REWARD_SIZE; i++)
{
if(misc[i] == 0) continue;
ItemTemplate const* proto = sObjectMgr->GetItemTemplate(misc[i]);
if(!proto)
{
code = 3;
break;
}
ItemPosCountVec pos;
uint32 extra = 0;
uint8 r = plr->CanStoreNewItem(NULL_BAG, NULL_SLOT, pos, misc[i], 1, &extra);
if(r != EQUIP_ERR_OK)
{
code = 4;
MailSender sender(MAIL_NORMAL,plr->GetGUIDLow(),MAIL_STATIONERY_VAL);
MailReceiver mailrecv(plr);
MailDraft draft("Reward Delivery","Here is your reward.");
Item * item = Item::CreateItem(misc[i],1);
item->SaveToDB(trans);
draft.AddItem(item);
draft.SendMailTo(trans,mailrecv,sender);
}
else
{
Item * item = plr->StoreNewItem(pos,misc[i],true);
plr->SendNewItem(item,1,true,false);
}
}
}
break;
case REWARD_TYPE_MULTIITEM:
{
for(int i = 0; i < REWARD_SIZE; i = i + 2)
{
uint32 itemid = misc[i];
uint32 itemcount = misc[i+1];
if(itemid == 0 || itemcount == 0)
continue;
ItemTemplate const * proto = sObjectMgr->GetItemTemplate(itemid);
if(!proto)
{
code = 3;
break;
}
ItemPosCountVec pos;
uint32 extra = 0;
uint32 addcount = itemcount;
uint8 r = plr->CanStoreNewItem(NULL_BAG,NULL_SLOT,pos,itemid,itemcount,&extra);
if(r != EQUIP_ERR_OK)
addcount = itemcount - extra;
if(addcount == 0 || pos.empty())
{
MailSender sender(MAIL_NORMAL,plr->GetGUIDLow(),MAIL_STATIONERY_VAL);
MailReceiver mailrecv(plr);
MailDraft draft("Reward Delivery","Here is your reward.");
Item * item = Item::CreateItem(itemid,itemcount);
item->SaveToDB(trans);
draft.AddItem(item);
draft.SendMailTo(trans,mailrecv,sender);
item = plr->StoreNewItem(pos,itemid,true);
plr->SendNewItem(item,addcount,true,false);
code = 1;
}
else if(addcount != itemcount)
{
//some can't be sent, send the rest by mail
MailSender sender(MAIL_NORMAL,plr->GetGUIDLow(),MAIL_STATIONERY_VAL);
MailReceiver mailrecv(plr);
MailDraft draft("Reward Delivery","Here is your reward.");
Item * item = Item::CreateItem(itemid,itemcount - addcount);
item->SaveToDB(trans);
draft.AddItem(item);
draft.SendMailTo(trans,mailrecv,sender);
item = plr->StoreNewItem(pos,itemid,true);
plr->SendNewItem(item,addcount,true,false);
code = 4;
}
else if(addcount == itemcount)
{
//dont need to do anything but add
plr->StoreNewItem(pos,itemid,true);
}
}
}
break;
// case REWARD_TYPE_ITEMSET:
// {
// uint32 set = misc[0];
// if(set == 0)
// {
// code = 2;
// break;
// }
// for(int i = 0; i < sItemSetStore.GetNumRows; i++)
// {
//ItemTemplate const* proto = sObjectMgr->GetItemTemplate(id);
//if(!proto)
//continue;
//if(proto->ItemSet == set)
//{
//ItemPosCountVec pos;
//uint8 r = plr->CanStoreNewItem(NULL_BAG,NULL_SLOT,pos,proto->ItemId,1);
//if(r != EQUIP_ERR_OK)
//{
//code = 1;
//MailSender sender(MAIL_NORMAL,plr->GetGUIDLow(),MAIL_STATIONERY_VAL);
//MailReceiver mailrecv(plr);
//MailDraft draft("Reward Delivery","Here is your reward.");
//Item * item = Item::CreateItem(i,1);
//item->SaveToDB(trans);
//draft.AddItem(item);
//draft.SendMailTo(trans,mailrecv,sender);
//}
//else
//{
//Item * item = plr->StoreNewItem(pos,proto->ItemId,true);
//plr->SendNewItem(item,1,true,false);
//}
// }
// }
// }
break;
case REWARD_TYPE_LEVEL:
plr->SetLevel( plr->getLevel() + misc[0] > 80 ? 80 : plr->getLevel() + misc[0] );
break;
case REWARD_TYPE_TITLE:
{
CharTitlesEntry const* entry = sCharTitlesStore.LookupEntry(misc[0]);
if(!entry)
{
code = 2;
break;
}
plr->SetTitle(entry);
}
break;
case REWARD_TYPE_SPELL:
plr->learnSpell(misc[0],false);
break;
case REWARD_TYPE_SKILL:
{
//SkillLineEntry const* entry = sSkillLineStore.LookupEntry(misc[0]);
//if(!entry)
//{
code = 2;
// break;
//}
//plr->SetSkill(misc[0],misc[1],400);
}
break;
case REWARD_TYPE_REPUTATION:
{
FactionEntry const* entry = sFactionStore.LookupEntry(misc[0]);
if(!entry)
{
code = 2;
break;
}
plr->SetReputation(entry->ID,misc[1]);
}
break;
}
WorldPacket data;
switch(code)
{
default:
ChatHandler::FillMessageData(&data, plr->GetSession(), CHAT_MSG_SYSTEM, LANG_UNIVERSAL, NULL, 0, "Thank you for your support. Enjoy your reward!", NULL);
break;
case 1:
ChatHandler::FillMessageData(&data, plr->GetSession(), CHAT_MSG_SYSTEM, LANG_UNIVERSAL, NULL, 0, "Thank you for your support. Your reward has been mailed to you.", NULL);
break;
case 2:
ChatHandler::FillMessageData(&data, plr->GetSession(), CHAT_MSG_SYSTEM, LANG_UNIVERSAL, NULL, 0, "|cffff0000Warning: Your reward could not be granted. Will try again later. :(|r", NULL);
break;
case 3:
ChatHandler::FillMessageData(&data, plr->GetSession(), CHAT_MSG_SYSTEM, LANG_UNIVERSAL, NULL, 0, "|cffff0000Warning: Your reward could not be granted. :(|r", NULL);
break;
case 4:
ChatHandler::FillMessageData(&data, plr->GetSession(), CHAT_MSG_SYSTEM, LANG_UNIVERSAL, NULL, 0, "Thank you for your support. You now have parts of your reward, the rest will arrive via mail.", NULL);
break;
}
plr->GetSession()->SendPacket(&data);
if(code != 2)
CharacterDatabase.PExecute("DELETE FROM donations WHERE id = %u",id);
plr->CastSpell(plr,19484,true);
CharacterDatabase.CommitTransaction(trans);
}
while(res->NextRow());
}
}
bool ArenaTeam::LoadMembersFromDB(QueryResult arenaTeamMembersResult)
{
if (!arenaTeamMembersResult)
return false;
bool captainPresentInTeam = false;
do
{
Field *fields = arenaTeamMembersResult->Fetch();
//prevent crash if db records are broken, when all members in result are already processed and current team hasn't got any members
if (!fields)
break;
uint32 arenaTeamId = fields[0].GetUInt32();
if (arenaTeamId < m_TeamId)
{
//there is in table arena_team_member record which doesn't have arenateamid in arena_team table, report error
sLog.outErrorDb("ArenaTeam %u does not exist but it has record in arena_team_member table, deleting it!", arenaTeamId);
CharacterDatabase.PExecute("DELETE FROM arena_team_member WHERE arenateamid = '%u'", arenaTeamId);
continue;
}
if (arenaTeamId > m_TeamId)
//we loaded all members for this arena_team already, break cycle
break;
uint32 player_guid = fields[1].GetUInt32();
QueryResult result = CharacterDatabase.PQuery(
"SELECT personal_rating, matchmaker_rating FROM character_arena_stats WHERE guid = '%u' AND slot = '%u'", player_guid, GetSlot());
uint32 personalrating = 0;
uint32 matchmakerrating = 1500;
if (result)
{
personalrating = (*result)[0].GetUInt32();
matchmakerrating = (*result)[1].GetUInt32();
}
ArenaTeamMember newmember;
newmember.guid = MAKE_NEW_GUID(player_guid, 0, HIGHGUID_PLAYER);
newmember.games_week = fields[2].GetUInt32();
newmember.wins_week = fields[3].GetUInt32();
newmember.games_season = fields[4].GetUInt32();
newmember.wins_season = fields[5].GetUInt32();
newmember.name = fields[6].GetString();
newmember.Class = fields[7].GetUInt8();
newmember.personal_rating = personalrating;
newmember.matchmaker_rating = matchmakerrating;
//check if member exists in characters table
if (newmember.name.empty())
{
sLog.outErrorDb("ArenaTeam %u has member with empty name - probably player %u doesn't exist, deleting him from memberlist!", arenaTeamId, GUID_LOPART(newmember.guid));
this->DelMember(newmember.guid);
continue;
}
if (newmember.guid == GetCaptain())
captainPresentInTeam = true;
m_members.push_back(newmember);
}while (arenaTeamMembersResult->NextRow());
if (Empty() || !captainPresentInTeam)
{
// arena team is empty or captain is not in team, delete from db
sLog.outErrorDb("ArenaTeam %u does not have any members or its captain is not in team, disbanding it...", m_TeamId);
return false;
}
return true;
}
void GuildMgr::LoadGuilds()
{
// 1. Load all guilds
sLog->outString("Loading Guilds...");
{
uint32 oldMSTime = getMSTime();
// 0 1 2 3 4 5 6
QueryResult result = CharacterDatabase.Query("SELECT g.guildid, g.name, g.leaderguid, g.EmblemStyle, g.EmblemColor, g.BorderStyle, g.BorderColor, "
// 7 8 9 10 11 12 13 14 15
"g.BackgroundColor, g.info, g.motd, g.createdate, g.BankMoney, COUNT(gbt.guildid), xp, level, m_today_xp, m_xp_cap "
"FROM guild g LEFT JOIN guild_bank_tab gbt ON g.guildid = gbt.guildid GROUP BY g.guildid ORDER BY g.guildid ASC");
if (!result)
{
sLog->outString(">> Loaded 0 Guilds. DB table `guild` is empty.");
sLog->outString();
return;
}
else
{
uint32 count = 0;
do
{
Field* fields = result->Fetch();
Guild* guild = new Guild();
if (!guild->LoadFromDB(fields))
{
delete guild;
continue;
}
QueryResult guildNews = CharacterDatabase.PQuery("SELECT type, date, value1, value2, source_guid, flags FROM guild_news WHERE guildid = %u ORDER BY date DESC", guild->GetId());
if (guildNews)
{
Field* fields = guildNews->Fetch();
guild->LoadGuildNewsFromDB(fields);
}
AddGuild(guild);
++count;
}
while (result->NextRow());
sLog->outString(">> Loaded %u Guilds in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
sLog->outString();
}
}
// 2. Load all guild ranks
sLog->outString("Loading guild ranks...");
{
uint32 oldMSTime = getMSTime();
// Delete orphaned guild rank entries before loading the valid ones
CharacterDatabase.DirectExecute("DELETE gr FROM guild_rank gr LEFT JOIN guild g ON gr.guildId = g.guildId WHERE g.guildId IS NULL");
// 0 1 2 3 4
QueryResult result = CharacterDatabase.Query("SELECT guildid, rid, rname, rights, BankMoneyPerDay FROM guild_rank ORDER BY guildid ASC, rid ASC");
if (!result)
{
sLog->outString(">> Loaded 0 guild ranks. DB table `guild_rank` is empty.");
sLog->outString();
}
else
{
uint32 count = 0;
do
{
Field* fields = result->Fetch();
uint32 guildId = fields[0].GetUInt32();
if (Guild* guild = GetGuildById(guildId))
guild->LoadRankFromDB(fields);
++count;
}
while (result->NextRow());
sLog->outString(">> Loaded %u guild ranks in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
sLog->outString();
}
}
// 3. Load all guild members
sLog->outString("Loading guild members...");
{
uint32 oldMSTime = getMSTime();
// Delete orphaned guild member entries before loading the valid ones
CharacterDatabase.DirectExecute("DELETE gm FROM guild_member gm LEFT JOIN guild g ON gm.guildId = g.guildId WHERE g.guildId IS NULL");
// 0 1 2 3 4 5 6
QueryResult result = CharacterDatabase.Query("SELECT guildid, gm.guid, rank, pnote, offnote, BankResetTimeMoney, BankRemMoney, "
// 7 8 9 10 11 12
"BankResetTimeTab0, BankRemSlotsTab0, BankResetTimeTab1, BankRemSlotsTab1, BankResetTimeTab2, BankRemSlotsTab2, "
// 13 14 15 16 17 18
"BankResetTimeTab3, BankRemSlotsTab3, BankResetTimeTab4, BankRemSlotsTab4, BankResetTimeTab5, BankRemSlotsTab5, "
// 19 20 21 22
"BankResetTimeTab6, BankRemSlotsTab6, BankResetTimeTab7, BankRemSlotsTab7, "
// 23 24 25 26 27 28 29 30 31 32 33 34
"c.name, c.level, c.class, c.zone, c.account, c.logout_time, FirstProffLevel, FirstProffSkill, FirstProffRank, SecondProffLevel, SecondProffSkill, SecondProffRank "
"FROM guild_member gm LEFT JOIN characters c ON c.guid = gm.guid ORDER BY guildid ASC");
if (!result)
{
sLog->outString(">> Loaded 0 guild members. DB table `guild_member` is empty.");
sLog->outString();
}
else
{
uint32 count = 0;
do
{
Field* fields = result->Fetch();
uint32 guildId = fields[0].GetUInt32();
if (Guild* guild = GetGuildById(guildId))
guild->LoadMemberFromDB(fields);
++count;
}
while (result->NextRow());
sLog->outString(">> Loaded %u guild members int %u ms", count, GetMSTimeDiffToNow(oldMSTime));
sLog->outString();
}
}
// 4. Load all guild bank tab rights
sLog->outString("Loading bank tab rights...");
{
uint32 oldMSTime = getMSTime();
// Delete orphaned guild bank right entries before loading the valid ones
CharacterDatabase.DirectExecute("DELETE gbr FROM guild_bank_right gbr LEFT JOIN guild g ON gbr.guildId = g.guildId WHERE g.guildId IS NULL");
// 0 1 2 3 4
QueryResult result = CharacterDatabase.Query("SELECT guildid, TabId, rid, gbright, SlotPerDay FROM guild_bank_right ORDER BY guildid ASC, TabId ASC");
if (!result)
{
sLog->outString(">> Loaded 0 guild bank tab rights. DB table `guild_bank_right` is empty.");
sLog->outString();
}
else
{
uint32 count = 0;
do
{
Field* fields = result->Fetch();
uint32 guildId = fields[0].GetUInt32();
if (Guild* guild = GetGuildById(guildId))
guild->LoadBankRightFromDB(fields);
++count;
}
while (result->NextRow());
sLog->outString(">> Loaded %u bank tab rights in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
sLog->outString();
}
}
// 5. Load all event logs
sLog->outString("Loading guild event logs...");
{
uint32 oldMSTime = getMSTime();
CharacterDatabase.DirectPExecute("DELETE FROM guild_eventlog WHERE LogGuid > %u", sWorld->getIntConfig(CONFIG_GUILD_EVENT_LOG_COUNT));
// 0 1 2 3 4 5 6
QueryResult result = CharacterDatabase.Query("SELECT guildid, LogGuid, EventType, PlayerGuid1, PlayerGuid2, NewRank, TimeStamp FROM guild_eventlog ORDER BY TimeStamp DESC, LogGuid DESC");
if (!result)
{
sLog->outString(">> Loaded 0 guild event logs. DB table `guild_eventlog` is empty.");
sLog->outString();
}
else
{
uint32 count = 0;
do
{
Field* fields = result->Fetch();
uint32 guildId = fields[0].GetUInt32();
if (Guild* guild = GetGuildById(guildId))
guild->LoadEventLogFromDB(fields);
++count;
}
while (result->NextRow());
sLog->outString(">> Loaded %u guild event logs in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
sLog->outString();
}
}
// 6. Load all bank event logs
sLog->outString("Loading guild bank event logs...");
{
uint32 oldMSTime = getMSTime();
// Remove log entries that exceed the number of allowed entries per guild
CharacterDatabase.DirectPExecute("DELETE FROM guild_bank_eventlog WHERE LogGuid > %u", sWorld->getIntConfig(CONFIG_GUILD_BANK_EVENT_LOG_COUNT));
// 0 1 2 3 4 5 6 7 8
QueryResult result = CharacterDatabase.Query("SELECT guildid, TabId, LogGuid, EventType, PlayerGuid, ItemOrMoney, ItemStackCount, DestTabId, TimeStamp FROM guild_bank_eventlog ORDER BY TimeStamp DESC, LogGuid DESC");
if (!result)
{
sLog->outString(">> Loaded 0 guild bank event logs. DB table `guild_bank_eventlog` is empty.");
sLog->outString();
}
else
{
uint32 count = 0;
do
{
Field* fields = result->Fetch();
uint32 guildId = fields[0].GetUInt32();
if (Guild* guild = GetGuildById(guildId))
guild->LoadBankEventLogFromDB(fields);
++count;
}
while (result->NextRow());
sLog->outString(">> Loaded %u guild bank event logs in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
sLog->outString();
}
}
// 7. Load all guild bank tabs
sLog->outString("Loading guild bank tabs...");
{
uint32 oldMSTime = getMSTime();
// Delete orphaned guild bank tab entries before loading the valid ones
CharacterDatabase.DirectExecute("DELETE gbt FROM guild_bank_tab gbt LEFT JOIN guild g ON gbt.guildId = g.guildId WHERE g.guildId IS NULL");
// 0 1 2 3 4
QueryResult result = CharacterDatabase.Query("SELECT guildid, TabId, TabName, TabIcon, TabText FROM guild_bank_tab ORDER BY guildid ASC, TabId ASC");
if (!result)
{
sLog->outString(">> Loaded 0 guild bank tabs. DB table `guild_bank_tab` is empty.");
sLog->outString();
}
else
{
uint32 count = 0;
do
{
Field* fields = result->Fetch();
uint32 guildId = fields[0].GetUInt32();
if (Guild* guild = GetGuildById(guildId))
guild->LoadBankTabFromDB(fields);
++count;
}
while (result->NextRow());
sLog->outString(">> Loaded %u guild bank tabs in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
sLog->outString();
}
}
// 8. Fill all guild bank tabs
sLog->outString("Filling bank tabs with items...");
{
uint32 oldMSTime = getMSTime();
// Delete orphan guild bank items
CharacterDatabase.DirectExecute("DELETE gbi FROM guild_bank_item gbi LEFT JOIN guild g ON gbi.guildId = g.guildId WHERE g.guildId IS NULL");
// 0 1 2 3 4 5 6 7 8 9 10
QueryResult result = CharacterDatabase.Query("SELECT creatorGuid, giftCreatorGuid, count, duration, charges, flags, enchantments, randomPropertyId, durability, playedTime, text, "
// 11 12 13 14 15
"guildid, TabId, SlotId, item_guid, itemEntry FROM guild_bank_item gbi INNER JOIN item_instance ii ON gbi.item_guid = ii.guid");
if (!result)
{
sLog->outString(">> Loaded 0 guild bank tab items. DB table `guild_bank_item` or `item_instance` is empty.");
sLog->outString();
}
else
{
uint32 count = 0;
do
{
Field* fields = result->Fetch();
uint32 guildId = fields[11].GetUInt32();
if (Guild* guild = GetGuildById(guildId))
guild->LoadBankItemFromDB(fields);
++count;
}
while (result->NextRow());
sLog->outString(">> Loaded %u guild bank tab items in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
sLog->outString();
}
}
// 9. Validate loaded guild data
sLog->outString("Validating data of loaded guilds...");
{
uint32 oldMSTime = getMSTime();
std::set<Guild*> rm; // temporary storage to avoid modifying GuildStore with RemoveGuild() while iterating
for (GuildContainer::iterator itr = GuildStore.begin(); itr != GuildStore.end(); ++itr)
{
Guild* guild = itr->second;
if (guild && !guild->Validate())
rm.insert(guild);
}
for (std::set<Guild*>::iterator itr = rm.begin(); itr != rm.end(); ++itr)
{
Guild* guild = *itr;
RemoveGuild(guild->GetId());
delete guild;
}
sLog->outString(">> Validated data of loaded guilds in %u ms", GetMSTimeDiffToNow(oldMSTime));
sLog->outString();
}
}
bool Master::CheckDBVersion()
{
QueryResult* wqr = WorldDatabase.QueryNA( "SELECT LastUpdate FROM world_db_version;" );
if(wqr == NULL)
{
Log.Error("Database", "World database is missing the table `world_db_version` OR the table doesn't contain any rows. Can't validate database version. Exiting.");
Log.Error( "Database","You may need to update your database" );
return false;
}
Field* f = wqr->Fetch();
const char *WorldDBVersion = f->GetString();
Log.Notice("Database", "Last world database update: %s", WorldDBVersion);
int result = strcmp( WorldDBVersion, REQUIRED_WORLD_DB_VERSION );
if( result != 0 )
{
Log.Error("Database", "Last world database update doesn't match the required one which is %s.", REQUIRED_WORLD_DB_VERSION);
if( result < 0 ){
Log.Error("Database", "You need to apply the world update queries that are newer than %s. Exiting.", WorldDBVersion);
Log.Error( "Database", "You can find the world update queries in the sql/world_updates sub-directory of your ArcPro source directory." );
}else
Log.Error("Database", "Your world database is probably too new for this ArcPro version, you need to update your server. Exiting.");
delete wqr;
return false;
}
delete wqr;
QueryResult* cqr = CharacterDatabase.QueryNA( "SELECT LastUpdate FROM character_db_version;" );
if(cqr == NULL)
{
Log.Error("Database", "Character database is missing the table `character_db_version` OR the table doesn't contain any rows. Can't validate database version. Exiting.");
Log.Error( "Database","You may need to update your database" );
return false;
}
f = cqr->Fetch();
const char *CharDBVersion = f->GetString();
Log.Notice("Database", "Last character database update: %s", CharDBVersion);
result = strcmp( CharDBVersion, REQUIRED_CHAR_DB_VERSION );
if( result != 0 )
{
Log.Error("Database", "Last character database update doesn't match the required one which is %s.", REQUIRED_CHAR_DB_VERSION);
if( result < 0 ){
Log.Error("Database", "You need to apply the character update queries that are newer than %s. Exiting.", CharDBVersion);
Log.Error( "Database", "You can find the character update queries in the sql/character_updates sub-directory of your ArcPro source directory." );
}else
Log.Error("Database", "Your character database is too new for this ArcPro version, you need to update your server. Exiting.");
delete cqr;
return false;
}
delete cqr;
Log.Success("Database", "Database successfully validated.");
return true;
}
void Map::LoadSpawns(bool reload)
{
//uint32 st=getMSTime();
CreatureSpawnCount = 0;
if ( reload )//perform cleanup
for ( uint32 x = 0; x < _sizeX; x++ )
for ( uint32 y = 0; y < _sizeY; y++ )
if ( spawns[x][y])
{
CellSpawns * sp = spawns[x][y];
for ( CreatureSpawnList::iterator i = sp->CreatureSpawns.begin(); i != sp->CreatureSpawns.end(); i++ )
delete (*i);
for ( GOSpawnList::iterator it = sp->GOSpawns.begin(); it != sp->GOSpawns.end(); it++ )
delete (*it);
delete sp;
spawns[x][y] = NULL;
}
QueryResult * result;
set<string>::iterator tableiterator;
for(tableiterator=ExtraMapCreatureTables.begin(); tableiterator!=ExtraMapCreatureTables.end();++tableiterator)
{
result = WorldDatabase.Query("SELECT * FROM %s WHERE Map = %u",(*tableiterator).c_str(),this->_mapId);
if(result)
{
if(CheckResultLengthCreatures( result) )
{
do{
Field * fields = result->Fetch();
CreatureSpawn * cspawn = new CreatureSpawn;
cspawn->id = fields[0].GetUInt32();
cspawn->form = FormationMgr::getSingleton().GetFormation(cspawn->id);
cspawn->entry = fields[1].GetUInt32();
cspawn->x = fields[3].GetFloat();
cspawn->y = fields[4].GetFloat();
cspawn->z = fields[5].GetFloat();
cspawn->o = fields[6].GetFloat();
/*uint32 cellx=float2int32(((_maxX-cspawn->x)/_cellSize));
uint32 celly=float2int32(((_maxY-cspawn->y)/_cellSize));*/
uint32 cellx=CellHandler<MapMgr>::GetPosX(cspawn->x);
uint32 celly=CellHandler<MapMgr>::GetPosY(cspawn->y);
if(spawns[cellx]== NULL)
{
spawns[cellx]=new CellSpawns*[_sizeY];
memset(spawns[cellx],0,sizeof(CellSpawns*)*_sizeY);
}
if(!spawns[cellx][celly])
spawns[cellx][celly]=new CellSpawns;
cspawn->movetype = fields[7].GetUInt8();
cspawn->displayid = fields[8].GetUInt32();
cspawn->factionid = fields[9].GetUInt32();
cspawn->flags = fields[10].GetUInt32();
cspawn->bytes0 = fields[11].GetUInt32();
cspawn->bytes1 = fields[12].GetUInt32();
cspawn->bytes2 = fields[13].GetUInt32();
cspawn->emote_state = fields[14].GetUInt32();
//cspawn->respawnNpcLink = fields[15].GetUInt32();
cspawn->channel_spell = fields[16].GetUInt16();
cspawn->channel_target_go = fields[17].GetUInt32();
cspawn->channel_target_creature = fields[18].GetUInt32();
cspawn->stand_state = fields[19].GetUInt16();
cspawn->MountedDisplayID = fields[20].GetUInt32();
cspawn->Item1SlotDisplay = fields[21].GetUInt32();
cspawn->Item2SlotDisplay = fields[22].GetUInt32();
cspawn->Item3SlotDisplay = fields[23].GetUInt32();
cspawn->CanFly = fields[24].GetUInt32();
cspawn->phase = fields[25].GetUInt32();
if( cspawn->phase == 0 ) cspawn->phase= 0xFFFFFFFF;
spawns[cellx][celly]->CreatureSpawns.push_back(cspawn);
++CreatureSpawnCount;
}while(result->NextRow());
}
delete result;
}
}
result = WorldDatabase.Query("SELECT * FROM creature_staticspawns WHERE Map = %u",this->_mapId);
if(result)
{
if( CheckResultLengthCreatures(result) )
{
do{
Field * fields = result->Fetch();
CreatureSpawn * cspawn = new CreatureSpawn;
cspawn->id = fields[0].GetUInt32();
cspawn->form = FormationMgr::getSingleton().GetFormation(cspawn->id);
cspawn->entry = fields[1].GetUInt32();
cspawn->x = fields[3].GetFloat();
cspawn->y = fields[4].GetFloat();
cspawn->z = fields[5].GetFloat();
cspawn->o = fields[6].GetFloat();
cspawn->movetype = fields[7].GetUInt8();
cspawn->displayid = fields[8].GetUInt32();
cspawn->factionid = fields[9].GetUInt32();
cspawn->flags = fields[10].GetUInt32();
cspawn->bytes0 = fields[11].GetUInt32();
cspawn->bytes1 = fields[12].GetUInt32();
cspawn->bytes2 = fields[13].GetUInt32();
cspawn->emote_state = fields[14].GetUInt32();
//cspawn->respawnNpcLink = fields[15].GetUInt32();
cspawn->channel_spell= 0;
cspawn->channel_target_creature= 0;
cspawn->channel_target_go= 0;
cspawn->stand_state = fields[19].GetUInt16();
cspawn->MountedDisplayID = fields[20].GetUInt32();
cspawn->Item1SlotDisplay = fields[21].GetUInt32();
cspawn->Item2SlotDisplay = fields[22].GetUInt32();
cspawn->Item3SlotDisplay = fields[23].GetUInt32();
cspawn->CanFly = fields[24].GetUInt32();
cspawn->phase = fields[25].GetUInt32();
if( cspawn->phase == 0 ) cspawn->phase= 0xFFFFFFFF;
staticSpawns.CreatureSpawns.push_back(cspawn);
++CreatureSpawnCount;
}while(result->NextRow());
}
delete result;
}
GameObjectSpawnCount = 0;
result = WorldDatabase.Query("SELECT * FROM gameobject_staticspawns WHERE Map = %u",this->_mapId);
if(result)
{
if( CheckResultLengthGameObject(result) )
{
do{
Field * fields = result->Fetch();
GOSpawn * gspawn = new GOSpawn;
gspawn->entry = fields[1].GetUInt32();
gspawn->id = fields[0].GetUInt32();
gspawn->x=fields[3].GetFloat();
gspawn->y=fields[4].GetFloat();
gspawn->z=fields[5].GetFloat();
gspawn->facing=fields[6].GetFloat();
gspawn->o =fields[7].GetFloat();
gspawn->o1=fields[8].GetFloat();
gspawn->o2=fields[9].GetFloat();
gspawn->o3=fields[10].GetFloat();
gspawn->state=fields[11].GetUInt32();
gspawn->flags=fields[12].GetUInt32();
gspawn->faction=fields[13].GetUInt32();
gspawn->scale = fields[14].GetFloat();
//gspawn->stateNpcLink = fields[15].GetUInt32();
gspawn->phase = fields[16].GetUInt32();
if( gspawn->phase == 0 ) gspawn->phase= 0xFFFFFFFF;
gspawn->overrides = fields[17].GetUInt32();
staticSpawns.GOSpawns.push_back(gspawn);
++GameObjectSpawnCount;
}while(result->NextRow());
}
delete result;
}
for(tableiterator=ExtraMapGameObjectTables.begin(); tableiterator!=ExtraMapGameObjectTables.end();++tableiterator)
{
result = WorldDatabase.Query("SELECT * FROM %s WHERE map = %u",(*tableiterator).c_str(),this->_mapId);
if(result)
{
if( CheckResultLengthGameObject(result) )
{
do{
Field * fields = result->Fetch();
GOSpawn * gspawn = new GOSpawn;
gspawn->entry = fields[1].GetUInt32();
gspawn->id = fields[0].GetUInt32();
gspawn->x=fields[3].GetFloat();
gspawn->y=fields[4].GetFloat();
gspawn->z=fields[5].GetFloat();
gspawn->facing=fields[6].GetFloat();
gspawn->o =fields[7].GetFloat();
gspawn->o1=fields[8].GetFloat();
gspawn->o2=fields[9].GetFloat();
gspawn->o3=fields[10].GetFloat();
gspawn->state=fields[11].GetUInt32();
gspawn->flags=fields[12].GetUInt32();
gspawn->faction=fields[13].GetUInt32();
gspawn->scale = fields[14].GetFloat();
//gspawn->stateNpcLink = fields[15].GetUInt32();
gspawn->phase = fields[16].GetUInt32();
if( gspawn->phase == 0 ) gspawn->phase= 0xFFFFFFFF;
gspawn->overrides = fields[17].GetUInt32();
if( gspawn->overrides & GAMEOBJECT_MAPWIDE )
{
staticSpawns.GOSpawns.push_back(gspawn); //We already have a staticSpawns in the Map class, and it does just the right thing
++GameObjectSpawnCount;
}
else
{
//uint32 cellx=float2int32(((_maxX-gspawn->x)/_cellSize));
//uint32 celly=float2int32(((_maxY-gspawn->y)/_cellSize));
uint32 cellx=CellHandler<MapMgr>::GetPosX(gspawn->x);
uint32 celly=CellHandler<MapMgr>::GetPosY(gspawn->y);
if(spawns[cellx]== NULL)
{
spawns[cellx]=new CellSpawns*[_sizeY];
memset(spawns[cellx],0,sizeof(CellSpawns*)*_sizeY);
}
if(!spawns[cellx][celly])
spawns[cellx][celly]=new CellSpawns;
spawns[cellx][celly]->GOSpawns.push_back(gspawn);
++GameObjectSpawnCount;
}
}while(result->NextRow());
}
delete result;
}
}
Log.Notice("Map", "%u creatures / %u gameobjects on map %u cached.", CreatureSpawnCount, GameObjectSpawnCount, _mapId);
}
void WorldSession::HandleSendMail(WorldPacket & recv_data )
{
CHECK_PACKET_SIZE(recv_data,8+1+1+1+4+4+1+4+4+8+1);
uint64 mailbox, unk3;
std::string receiver, subject, body;
uint32 unk1, unk2, money, COD;
uint8 unk4;
recv_data >> mailbox;
recv_data >> receiver;
if (!GetPlayer()->GetGameObjectIfCanInteractWith(mailbox, GAMEOBJECT_TYPE_MAILBOX))
return;
// recheck
CHECK_PACKET_SIZE(recv_data, 8+(receiver.size()+1)+1+1+4+4+1+4+4+8+1);
recv_data >> subject;
// recheck
CHECK_PACKET_SIZE(recv_data, 8+(receiver.size()+1)+(subject.size()+1)+1+4+4+1+4+4+8+1);
recv_data >> body;
// recheck
CHECK_PACKET_SIZE(recv_data, 8+(receiver.size()+1)+(subject.size()+1)+(body.size()+1)+4+4+1+4+4+8+1);
recv_data >> unk1; // stationery?
recv_data >> unk2; // 0x00000000
MailItemsInfo mi;
uint8 items_count;
recv_data >> items_count; // attached items count
if(items_count > 12) // client limit
return;
// recheck
CHECK_PACKET_SIZE(recv_data, 8+(receiver.size()+1)+(subject.size()+1)+(body.size()+1)+4+4+1+items_count*(1+8)+4+4+8+1);
if(items_count)
{
for(uint8 i = 0; i < items_count; ++i)
{
uint8 item_slot;
uint64 item_guid;
recv_data >> item_slot;
recv_data >> item_guid;
mi.AddItem(GUID_LOPART(item_guid), item_slot);
}
}
recv_data >> money >> COD; // money and cod
recv_data >> unk3; // const 0
recv_data >> unk4; // const 0
items_count = mi.size(); // this is the real size after the duplicates have been removed
if (receiver.empty())
return;
Player* pl = _player;
uint64 rc = 0;
if(normalizePlayerName(receiver))
rc = objmgr.GetPlayerGUIDByName(receiver);
if (!rc)
{
sLog.outDetail("Player %u is sending mail to %s (GUID: not existed!) with subject %s and body %s includes %u items, %u copper and %u COD copper with unk1 = %u, unk2 = %u",
pl->GetGUIDLow(), receiver.c_str(), subject.c_str(), body.c_str(), items_count, money, COD, unk1, unk2);
pl->SendMailResult(0, 0, MAIL_ERR_RECIPIENT_NOT_FOUND);
return;
}
sLog.outDetail("Player %u is sending mail to %s (GUID: %u) with subject %s and body %s includes %u items, %u copper and %u COD copper with unk1 = %u, unk2 = %u", pl->GetGUIDLow(), receiver.c_str(), GUID_LOPART(rc), subject.c_str(), body.c_str(), items_count, money, COD, unk1, unk2);
if(pl->GetGUID() == rc)
{
pl->SendMailResult(0, 0, MAIL_ERR_CANNOT_SEND_TO_SELF);
return;
}
uint32 cost = items_count ? 30 * items_count : 30; // price hardcoded in client
uint32 reqmoney = cost + money;
if (pl->GetMoney() < reqmoney)
{
pl->SendMailResult(0, 0, MAIL_ERR_NOT_ENOUGH_MONEY);
return;
}
Player *receive = objmgr.GetPlayer(rc);
uint32 rc_team = 0;
uint8 mails_count = 0; //do not allow to send to one player more than 100 mails
if(receive)
{
rc_team = receive->GetTeam();
mails_count = receive->GetMailSize();
}
else
{
rc_team = objmgr.GetPlayerTeamByGUID(rc);
QueryResult* result = CharacterDatabase.PQuery("SELECT COUNT(*) FROM mail WHERE receiver = '%u'", GUID_LOPART(rc));
if(result)
{
Field *fields = result->Fetch();
mails_count = fields[0].GetUInt32();
delete result;
}
}
//do not allow to have more than 100 mails in mailbox.. mails count is in opcode uint8!!! - so max can be 255..
if (mails_count > 100)
{
pl->SendMailResult(0, 0, MAIL_ERR_INTERNAL_ERROR);
return;
}
// test the receiver's Faction...
if (!sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_MAIL) && pl->GetTeam() != rc_team && GetSecurity() == SEC_PLAYER)
{
pl->SendMailResult(0, 0, MAIL_ERR_NOT_YOUR_TEAM);
return;
}
if (items_count)
{
for(MailItemMap::iterator mailItemIter = mi.begin(); mailItemIter != mi.end(); ++mailItemIter)
{
MailItem& mailItem = mailItemIter->second;
if(!mailItem.item_guidlow)
{
pl->SendMailResult(0, 0, MAIL_ERR_INTERNAL_ERROR);
return;
}
mailItem.item = pl->GetItemByGuid(MAKE_NEW_GUID(mailItem.item_guidlow, 0, HIGHGUID_ITEM));
// prevent sending bag with items (cheat: can be placed in bag after adding equipped empty bag to mail)
if(!mailItem.item || !mailItem.item->CanBeTraded())
{
pl->SendMailResult(0, 0, MAIL_ERR_INTERNAL_ERROR);
return;
}
if (mailItem.item->HasFlag(ITEM_FIELD_FLAGS, ITEM_FLAGS_CONJURED) || mailItem.item->GetUInt32Value(ITEM_FIELD_DURATION))
{
pl->SendMailResult(0, 0, MAIL_ERR_INTERNAL_ERROR);
return;
}
if(COD && mailItem.item->HasFlag(ITEM_FIELD_FLAGS, ITEM_FLAGS_WRAPPED))
{
pl->SendMailResult(0, 0, MAIL_ERR_CANT_SEND_WRAPPED_COD);
return;
}
}
}
pl->SendMailResult(0, 0, MAIL_OK);
uint32 itemTextId = 0;
if (!body.empty())
{
itemTextId = objmgr.CreateItemText( body );
}
pl->ModifyMoney( -int32(reqmoney) );
pl->GetAchievementMgr().UpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_GOLD_SPENT_FOR_MAIL, cost);
bool needItemDelay = false;
if(items_count > 0 || money > 0)
{
uint32 rc_account = 0;
if(receive)
rc_account = receive->GetSession()->GetAccountId();
else
rc_account = objmgr.GetPlayerAccountIdByGUID(rc);
if (items_count > 0)
{
for(MailItemMap::iterator mailItemIter = mi.begin(); mailItemIter != mi.end(); ++mailItemIter)
{
MailItem& mailItem = mailItemIter->second;
if(!mailItem.item)
continue;
mailItem.item_template = mailItem.item ? mailItem.item->GetEntry() : 0;
if( GetSecurity() > SEC_PLAYER && sWorld.getConfig(CONFIG_GM_LOG_TRADE) )
{
sLog.outCommand(GetAccountId(), "GM %s (Account: %u) mail item: %s (Entry: %u Count: %u) to player: %s (Account: %u)",
GetPlayerName(), GetAccountId(), mailItem.item->GetProto()->Name1, mailItem.item->GetEntry(), mailItem.item->GetCount(), receiver.c_str(), rc_account);
}
pl->MoveItemFromInventory(mailItem.item->GetBagSlot(), mailItem.item->GetSlot(), true);
CharacterDatabase.BeginTransaction();
mailItem.item->DeleteFromInventoryDB(); //deletes item from character's inventory
mailItem.item->SaveToDB(); // recursive and not have transaction guard into self, item not in inventory and can be save standalone
// owner in data will set at mail receive and item extracting
CharacterDatabase.PExecute("UPDATE item_instance SET owner_guid = '%u' WHERE guid='%u'", GUID_LOPART(rc), mailItem.item->GetGUIDLow());
CharacterDatabase.CommitTransaction();
}
// if item send to character at another account, then apply item delivery delay
needItemDelay = pl->GetSession()->GetAccountId() != rc_account;
}
if(money > 0 && GetSecurity() > SEC_PLAYER && sWorld.getConfig(CONFIG_GM_LOG_TRADE))
{
sLog.outCommand(GetAccountId(),"GM %s (Account: %u) mail money: %u to player: %s (Account: %u)",
GetPlayerName(), GetAccountId(), money, receiver.c_str(), rc_account);
}
}
// If theres is an item, there is a one hour delivery delay if sent to another account's character.
uint32 deliver_delay = needItemDelay ? sWorld.getConfig(CONFIG_MAIL_DELIVERY_DELAY) : 0;
// will delete item or place to receiver mail list
WorldSession::SendMailTo(receive, MAIL_NORMAL, MAIL_STATIONERY_NORMAL, pl->GetGUIDLow(), GUID_LOPART(rc), subject, itemTextId, &mi, money, COD, MAIL_CHECK_MASK_NONE, deliver_delay);
CharacterDatabase.BeginTransaction();
pl->SaveInventoryAndGoldToDB();
CharacterDatabase.CommitTransaction();
}
void AccountMgr::ReloadAccounts(bool silent)
{
setBusy.Acquire();
if(!silent) sLog.outString("[AccountMgr] Reloading Accounts...");
// Load *all* accounts.
QueryResult * result = sLogonSQL->Query("SELECT acct, login, password, encrypted_password, gm, flags, banned, forceLanguage, muted FROM accounts");
Field * field;
string AccountName;
set<string> account_list;
Account * acct;
if(result)
{
do
{
field = result->Fetch();
AccountName = field[1].GetString();
// transform to uppercase
ASCENT_TOUPPER(AccountName);
//Use private __GetAccount, for locks
acct = __GetAccount(AccountName);
if(acct == 0)
{
// New account.
AddAccount(field);
}
else
{
// Update the account with possible changed details.
UpdateAccount(acct, field);
}
// add to our "known" list
account_list.insert(AccountName);
} while(result->NextRow());
delete result;
}
// check for any purged/deleted accounts
#ifdef WIN32
HM_NAMESPACE::hash_map<string, Account*>::iterator itr = AccountDatabase.begin();
HM_NAMESPACE::hash_map<string, Account*>::iterator it2;
#else
std::map<string, Account*>::iterator itr = AccountDatabase.begin();
std::map<string, Account*>::iterator it2;
#endif
for(; itr != AccountDatabase.end();)
{
it2 = itr;
++itr;
if(account_list.find(it2->first) == account_list.end())
{
delete it2->second;
AccountDatabase.erase(it2);
}
else
{
it2->second->UsernamePtr = (std::string*)&it2->first;
}
}
if(!silent) sLog.outString("[AccountMgr] Found %u accounts.", AccountDatabase.size());
setBusy.Release();
IPBanner::getSingleton().Reload();
}
void WorldSession::HandleCharCreateOpcode( WorldPacket & recv_data )
{
std::string name;
uint8 race_,class_;
recv_data >> name;
recv_data >> race_;
recv_data >> class_;
WorldPacket data(SMSG_CHAR_CREATE, 1); // returned with diff.values in all cases
if(GetSecurity() == SEC_PLAYER)
{
if(uint32 mask = sWorld.getConfig(CONFIG_CHARACTERS_CREATING_DISABLED))
{
bool disabled = false;
uint32 team = Player::TeamForRace(race_);
switch(team)
{
case ALLIANCE: disabled = mask & (1<<0); break;
case HORDE: disabled = mask & (1<<1); break;
}
if(disabled)
{
data << (uint8)CHAR_CREATE_DISABLED;
SendPacket( &data );
return;
}
}
}
ChrClassesEntry const* classEntry = sChrClassesStore.LookupEntry(class_);
ChrRacesEntry const* raceEntry = sChrRacesStore.LookupEntry(race_);
if( !classEntry || !raceEntry )
{
data << (uint8)CHAR_CREATE_FAILED;
SendPacket( &data );
sLog.outError("Class: %u or Race %u not found in DBC (Wrong DBC files?) or Cheater?", class_, race_);
return;
}
// prevent character creating Expansion race without Expansion account
if (raceEntry->addon > Expansion())
{
data << (uint8)CHAR_CREATE_EXPANSION;
sLog.outError("Expansion %u account:[%d] tried to Create character with expansion %u race (%u)",Expansion(),GetAccountId(),raceEntry->addon,race_);
SendPacket( &data );
return;
}
// prevent character creating Expansion class without Expansion account
if (classEntry->addon > Expansion())
{
data << (uint8)CHAR_CREATE_EXPANSION_CLASS;
sLog.outError("Expansion %u account:[%d] tried to Create character with expansion %u class (%u)",Expansion(),GetAccountId(),classEntry->addon,class_);
SendPacket( &data );
return;
}
// prevent character creating with invalid name
if (!normalizePlayerName(name))
{
data << (uint8)CHAR_NAME_NO_NAME;
SendPacket( &data );
sLog.outError("Account:[%d] but tried to Create character with empty [name] ",GetAccountId());
return;
}
// check name limitations
uint8 res = ObjectMgr::CheckPlayerName(name,true);
if (res != CHAR_NAME_SUCCESS)
{
data << uint8(res);
SendPacket( &data );
return;
}
if (GetSecurity() == SEC_PLAYER && objmgr.IsReservedName(name))
{
data << (uint8)CHAR_NAME_RESERVED;
SendPacket( &data );
return;
}
if (objmgr.GetPlayerGUIDByName(name))
{
data << (uint8)CHAR_CREATE_NAME_IN_USE;
SendPacket( &data );
return;
}
QueryResult *resultacct = loginDatabase.PQuery("SELECT SUM(numchars) FROM realmcharacters WHERE acctid = '%d'", GetAccountId());
if (resultacct)
{
Field *fields=resultacct->Fetch();
uint32 acctcharcount = fields[0].GetUInt32();
delete resultacct;
if (acctcharcount >= sWorld.getConfig(CONFIG_CHARACTERS_PER_ACCOUNT))
{
data << (uint8)CHAR_CREATE_ACCOUNT_LIMIT;
SendPacket( &data );
return;
}
}
QueryResult *result = CharacterDatabase.PQuery("SELECT COUNT(guid) FROM characters WHERE account = '%d'", GetAccountId());
uint8 charcount = 0;
if ( result )
{
Field *fields=result->Fetch();
charcount = fields[0].GetUInt8();
delete result;
if (charcount >= sWorld.getConfig(CONFIG_CHARACTERS_PER_REALM))
{
data << (uint8)CHAR_CREATE_SERVER_LIMIT;
SendPacket( &data );
return;
}
}
// speedup check for heroic class disabled case
uint32 heroic_free_slots = sWorld.getConfig(CONFIG_HEROIC_CHARACTERS_PER_REALM);
if(heroic_free_slots==0 && GetSecurity()==SEC_PLAYER && class_ == CLASS_DEATH_KNIGHT)
{
data << (uint8)CHAR_CREATE_UNIQUE_CLASS_LIMIT;
SendPacket( &data );
return;
}
// speedup check for heroic class disabled case
uint32 req_level_for_heroic = sWorld.getConfig(CONFIG_MIN_LEVEL_FOR_HEROIC_CHARACTER_CREATING);
if(GetSecurity()==SEC_PLAYER && class_ == CLASS_DEATH_KNIGHT && req_level_for_heroic > sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL))
{
data << (uint8)CHAR_CREATE_LEVEL_REQUIREMENT;
SendPacket( &data );
return;
}
bool AllowTwoSideAccounts = !sWorld.IsPvPRealm() || sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_ACCOUNTS) || GetSecurity() > SEC_PLAYER;
uint32 skipCinematics = sWorld.getConfig(CONFIG_SKIP_CINEMATICS);
bool have_same_race = false;
// if 0 then allowed creating without any characters
bool have_req_level_for_heroic = (req_level_for_heroic==0);
if(!AllowTwoSideAccounts || skipCinematics == 1 || class_ == CLASS_DEATH_KNIGHT)
{
QueryResult *result2 = CharacterDatabase.PQuery("SELECT level,race,class FROM characters WHERE account = '%u' %s",
GetAccountId(), (skipCinematics == 1 || class_ == CLASS_DEATH_KNIGHT) ? "" : "LIMIT 1");
if(result2)
{
uint32 team_= Player::TeamForRace(race_);
Field* field = result2->Fetch();
uint8 acc_race = field[1].GetUInt32();
if(GetSecurity()==SEC_PLAYER && class_ == CLASS_DEATH_KNIGHT)
{
uint8 acc_class = field[2].GetUInt32();
if(acc_class == CLASS_DEATH_KNIGHT)
{
if(heroic_free_slots > 0)
--heroic_free_slots;
if(heroic_free_slots==0)
{
data << (uint8)CHAR_CREATE_UNIQUE_CLASS_LIMIT;
SendPacket( &data );
return;
}
}
if(!have_req_level_for_heroic)
{
uint32 acc_level = field[0].GetUInt32();
if(acc_level >= req_level_for_heroic)
have_req_level_for_heroic = true;
}
}
// need to check team only for first character
// TODO: what to if account already has characters of both races?
if (!AllowTwoSideAccounts)
{
uint32 acc_team=0;
if(acc_race > 0)
acc_team = Player::TeamForRace(acc_race);
if(acc_team != team_)
{
data << (uint8)CHAR_CREATE_PVP_TEAMS_VIOLATION;
SendPacket( &data );
delete result2;
return;
}
}
// search same race for cinematic or same class if need
// TODO: check if cinematic already shown? (already logged in?; cinematic field)
while ((skipCinematics == 1 && !have_same_race) || class_ == CLASS_DEATH_KNIGHT)
{
if(!result2->NextRow())
break;
field = result2->Fetch();
acc_race = field[1].GetUInt32();
if(!have_same_race)
have_same_race = race_ == acc_race;
if(GetSecurity()==SEC_PLAYER && class_ == CLASS_DEATH_KNIGHT)
{
uint8 acc_class = field[2].GetUInt32();
if(acc_class == CLASS_DEATH_KNIGHT)
{
if(heroic_free_slots > 0)
--heroic_free_slots;
if(heroic_free_slots==0)
{
data << (uint8)CHAR_CREATE_UNIQUE_CLASS_LIMIT;
SendPacket( &data );
return;
}
}
if(!have_req_level_for_heroic)
{
uint32 acc_level = field[0].GetUInt32();
if(acc_level >= req_level_for_heroic)
have_req_level_for_heroic = true;
}
}
}
delete result2;
}
}
if(GetSecurity()==SEC_PLAYER && class_ == CLASS_DEATH_KNIGHT && !have_req_level_for_heroic)
{
data << (uint8)CHAR_CREATE_LEVEL_REQUIREMENT;
SendPacket( &data );
return;
}
// extract other data required for player creating
uint8 gender, skin, face, hairStyle, hairColor, facialHair, outfitId;
recv_data >> gender >> skin >> face;
recv_data >> hairStyle >> hairColor >> facialHair >> outfitId;
Player * pNewChar = new Player(this);
if(!pNewChar->Create( objmgr.GenerateLowGuid(HIGHGUID_PLAYER), name, race_, class_, gender, skin, face, hairStyle, hairColor, facialHair, outfitId ))
{
// Player not create (race/class problem?)
delete pNewChar;
data << (uint8)CHAR_CREATE_ERROR;
SendPacket( &data );
return;
}
if ((have_same_race && skipCinematics == 1) || skipCinematics == 2)
pNewChar->setCinematic(1); // not show intro
// Player created, save it now
pNewChar->SaveToDB();
charcount+=1;
loginDatabase.PExecute("DELETE FROM realmcharacters WHERE acctid= '%d' AND realmid = '%d'", GetAccountId(), realmID);
loginDatabase.PExecute("INSERT INTO realmcharacters (numchars, acctid, realmid) VALUES (%u, %u, %u)", charcount, GetAccountId(), realmID);
delete pNewChar; // created only to call SaveToDB()
data << (uint8)CHAR_CREATE_SUCCESS;
SendPacket( &data );
std::string IP_str = GetRemoteAddress();
sLog.outBasic("Account: %d (IP: %s) Create Character:[%s]",GetAccountId(),IP_str.c_str(),name.c_str());
sLog.outChar("Account: %d (IP: %s) Create Character:[%s]",GetAccountId(),IP_str.c_str(),name.c_str());
}
void WorldSession::HandlePlayerLogin(LoginQueryHolder * holder)
{
uint64 playerGuid = holder->GetGuid();
Player* pCurrChar = new Player(this);
pCurrChar->GetMotionMaster()->Initialize();
// "GetAccountId()==db stored account id" checked in LoadFromDB (prevent login not own character using cheating tools)
if(!pCurrChar->LoadFromDB(GUID_LOPART(playerGuid), holder))
{
KickPlayer(); // disconnect client, player no set to session and it will not deleted or saved at kick
delete pCurrChar; // delete it manually
delete holder; // delete all unprocessed queries
m_playerLoading = false;
return;
}
SetPlayer(pCurrChar);
pCurrChar->SendDungeonDifficulty(false);
WorldPacket data( SMSG_LOGIN_VERIFY_WORLD, 20 );
data << pCurrChar->GetMapId();
data << pCurrChar->GetPositionX();
data << pCurrChar->GetPositionY();
data << pCurrChar->GetPositionZ();
data << pCurrChar->GetOrientation();
SendPacket(&data);
// load player specific part before send times
LoadAccountData(holder->GetResult(PLAYER_LOGIN_QUERY_LOADACCOUNTDATA),PER_CHARACTER_CACHE_MASK);
SendAccountDataTimes();
data.Initialize(SMSG_FEATURE_SYSTEM_STATUS, 2); // added in 2.2.0
data << uint8(2); // unknown value
data << uint8(0); // enable(1)/disable(0) voice chat interface in client
SendPacket(&data);
// Send MOTD
{
data.Initialize(SMSG_MOTD, 50); // new in 2.0.1
data << (uint32)0;
uint32 linecount=0;
std::string str_motd = sWorld.GetMotd();
std::string::size_type pos, nextpos;
pos = 0;
while ( (nextpos= str_motd.find('@',pos)) != std::string::npos )
{
if (nextpos != pos)
{
data << str_motd.substr(pos,nextpos-pos);
++linecount;
}
pos = nextpos+1;
}
if (pos<str_motd.length())
{
data << str_motd.substr(pos);
++linecount;
}
data.put(0, linecount);
SendPacket( &data );
DEBUG_LOG( "WORLD: Sent motd (SMSG_MOTD)" );
}
data.Initialize(SMSG_LEARNED_DANCE_MOVES, 4+4);
data << uint32(0);
data << uint32(0);
SendPacket(&data);
//QueryResult *result = CharacterDatabase.PQuery("SELECT guildid,rank FROM guild_member WHERE guid = '%u'",pCurrChar->GetGUIDLow());
QueryResult *resultGuild = holder->GetResult(PLAYER_LOGIN_QUERY_LOADGUILD);
if(resultGuild)
{
Field *fields = resultGuild->Fetch();
pCurrChar->SetInGuild(fields[0].GetUInt32());
pCurrChar->SetRank(fields[1].GetUInt32());
delete resultGuild;
}
else if(pCurrChar->GetGuildId()) // clear guild related fields in case wrong data about non existed membership
{
pCurrChar->SetInGuild(0);
pCurrChar->SetRank(0);
}
if(pCurrChar->GetGuildId() != 0)
{
Guild* guild = objmgr.GetGuildById(pCurrChar->GetGuildId());
if(guild)
{
data.Initialize(SMSG_GUILD_EVENT, (2+guild->GetMOTD().size()+1));
data << (uint8)GE_MOTD;
data << (uint8)1;
data << guild->GetMOTD();
SendPacket(&data);
DEBUG_LOG( "WORLD: Sent guild-motd (SMSG_GUILD_EVENT)" );
data.Initialize(SMSG_GUILD_EVENT, (5+10)); // we guess size
data<<(uint8)GE_SIGNED_ON;
data<<(uint8)1;
data<<pCurrChar->GetName();
data<<pCurrChar->GetGUID();
guild->BroadcastPacket(&data);
DEBUG_LOG( "WORLD: Sent guild-signed-on (SMSG_GUILD_EVENT)" );
// Increment online members of the guild
guild->IncOnlineMemberCount();
}
else
{
// remove wrong guild data
sLog.outError("Player %s (GUID: %u) marked as member not existed guild (id: %u), removing guild membership for player.",pCurrChar->GetName(),pCurrChar->GetGUIDLow(),pCurrChar->GetGuildId());
pCurrChar->SetInGuild(0);
}
}
if(!pCurrChar->isAlive())
pCurrChar->SendCorpseReclaimDelay(true);
pCurrChar->SendInitialPacketsBeforeAddToMap();
//Show cinematic at the first time that player login
if( !pCurrChar->getCinematic() )
{
pCurrChar->setCinematic(1);
if(ChrClassesEntry const* cEntry = sChrClassesStore.LookupEntry(pCurrChar->getClass()))
{
if (cEntry->CinematicSequence)
pCurrChar->SendCinematicStart(cEntry->CinematicSequence);
else if (ChrRacesEntry const* rEntry = sChrRacesStore.LookupEntry(pCurrChar->getRace()))
pCurrChar->SendCinematicStart(rEntry->CinematicSequence);
}
}
if (!pCurrChar->GetMap()->Add(pCurrChar))
{
AreaTrigger const* at = objmgr.GetGoBackTrigger(pCurrChar->GetMapId());
if(at)
pCurrChar->TeleportTo(at->target_mapId, at->target_X, at->target_Y, at->target_Z, pCurrChar->GetOrientation());
else
pCurrChar->TeleportTo(pCurrChar->m_homebindMapId, pCurrChar->m_homebindX, pCurrChar->m_homebindY, pCurrChar->m_homebindZ, pCurrChar->GetOrientation());
}
ObjectAccessor::Instance().AddObject(pCurrChar);
//sLog.outDebug("Player %s added to Map.",pCurrChar->GetName());
pCurrChar->SendInitialPacketsAfterAddToMap();
CharacterDatabase.PExecute("UPDATE characters SET online = 1 WHERE guid = '%u'", pCurrChar->GetGUIDLow());
loginDatabase.PExecute("UPDATE account SET online = 1 WHERE id = '%u'", GetAccountId());
pCurrChar->SetInGameTime( getMSTime() );
// announce group about member online (must be after add to player list to receive announce to self)
if(Group *group = pCurrChar->GetGroup())
{
//pCurrChar->groupInfo.group->SendInit(this); // useless
group->SendUpdate();
}
// friend status
sSocialMgr.SendFriendStatus(pCurrChar, FRIEND_ONLINE, pCurrChar->GetGUIDLow(), true);
// Place character in world (and load zone) before some object loading
pCurrChar->LoadCorpse();
// setting Ghost+speed if dead
if (pCurrChar->m_deathState != ALIVE)
{
// not blizz like, we must correctly save and load player instead...
if(pCurrChar->getRace() == RACE_NIGHTELF)
pCurrChar->CastSpell(pCurrChar, 20584, true, 0);// auras SPELL_AURA_INCREASE_SPEED(+speed in wisp form), SPELL_AURA_INCREASE_SWIM_SPEED(+swim speed in wisp form), SPELL_AURA_TRANSFORM (to wisp form)
pCurrChar->CastSpell(pCurrChar, 8326, true, 0); // auras SPELL_AURA_GHOST, SPELL_AURA_INCREASE_SPEED(why?), SPELL_AURA_INCREASE_SWIM_SPEED(why?)
pCurrChar->SetMovement(MOVE_WATER_WALK);
}
pCurrChar->ContinueTaxiFlight();
// reset for all pets before pet loading
if(pCurrChar->HasAtLoginFlag(AT_LOGIN_RESET_PET_TALENTS))
Pet::resetTalentsForAllPetsOf(pCurrChar);
// Load pet if any (if player not alive and in taxi flight or another then pet will remember as temporary unsummoned)
pCurrChar->LoadPet();
// Set FFA PvP for non GM in non-rest mode
if(sWorld.IsFFAPvPRealm() && !pCurrChar->isGameMaster() && !pCurrChar->HasFlag(PLAYER_FLAGS,PLAYER_FLAGS_RESTING) )
pCurrChar->SetByteFlag(UNIT_FIELD_BYTES_2, 1, UNIT_BYTE2_FLAG_FFA_PVP);
if(pCurrChar->HasFlag(PLAYER_FLAGS, PLAYER_FLAGS_CONTESTED_PVP))
pCurrChar->SetContestedPvP();
// Apply at_login requests
if(pCurrChar->HasAtLoginFlag(AT_LOGIN_RESET_SPELLS))
{
pCurrChar->resetSpells();
SendNotification(LANG_RESET_SPELLS);
}
if(pCurrChar->HasAtLoginFlag(AT_LOGIN_RESET_TALENTS))
{
pCurrChar->resetTalents(true);
pCurrChar->SendTalentsInfoData(false); // original talents send already in to SendInitialPacketsBeforeAddToMap, resend reset state
SendNotification(LANG_RESET_TALENTS);
}
// show time before shutdown if shutdown planned.
if(sWorld.IsShutdowning())
sWorld.ShutdownMsg(true,pCurrChar);
if(sWorld.getConfig(CONFIG_ALL_TAXI_PATHS))
pCurrChar->SetTaxiCheater(true);
if(pCurrChar->isGameMaster())
SendNotification(LANG_GM_ON);
std::string IP_str = GetRemoteAddress();
sLog.outChar("Account: %d (IP: %s) Login Character:[%s] (guid:%u)",
GetAccountId(),IP_str.c_str(),pCurrChar->GetName() ,pCurrChar->GetGUIDLow());
if(!pCurrChar->IsStandState() && !pCurrChar->hasUnitState(UNIT_STAT_STUNNED))
pCurrChar->SetStandState(UNIT_STAND_STATE_STAND);
m_playerLoading = false;
delete holder;
}
void WorldSession::LoadPlayerFromDBProc(QueryResultVector & results)
{
if(results.size() < 1)
{
uint8 respons = E_CHAR_LOGIN_NO_CHARACTER;
OutPacket(SMSG_CHARACTER_LOGIN_FAILED, 1, &respons);
return;
}
QueryResult* result = results[0].result;
if(! result)
{
Log.Error("WorldSession::LoadPlayerFromDBProc", "Player login query failed!");
uint8 respons = E_CHAR_LOGIN_NO_CHARACTER;
OutPacket(SMSG_CHARACTER_LOGIN_FAILED, 1, &respons);
return;
}
Field* fields = result->Fetch();
uint64 playerGuid = fields[0].GetUInt64();
uint8 _class = fields[1].GetUInt8();
Player* plr = NULL;
switch(_class)
{
case WARRIOR:
plr = new Warrior(playerGuid);
break;
case PALADIN:
plr = new Paladin(playerGuid);
break;
case HUNTER:
plr = new Hunter(playerGuid);
break;
case ROGUE:
plr = new Rogue(playerGuid);
break;
case PRIEST:
plr = new Priest(playerGuid);
break;
case DEATHKNIGHT:
plr = new DeathKnight(playerGuid);
break;
case SHAMAN:
plr = new Shaman(playerGuid);
break;
case MAGE:
plr = new Mage(playerGuid);
break;
case WARLOCK:
plr = new Warlock(playerGuid);
break;
case DRUID:
plr = new Druid(playerGuid);
break;
}
if(plr == NULL)
{
Log.Error("WorldSession::LoadPlayerFromDBProc", "Class %u unknown!", _class);
uint8 respons = E_CHAR_LOGIN_NO_CHARACTER;
OutPacket(SMSG_CHARACTER_LOGIN_FAILED, 1, &respons);
return;
}
plr->SetSession(this);
m_bIsWLevelSet = false;
Log.Debug("WorldSession", "Async loading player %u", (uint32)playerGuid);
m_loggingInPlayer = plr;
plr->LoadFromDB((uint32)playerGuid);
}
void WorldSession::HandleCharCustomize(WorldPacket& recv_data)
{
uint64 guid;
std::string newname;
recv_data >> guid;
recv_data >> newname;
uint8 gender, skin, face, hairStyle, hairColor, facialHair;
recv_data >> gender >> skin >> hairColor >> hairStyle >> facialHair >> face;
QueryResult *result = CharacterDatabase.PQuery("SELECT at_login FROM characters WHERE guid ='%u'", GUID_LOPART(guid));
if (!result)
{
WorldPacket data(SMSG_CHAR_CUSTOMIZE, 1);
data << uint8(CHAR_CREATE_ERROR);
SendPacket( &data );
return;
}
Field *fields = result->Fetch();
uint32 at_loginFlags = fields[0].GetUInt32();
delete result;
if (!(at_loginFlags & AT_LOGIN_CUSTOMIZE))
{
WorldPacket data(SMSG_CHAR_CUSTOMIZE, 1);
data << uint8(CHAR_CREATE_ERROR);
SendPacket( &data );
return;
}
// prevent character rename to invalid name
if (!normalizePlayerName(newname))
{
WorldPacket data(SMSG_CHAR_CUSTOMIZE, 1);
data << uint8(CHAR_NAME_NO_NAME);
SendPacket( &data );
return;
}
uint8 res = ObjectMgr::CheckPlayerName(newname,true);
if (res != CHAR_NAME_SUCCESS)
{
WorldPacket data(SMSG_CHAR_CUSTOMIZE, 1);
data << uint8(res);
SendPacket( &data );
return;
}
// check name limitations
if (GetSecurity() == SEC_PLAYER && objmgr.IsReservedName(newname))
{
WorldPacket data(SMSG_CHAR_CUSTOMIZE, 1);
data << uint8(CHAR_NAME_RESERVED);
SendPacket( &data );
return;
}
// character with this name already exist
if (uint64 newguid = objmgr.GetPlayerGUIDByName(newname))
{
if (newguid != guid)
{
WorldPacket data(SMSG_CHAR_CUSTOMIZE, 1);
data << uint8(CHAR_CREATE_NAME_IN_USE);
SendPacket( &data );
return;
}
}
CharacterDatabase.escape_string(newname);
Player::Customize(guid, gender, skin, face, hairStyle, hairColor, facialHair);
CharacterDatabase.PExecute("UPDATE characters set name = '%s', at_login = at_login & ~ %u WHERE guid ='%u'", newname.c_str(), uint32(AT_LOGIN_CUSTOMIZE), GUID_LOPART(guid));
CharacterDatabase.PExecute("DELETE FROM character_declinedname WHERE guid ='%u'", GUID_LOPART(guid));
std::string IP_str = GetRemoteAddress();
sLog.outChar("Account: %d (IP: %s), Character guid: %u Customized to: %s", GetAccountId(), IP_str.c_str(), GUID_LOPART(guid), newname.c_str());
WorldPacket data(SMSG_CHAR_CUSTOMIZE, 1+8+(newname.size()+1)+6);
data << uint8(RESPONSE_SUCCESS);
data << uint64(guid);
data << newname;
data << uint8(gender);
data << uint8(skin);
data << uint8(face);
data << uint8(hairStyle);
data << uint8(hairColor);
data << uint8(facialHair);
SendPacket(&data);
}
uint8 WorldSession::DeleteCharacter(uint32 guid)
{
PlayerInfo* inf = objmgr.GetPlayerInfo(guid);
if(inf != NULL && inf->m_loggedInPlayer == NULL)
{
QueryResult* result = CharacterDatabase.Query("SELECT name FROM characters WHERE guid = %u AND acct = %u", (uint32)guid, _accountId);
if(!result)
return E_CHAR_DELETE_FAILED;
string name = result->Fetch()[0].GetString();
delete result;
if(inf->guild)
{
if(inf->guild->GetGuildLeader() == inf->guid)
return E_CHAR_DELETE_FAILED_GUILD_LEADER;
else
inf->guild->RemoveGuildMember(inf, NULL);
}
for(int i = 0; i < NUM_CHARTER_TYPES; ++i)
{
Charter* c = objmgr.GetCharterByGuid(guid, (CharterTypes)i);
if(c != NULL)
c->RemoveSignature((uint32)guid);
}
for(int i = 0; i < NUM_ARENA_TEAM_TYPES; ++i)
{
ArenaTeam* t = objmgr.GetArenaTeamByGuid((uint32)guid, i);
if(t != NULL && t->m_leader == guid)
return E_CHAR_DELETE_FAILED_ARENA_CAPTAIN;
if(t != NULL)
t->RemoveMember(inf);
}
/*if( _socket != NULL )
sPlrLog.write("Account: %s | IP: %s >> Deleted player %s", GetAccountName().c_str(), GetSocket()->GetRemoteIP().c_str(), name.c_str());*/
sPlrLog.writefromsession(this, "deleted character %s (GUID: %u)", name.c_str(), (uint32)guid);
CharacterDatabase.WaitExecute("DELETE FROM characters WHERE guid = %u", (uint32)guid);
Corpse* c = objmgr.GetCorpseByOwner((uint32)guid);
if(c)
CharacterDatabase.Execute("DELETE FROM corpses WHERE guid = %u", c->GetLowGUID());
CharacterDatabase.Execute("DELETE FROM playeritems WHERE ownerguid=%u", (uint32)guid);
CharacterDatabase.Execute("DELETE FROM gm_tickets WHERE playerguid = %u", (uint32)guid);
CharacterDatabase.Execute("DELETE FROM playerpets WHERE ownerguid = %u", (uint32)guid);
CharacterDatabase.Execute("DELETE FROM playerpetspells WHERE ownerguid = %u", (uint32)guid);
CharacterDatabase.Execute("DELETE FROM tutorials WHERE playerId = %u", (uint32)guid);
CharacterDatabase.Execute("DELETE FROM questlog WHERE player_guid = %u", (uint32)guid);
CharacterDatabase.Execute("DELETE FROM playercooldowns WHERE player_guid = %u", (uint32)guid);
CharacterDatabase.Execute("DELETE FROM mailbox WHERE player_guid = %u", (uint32)guid);
CharacterDatabase.Execute("DELETE FROM social_friends WHERE character_guid = %u OR friend_guid = %u", (uint32)guid, (uint32)guid);
CharacterDatabase.Execute("DELETE FROM social_ignores WHERE character_guid = %u OR ignore_guid = %u", (uint32)guid, (uint32)guid);
CharacterDatabase.Execute("DELETE FROM character_achievement WHERE guid = '%u' AND achievement NOT IN (457, 467, 466, 465, 464, 463, 462, 461, 460, 459, 458, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1415, 1414, 1416, 1417, 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, 1463, 1400, 456, 1402)", (uint32)guid);
CharacterDatabase.Execute("DELETE FROM character_achievement_progress WHERE guid = '%u'", (uint32)guid);
CharacterDatabase.Execute("DELETE FROM playerspells WHERE GUID = '%u'", guid);
CharacterDatabase.Execute("DELETE FROM playerdeletedspells WHERE GUID = '%u'", guid);
CharacterDatabase.Execute("DELETE FROM playerreputations WHERE guid = '%u'", guid);
CharacterDatabase.Execute("DELETE FROM playerskills WHERE GUID = '%u'", guid);
/* remove player info */
objmgr.DeletePlayerInfo((uint32)guid);
return E_CHAR_DELETE_SUCCESS;
}
return E_CHAR_DELETE_FAILED;
}
void WorldSession::HandleCharCreateOpcode(WorldPacket & recv_data)
{
CHECK_PACKET_SIZE(recv_data, 10);
std::string name;
uint8 race, class_;
recv_data >> name >> race >> class_;
recv_data.rpos(0);
LoginErrorCode res = VerifyName(name.c_str(), name.length());
if(res != E_CHAR_NAME_SUCCESS)
{
OutPacket(SMSG_CHAR_CREATE, 1, &res);
return;
}
res = g_characterNameFilter->Parse(name, false) ? E_CHAR_NAME_PROFANE : E_CHAR_NAME_SUCCESS;
if(res != E_CHAR_NAME_SUCCESS)
{
OutPacket(SMSG_CHAR_CREATE, 1, &res);
return;
}
res = objmgr.GetPlayerInfoByName(name.c_str()) == NULL ? E_CHAR_CREATE_SUCCESS : E_CHAR_CREATE_NAME_IN_USE;
if(res != E_CHAR_CREATE_SUCCESS)
{
OutPacket(SMSG_CHAR_CREATE, 1, &res);
return;
}
res = sHookInterface.OnNewCharacter(race, class_, this, name.c_str()) ? E_CHAR_CREATE_SUCCESS : E_CHAR_CREATE_ERROR;
if(res != E_CHAR_CREATE_SUCCESS)
{
OutPacket(SMSG_CHAR_CREATE, 1, &res);
return;
}
QueryResult* result = CharacterDatabase.Query("SELECT COUNT(*) FROM banned_names WHERE name = '%s'", CharacterDatabase.EscapeString(name).c_str());
if(result)
{
if(result->Fetch()[0].GetUInt32() > 0)
{
// That name is banned!
OutPacket(SMSG_CHAR_CREATE, 1, CHAR_NAME_PROFANE);
delete result;
return;
}
delete result;
}
// Check if player got Death Knight already on this realm.
if(Config.OptionalConfig.GetBoolDefault("ClassOptions" , "DeathKnightLimit" , true) && has_dk
&& (class_ == DEATHKNIGHT))
{
OutPacket(SMSG_CHAR_CREATE, 1, CHAR_CREATE_UNIQUE_CLASS_LIMIT);
return;
}
// loading characters
// Check the number of characters, so we can't make over 10.
// They're able to manage to create >10 sometimes, not exactly sure how ..
result = CharacterDatabase.Query("SELECT COUNT(*) FROM characters WHERE acct = %u", GetAccountId());
if(result)
{
if(result->Fetch()[0].GetUInt32() >= 10)
{
// We can't make any more characters.
OutPacket(SMSG_CHAR_CREATE, 1, CHAR_CREATE_SERVER_LIMIT);
delete result;
return;
}
delete result;
}
Player* pNewChar = objmgr.CreatePlayer(class_);
pNewChar->SetSession(this);
if(!pNewChar->Create(recv_data))
{
// failed.
pNewChar->ok_to_remove = true;
delete pNewChar;
OutPacket(SMSG_CHAR_CREATE, 1, CHAR_CREATE_FAILED);
return;
}
//Same Faction limitation only applies to PVP and RPPVP realms :)
uint32 realmType = sLogonCommHandler.GetRealmType();
if(!HasGMPermissions() && realmType == REALMTYPE_PVP && _side >= 0 && !sWorld.crossover_chars) // ceberwow fixed bug
{
if((pNewChar->IsTeamAlliance() && (_side == 1)) || (pNewChar->IsTeamHorde() && (_side == 0)))
{
pNewChar->ok_to_remove = true;
delete pNewChar;
OutPacket(SMSG_CHAR_CREATE, 1, CHAR_CREATE_PVP_TEAMS_VIOLATION);
return;
}
}
//Check if player has a level 55 or higher character on this realm and allow him to create DK.
//This check can be turned off in optional.conf
if(Config.OptionalConfig.GetBoolDefault("ClassOptions" , "DeathKnightPreReq" , false) && !has_level_55_char
&& (class_ == DEATHKNIGHT))
{
pNewChar->ok_to_remove = true;
delete pNewChar;
/*
WorldPacket data(1);
data.SetOpcode(SMSG_CHAR_CREATE);
data << (uint8)56 + 1; // This errorcode is not the actual one. Need to find a real error code.
SendPacket( &data );
*/
OutPacket(SMSG_CHAR_CREATE, 1, CHAR_CREATE_LEVEL_REQUIREMENT);
return;
}
pNewChar->UnSetBanned();
pNewChar->addSpell(22027); // Remove Insignia
if(pNewChar->getClass() == WARLOCK)
{
pNewChar->AddSummonSpell(416, 3110); // imp fireball
pNewChar->AddSummonSpell(417, 19505);
pNewChar->AddSummonSpell(1860, 3716);
pNewChar->AddSummonSpell(1863, 7814);
}
pNewChar->SaveToDB(true);
PlayerInfo* pn = new PlayerInfo ;
pn->guid = pNewChar->GetLowGUID();
pn->name = strdup(pNewChar->GetName());
pn->cl = pNewChar->getClass();
pn->race = pNewChar->getRace();
pn->gender = pNewChar->getGender();
pn->acct = GetAccountId();
pn->m_Group = 0;
pn->subGroup = 0;
pn->m_loggedInPlayer = NULL;
pn->team = pNewChar->GetTeam();
pn->guild = NULL;
pn->guildRank = NULL;
pn->guildMember = NULL;
pn->lastOnline = UNIXTIME;
objmgr.AddPlayerInfo(pn);
pNewChar->ok_to_remove = true;
delete pNewChar;
OutPacket(SMSG_CHAR_CREATE, 1, CHAR_CREATE_SUCCESS);
sLogonCommHandler.UpdateAccountCount(GetAccountId(), 1);
}
void WorldSession::CharacterEnumProc(QueryResult* result)
{
struct player_item
{
uint32 displayid;
uint8 invtype;
uint32 enchantment; // added in 2.4
};
uint32 start_time = getMSTime();
player_item items[23];
int8 slot;
uint32 i;
ItemPrototype* proto;
QueryResult* res;
CreatureInfo* info = NULL;
uint8 race;
has_dk = false;
_side = -1; // side should be set on every enumeration for safety
uint32 numchar;
if(result)
numchar = result->GetRowCount();
else
numchar = 0;
// should be more than enough.. 200 bytes per char..
WorldPacket data(SMSG_CHAR_ENUM, 1 + numchar * 200);
// parse m_characters and build a mighty packet of
// characters to send to the client.
data << uint8(numchar);
if(result)
{
uint64 guid;
uint8 Class;
uint32 bytes2;
uint32 flags;
uint32 banned;
Field* fields;
uint32 petLevel = 0;
do
{
fields = result->Fetch();
guid = fields[0].GetUInt64();
bytes2 = fields[6].GetUInt32();
Class = fields[3].GetUInt8();
flags = fields[17].GetUInt32();
race = fields[2].GetUInt8();
if(_side < 0)
{
// work out the side
static uint8 sides[RACE_DRAENEI + 1] = {0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0};
_side = sides[race];
}
// Death Knight starting information
// Note: To change what level is required to make a dk change the >= 55 to something.
// For example >=80 would require a level 80 to create a DK
has_level_55_char = has_level_55_char || (fields[1].GetUInt8() >= 55);
has_dk = has_dk || (Class == 6);
/* build character enum, w0000t :p */
data << uint64(guid); //guid
data << fields[7].GetString(); //name
data << uint8(race); //race
data << uint8(Class); //class
data << uint8(fields[4].GetUInt8()); //gender
data << uint32(fields[5].GetUInt32()); //PLAYER_BYTES
data << uint8(bytes2 & 0xFF); //facial hair
data << uint8(fields[1].GetUInt8()); //Level
data << uint32(fields[12].GetUInt32()); //zoneid
data << uint32(fields[11].GetUInt32()); //Mapid
data << float(fields[8].GetFloat()); //X
data << float(fields[9].GetFloat()); //Y
data << float(fields[10].GetFloat()); //Z
data << uint32(fields[18].GetUInt32()); //GuildID
banned = fields[13].GetUInt32();
uint32 char_flags = 0;
if(banned && (banned < 10 || banned > (uint32)UNIXTIME))
char_flags |= 0x01000000; //Character is banned
if(fields[15].GetUInt32() != 0)
char_flags |= 0x00002000; //Character is dead
if(flags & PLAYER_FLAG_NOHELM)
char_flags |= 0x00000400; //Helm not displayed
if(flags & PLAYER_FLAG_NOCLOAK)
char_flags |= 0x00000800; //Cloak not displayed
if(fields[16].GetUInt32() != 0)
char_flags |= 0x00004000; //Character has to be renamed before logging in
data << uint32(char_flags);
data << uint32(0); //Character recustomization flags
data << uint8(0); //Unknown 3.2.0
if(Class == WARLOCK || Class == HUNTER)
{
res = CharacterDatabase.Query("SELECT entry, level FROM playerpets WHERE ownerguid = %u AND MOD( active, 10 ) = 1 AND alive = TRUE;", Arcemu::Util::GUID_LOPART(guid));
if(res)
{
petLevel = res->Fetch()[1].GetUInt32();
info = CreatureNameStorage.LookupEntry(res->Fetch()[0].GetUInt32());
delete res;
}
else
info = NULL;
}
else
info = NULL;
if(info)
{
data << uint32(info->Male_DisplayID);
data << uint32(petLevel);
data << uint32(info->Family);
}
else
{
data << uint32(0);
data << uint32(0);
data << uint32(0);
}
res = CharacterDatabase.Query("SELECT slot, entry, enchantments FROM playeritems WHERE ownerguid=%u AND containerslot = '-1' AND slot BETWEEN '0' AND '22'", Arcemu::Util::GUID_LOPART(guid));
memset(items, 0, sizeof(player_item) * 23);
uint32 enchantid;
EnchantEntry* enc;
if(res)
{
do
{
slot = res->Fetch()[0].GetInt8();
proto = ItemPrototypeStorage.LookupEntry(res->Fetch()[1].GetUInt32());
if(proto)
{
items[slot].displayid = proto->DisplayInfoID;
items[slot].invtype = static_cast<uint8>(proto->InventoryType);
// weapon glows
if(slot == EQUIPMENT_SLOT_MAINHAND || slot == EQUIPMENT_SLOT_OFFHAND)
{
// get enchant visual ID
const char* enchant_field = res->Fetch()[2].GetString();
if(sscanf(enchant_field , "%u,0,0;" , (unsigned int*)&enchantid) == 1 && enchantid > 0)
{
enc = dbcEnchant.LookupEntryForced(enchantid);
if(enc != NULL)
items[slot].enchantment = enc->visual;
}
}
}
}
while(res->NextRow());
delete res;
}
for(i = 0; i < INVENTORY_SLOT_BAG_END; ++i)
{
data << uint32(items[i].displayid);
data << uint8(items[i].invtype);
data << uint32(items[i].enchantment);
}
}
while(result->NextRow());
}
Log.Debug("Character Enum", "Built in %u ms.", getMSTime() - start_time);
SendPacket(&data);
}
// loads the extra item creation info from DB
void LoadSkillExtraItemTable()
{
uint32 oldMSTime = getMSTime();
SkillExtraItemStore.clear(); // need for reload
// 0 1 2 3
QueryResult result = WorldDatabase.Query("SELECT spellId, requiredSpecialization, additionalCreateChance, additionalMaxNum FROM skill_extra_item_template");
if (!result)
{
sLog->outError(LOG_FILTER_SERVER_LOADING, ">> Loaded 0 spell specialization definitions. DB table `skill_extra_item_template` is empty.");
return;
}
uint32 count = 0;
do
{
Field* fields = result->Fetch();
uint32 spellId = fields[0].GetUInt32();
if (!sSpellMgr->GetSpellInfo(spellId))
{
sLog->outError(LOG_FILTER_SQL, "Skill specialization %u has non-existent spell id in `skill_extra_item_template`!", spellId);
continue;
}
uint32 requiredSpecialization = fields[1].GetUInt32();
if (!sSpellMgr->GetSpellInfo(requiredSpecialization))
{
sLog->outError(LOG_FILTER_SQL, "Skill specialization %u have not existed required specialization spell id %u in `skill_extra_item_template`!", spellId, requiredSpecialization);
continue;
}
float additionalCreateChance = fields[2].GetFloat();
if (additionalCreateChance <= 0.0f)
{
sLog->outError(LOG_FILTER_SQL, "Skill specialization %u has too low additional create chance in `skill_extra_item_template`!", spellId);
continue;
}
uint8 additionalMaxNum = fields[3].GetUInt8();
if (!additionalMaxNum)
{
sLog->outError(LOG_FILTER_SQL, "Skill specialization %u has 0 max number of extra items in `skill_extra_item_template`!", spellId);
continue;
}
SkillExtraItemEntry& skillExtraItemEntry = SkillExtraItemStore[spellId];
skillExtraItemEntry.requiredSpecialization = requiredSpecialization;
skillExtraItemEntry.additionalCreateChance = additionalCreateChance;
skillExtraItemEntry.additionalMaxNum = additionalMaxNum;
++count;
}
while (result->NextRow());
sLog->outInfo(LOG_FILTER_SERVER_LOADING, ">> Loaded %u spell specialization definitions in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
}
bool Guild::LoadFromDB(Field* f)
{
m_guildId = f[0].GetUInt32();
m_guildName = strdup(f[1].GetString());
m_guildLeader = f[2].GetUInt32();
m_emblemStyle = f[3].GetUInt32();
m_emblemColor = f[4].GetUInt32();
m_borderStyle = f[5].GetUInt32();
m_borderColor = f[6].GetUInt32();
m_backgroundColor = f[7].GetUInt32();
m_guildInfo = strlen(f[8].GetString()) ? strdup(f[8].GetString()) : NULL;
m_motd = strlen(f[9].GetString()) ? strdup(f[9].GetString()) : "Click here to set a message of the day.";
m_creationTimeStamp = f[10].GetUInt32();
m_bankBalance = f[11].GetUInt64();
// load ranks
uint32 j;
QueryResult* result = CharacterDatabase.Query("SELECT * FROM guild_ranks WHERE guildId = %u ORDER BY rankId ASC", m_guildId);
if(result == NULL)
return false;
uint32 sid = 0;
do
{
GuildRank* r = new GuildRank;
Field* f2 = result->Fetch();
r->iId = f2[1].GetUInt32();
if(r->iId != sid)
{
Log.Notice("Guild", "Renaming rank %u of guild %s to %u.", r->iId, m_guildName, sid);
CharacterDatabase.Execute("UPDATE guild_ranks SET rankId = %u WHERE guildId = %u AND rankName = \'%s\'", r->iId,
m_guildId, CharacterDatabase.EscapeString(string(f2[2].GetString())).c_str());
r->iId = sid;
}
sid++;
r->szRankName = strdup(f2[2].GetString());
r->iRights = f2[3].GetUInt32();
r->iGoldLimitPerDay = f2[4].GetUInt32();
for(j = 0; j < MAX_GUILD_BANK_TABS; ++j)
{
r->iTabPermissions[j].iFlags = f2[5 + (j * 2)].GetUInt32();
r->iTabPermissions[j].iStacksPerDay = f2[6 + (j * 2)].GetUInt32();
}
//m_ranks.push_back(r);
ARCEMU_ASSERT(m_ranks[r->iId] == NULL);
m_ranks[r->iId] = r;
}
while(result->NextRow());
delete result;
// load members
result = CharacterDatabase.Query("SELECT * FROM guild_data WHERE guildid = %u", m_guildId);
if(result == NULL)
return false;
do
{
Field* f3 = result->Fetch();
GuildMember* gm = new GuildMember;
gm->pPlayer = objmgr.GetPlayerInfo(f3[1].GetUInt32());
if(gm->pPlayer == NULL)
{
delete gm;
continue;
}
if(f3[2].GetUInt32() >= MAX_GUILD_RANKS || m_ranks[f3[2].GetUInt32()] == NULL)
{
delete gm;
continue;
}
gm->pRank = m_ranks[f3[2].GetUInt32()];
if(gm->pRank == NULL)
gm->pRank = FindLowestRank();
gm->pPlayer->guild = this;
gm->pPlayer->guildRank = gm->pRank;
gm->pPlayer->guildMember = gm;
if(strlen(f3[3].GetString()))
gm->szPublicNote = strdup(f3[3].GetString());
else
gm->szPublicNote = NULL;
if(strlen(f3[4].GetString()))
gm->szOfficerNote = strdup(f3[4].GetString());
else
gm->szOfficerNote = NULL;
gm->uLastWithdrawReset = f3[5].GetUInt32();
gm->uWithdrawlsSinceLastReset = f3[6].GetUInt32();
for(j = 0; j < MAX_GUILD_BANK_TABS; ++j)
{
gm->uLastItemWithdrawReset[j] = f3[7 + (j * 2)].GetUInt32();
gm->uItemWithdrawlsSinceLastReset[j] = f3[8 + (j * 2)].GetUInt32();
}
m_members.insert(make_pair(gm->pPlayer, gm));
}
while(result->NextRow());
delete result;
result = CharacterDatabase.Query("SELECT MAX(log_id) FROM guild_logs WHERE guildid = %u", m_guildId);
m_hiLogId = 1;
if(result != NULL)
{
m_hiLogId = result->Fetch()[0].GetUInt32() + 1;
delete result;
}
result = CharacterDatabase.Query("SELECT MAX(log_id) FROM guild_banklogs WHERE guildid = %u", m_guildId);
if(result)
{
if((result->Fetch()[0].GetUInt32() + 1) > m_hiLogId)
m_hiLogId = result->Fetch()[0].GetUInt32() + 1;
delete result;
}
// load log
result = CharacterDatabase.Query("SELECT * FROM guild_logs WHERE guildid = %u ORDER BY timestamp ASC", m_guildId);
if(result)
{
do
{
GuildLogEvent* li = new GuildLogEvent;
li->iLogId = result->Fetch()[0].GetUInt32();
li->iEvent = static_cast<uint8>(result->Fetch()[3].GetUInt32());
li->iTimeStamp = result->Fetch()[2].GetUInt32();
li->iEventData[0] = result->Fetch()[4].GetUInt32();
li->iEventData[1] = result->Fetch()[5].GetUInt32();
li->iEventData[2] = result->Fetch()[6].GetUInt32();
m_log.push_back(li);
}
while(result->NextRow());
delete result;
}
result = CharacterDatabase.Query("SELECT * FROM guild_banktabs WHERE guildId = %u ORDER BY tabId ASC", m_guildId);
sid = 0;
if(result)
{
do
{
if((sid++) != result->Fetch()[1].GetUInt32())
{
LOG_ERROR("Guild bank tabs are out of order!");
#ifdef WIN32
TerminateProcess(GetCurrentProcess(), 0);
return false;
#else
exit(0);
#endif
}
QueryResult* res2 = CharacterDatabase.Query("SELECT * FROM guild_bankitems WHERE guildId = %u AND tabId = %u", m_guildId, result->Fetch()[1].GetUInt32());
GuildBankTab* pTab = new GuildBankTab;
pTab->iTabId = (uint8)result->Fetch()[1].GetUInt32();
pTab->szTabName = (strlen(result->Fetch()[2].GetString()) > 0) ? strdup(result->Fetch()[2].GetString()) : NULL;
pTab->szTabIcon = (strlen(result->Fetch()[3].GetString()) > 0) ? strdup(result->Fetch()[3].GetString()) : NULL;
pTab->szTabInfo = (strlen(result->Fetch()[4].GetString()) > 0) ? strdup(result->Fetch()[4].GetString()) : NULL;
memset(pTab->pSlots, 0, sizeof(Item*) * MAX_GUILD_BANK_SLOTS);
if(res2)
{
do
{
Item* pItem = objmgr.LoadItem(res2->Fetch()[3].GetUInt32());
if(pItem == NULL)
{
CharacterDatabase.Execute("DELETE FROM guild_bankitems WHERE itemGuid = %u AND guildId = %u AND tabId = %u", res2->Fetch()[3].GetUInt32(), m_guildId, (uint32)pTab->iTabId);
continue;
}
pTab->pSlots[res2->Fetch()[2].GetUInt32()] = pItem;
}
while(res2->NextRow());
delete res2;
}
res2 = CharacterDatabase.Query("SELECT * FROM guild_banklogs WHERE guildid = %u AND tabid = %u ORDER BY timestamp ASC", m_guildId, result->Fetch()[1].GetUInt32());
if(res2 != NULL)
{
do
{
GuildBankEvent* ev = new GuildBankEvent;
ev->iLogId = res2->Fetch()[0].GetUInt32();
ev->iAction = res2->Fetch()[3].GetUInt8();
ev->uPlayer = res2->Fetch()[4].GetUInt32();
ev->uEntry = res2->Fetch()[5].GetUInt32();
ev->iStack = res2->Fetch()[6].GetUInt8();
ev->uTimeStamp = res2->Fetch()[7].GetUInt32();
pTab->lLog.push_back(ev);
}
while(res2->NextRow());
delete res2;
}
m_bankTabs.push_back(pTab);
}
while(result->NextRow());
delete result;
}
result = CharacterDatabase.Query("SELECT * FROM guild_banklogs WHERE guildid = %u AND tabid = 6 ORDER BY timestamp ASC", m_guildId);
if(result != NULL)
{
do
{
GuildBankEvent* ev = new GuildBankEvent;
ev->iLogId = result->Fetch()[0].GetUInt32();
ev->iAction = result->Fetch()[3].GetUInt8();
ev->uPlayer = result->Fetch()[4].GetUInt32();
ev->uEntry = result->Fetch()[5].GetUInt32();
ev->iStack = result->Fetch()[6].GetUInt8();
ev->uTimeStamp = result->Fetch()[7].GetUInt32();
m_moneyLog.push_back(ev);
}
while(result->NextRow());
delete result;
}
Log.Debug("Guild", "Loaded guild %s, %u members.", m_guildName, m_members.size());
return true;
}
void WeatherMgr::LoadWeatherData()
{
uint32 count = 0;
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13
QueryResult result = WorldDatabase.Query("SELECT zone, spring_rain_chance, spring_snow_chance, spring_storm_chance, summer_rain_chance, summer_snow_chance, summer_storm_chance, fall_rain_chance, fall_snow_chance, fall_storm_chance, winter_rain_chance, winter_snow_chance, winter_storm_chance, ScriptName FROM game_weather");
if (!result)
{
sLog.outString();
sLog.outErrorDb(">> Loaded 0 weather definitions. DB table `game_weather` is empty.");
return;
}
do
{
Field *fields = result->Fetch();
uint32 zone_id = fields[0].GetUInt32();
WeatherData& wzc = mWeatherZoneMap[zone_id];
for (uint8 season = 0; season < WEATHER_SEASONS; ++season)
{
wzc.data[season].rainChance = fields[season * (MAX_WEATHER_TYPE-1) + 1].GetUInt32();
wzc.data[season].snowChance = fields[season * (MAX_WEATHER_TYPE-1) + 2].GetUInt32();
wzc.data[season].stormChance = fields[season * (MAX_WEATHER_TYPE-1) + 3].GetUInt32();
if (wzc.data[season].rainChance > 100)
{
wzc.data[season].rainChance = 25;
sLog.outErrorDb("Weather for zone %u season %u has wrong rain chance > 100%%",zone_id,season);
}
if (wzc.data[season].snowChance > 100)
{
wzc.data[season].snowChance = 25;
sLog.outErrorDb("Weather for zone %u season %u has wrong snow chance > 100%%",zone_id,season);
}
if (wzc.data[season].stormChance > 100)
{
wzc.data[season].stormChance = 25;
sLog.outErrorDb("Weather for zone %u season %u has wrong storm chance > 100%%",zone_id,season);
}
}
wzc.ScriptId = sObjectMgr.GetScriptId(fields[13].GetCString());
++count;
}
while (result->NextRow());
sLog.outString();
sLog.outString(">> Loaded %u weather definitions", count);
}
bool WorldSession::Anti__ReportCheat(const char* Reason,float Speed,const char* Op,float Val1,uint32 Val2)
{
if(!Reason)
{
sLog.outError("Anti__ReportCheat: Missing Reason parameter!");
return false;
}
const char* Player=GetPlayer()->GetName();
uint32 Acc=GetPlayer()->GetSession()->GetAccountId();
uint32 Map=GetPlayer()->GetMapId();
if(!Player)
{
sLog.outError("Anti__ReportCheat: Player with no name?!?");
return false;
}
QueryResult *Res=CharacterDatabase.PQuery("SELECT speed,Val1 FROM cheaters WHERE player='%s' AND reason LIKE '%s' AND Map='%u' AND last_date >= NOW()-300",Player,Reason,Map);
if(Res)
{
Field* Fields = Res->Fetch();
std::stringstream Query;
Query << "UPDATE cheaters SET count=count+1,last_date=NOW()";
Query.precision(5);
if(Speed>0.0f && Speed > Fields[0].GetFloat())
{
Query << ",speed='";
Query << std::fixed << Speed;
Query << "'";
}
if(Val1>0.0f && Val1 > Fields[1].GetFloat())
{
Query << ",Val1='";
Query << std::fixed << Val1;
Query << "'";
}
Query << " WHERE player='" << Player << "' AND reason='" << Reason << "' AND Map='" << Map << "' AND last_date >= NOW()-300 ORDER BY entry DESC LIMIT 1";
CharacterDatabase.Execute(Query.str().c_str());
delete Res;
}
else
{
if(!Op)
{ Op=""; }
std::stringstream Pos;
Pos << "OldPos: " << GetPlayer()->GetPositionX() << " " << GetPlayer()->GetPositionY() << " "
<< GetPlayer()->GetPositionZ();
CharacterDatabase.PExecute("INSERT INTO cheaters (player,acctid,reason,speed,count,first_date,last_date,`Op`,Val1,Val2,Map,Pos,Level) "
"VALUES ('%s','%u','%s','%f','1',NOW(),NOW(),'%s','%f','%u','%u','%s','%u')",
Player,Acc,Reason,Speed,Op,Val1,Val2,Map,
Pos.str().c_str(),GetPlayer()->getLevel());
}
if(sWorld.GetMvAnticheatKill() && GetPlayer()->isAlive())
{
GetPlayer()->DealDamage(GetPlayer(), GetPlayer()->GetHealth(), NULL, DIRECT_DAMAGE, SPELL_SCHOOL_MASK_NORMAL, NULL, false);
}
if(sWorld.GetMvAnticheatKick())
{
GetPlayer()->GetSession()->KickPlayer();
}
if(sWorld.GetMvAnticheatBan() & 1)
{
sWorld.BanAccount(BAN_CHARACTER,Player,sWorld.GetMvAnticheatBanTime(),"Cheat","Anticheat");
}
if(sWorld.GetMvAnticheatBan() & 2)
{
QueryResult *result = LoginDatabase.PQuery("SELECT last_ip FROM account WHERE id=%u", Acc);
if(result)
{
Field *fields = result->Fetch();
std::string LastIP = fields[0].GetCppString();
if(!LastIP.empty())
{
sWorld.BanAccount(BAN_IP,LastIP,sWorld.GetMvAnticheatBanTime(),"Cheat","Anticheat");
}
delete result;
}
}
return true;
}
void GameEventMgr::LoadFromDB()
{
{
QueryResult *result = WorldDatabase.Query("SELECT MAX(entry) FROM game_event");
if( !result )
{
sLog.outString(">> Table game_event is empty.");
sLog.outString();
return;
}
Field *fields = result->Fetch();
uint32 max_event_id = fields[0].GetUInt16();
delete result;
mGameEvent.resize(max_event_id+1);
}
QueryResult *result = WorldDatabase.Query("SELECT entry,UNIX_TIMESTAMP(start_time),UNIX_TIMESTAMP(end_time),occurence,length,holiday,description FROM game_event");
if( !result )
{
mGameEvent.clear();
sLog.outString(">> Table game_event is empty!");
sLog.outString();
return;
}
uint32 count = 0;
{
barGoLink bar( (int)result->GetRowCount() );
do
{
++count;
Field *fields = result->Fetch();
bar.step();
uint16 event_id = fields[0].GetUInt16();
if(event_id==0)
{
sLog.outErrorDb("`game_event` game event id (%i) is reserved and can't be used.",event_id);
continue;
}
GameEventData& pGameEvent = mGameEvent[event_id];
uint64 starttime = fields[1].GetUInt64();
pGameEvent.start = time_t(starttime);
uint64 endtime = fields[2].GetUInt64();
pGameEvent.end = time_t(endtime);
pGameEvent.occurence = fields[3].GetUInt32();
pGameEvent.length = fields[4].GetUInt32();
pGameEvent.holiday_id = HolidayIds(fields[5].GetUInt32());
if(pGameEvent.length==0) // length>0 is validity check
{
sLog.outErrorDb("`game_event` game event id (%i) have length 0 and can't be used.",event_id);
continue;
}
if(pGameEvent.holiday_id != HOLIDAY_NONE)
{
if(!sHolidaysStore.LookupEntry(pGameEvent.holiday_id))
{
sLog.outErrorDb("`game_event` game event id (%i) have nonexistent holiday id %u.",event_id,pGameEvent.holiday_id);
pGameEvent.holiday_id = HOLIDAY_NONE;
}
}
pGameEvent.description = fields[6].GetCppString();
} while( result->NextRow() );
delete result;
sLog.outString();
sLog.outString( ">> Loaded %u game events", count );
}
std::map<uint16,int16> pool2event; // for check unique spawn event associated with pool
std::map<uint32,int16> creature2event; // for check unique spawn event associated with creature
std::map<uint32,int16> go2event; // for check unique spawn event associated with gameobject
// list only positive event top pools, filled at creature/gameobject loading
mGameEventSpawnPoolIds.resize(mGameEvent.size());
mGameEventCreatureGuids.resize(mGameEvent.size()*2-1);
// 1 2
result = WorldDatabase.Query("SELECT creature.guid, game_event_creature.event "
"FROM creature JOIN game_event_creature ON creature.guid = game_event_creature.guid");
count = 0;
if( !result )
{
barGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded %u creatures in game events", count );
}
else
{
barGoLink bar( (int)result->GetRowCount() );
do
{
Field *fields = result->Fetch();
bar.step();
uint32 guid = fields[0].GetUInt32();
int16 event_id = fields[1].GetInt16();
if (event_id == 0)
{
sLog.outErrorDb("`game_event_creature` game event id (%i) not allowed",event_id);
continue;
}
int32 internal_event_id = mGameEvent.size() + event_id - 1;
if(internal_event_id < 0 || (size_t)internal_event_id >= mGameEventCreatureGuids.size())
{
sLog.outErrorDb("`game_event_creature` game event id (%i) is out of range compared to max event id in `game_event`",event_id);
continue;
}
++count;
// spawn objects at event can be grouped in pools and then affected pools have stricter requirements for this case
if (event_id > 0)
{
creature2event[guid] = event_id;
// not list explicitly creatures from pools in event creature list
if (uint16 topPoolId = sPoolMgr.IsPartOfTopPool<Creature>(guid))
{
int16& eventRef = pool2event[topPoolId];
if (eventRef != 0)
{
if (eventRef != event_id)
sLog.outErrorDb("`game_event_creature` have creature (GUID: %u) for event %i from pool or subpool of pool (ID: %u) but pool have already content from event %i. Pool don't must have content for different events!", guid, event_id, topPoolId, eventRef);
}
else
{
eventRef = event_id;
mGameEventSpawnPoolIds[event_id].push_back(topPoolId);
sPoolMgr.RemoveAutoSpawnForPool(topPoolId);
}
continue;
}
}
GuidList& crelist = mGameEventCreatureGuids[internal_event_id];
crelist.push_back(guid);
} while( result->NextRow() );
delete result;
sLog.outString();
sLog.outString( ">> Loaded %u creatures in game events", count );
}
mGameEventGameobjectGuids.resize(mGameEvent.size()*2-1);
// 1 2
result = WorldDatabase.Query("SELECT gameobject.guid, game_event_gameobject.event "
"FROM gameobject JOIN game_event_gameobject ON gameobject.guid=game_event_gameobject.guid");
count = 0;
if( !result )
{
barGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded %u gameobjects in game events", count );
}
else
{
barGoLink bar( (int)result->GetRowCount() );
do
{
Field *fields = result->Fetch();
bar.step();
uint32 guid = fields[0].GetUInt32();
int16 event_id = fields[1].GetInt16();
if (event_id == 0)
{
sLog.outErrorDb("`game_event_gameobject` game event id (%i) not allowed",event_id);
continue;
}
int32 internal_event_id = mGameEvent.size() + event_id - 1;
if(internal_event_id < 0 || (size_t)internal_event_id >= mGameEventGameobjectGuids.size())
{
sLog.outErrorDb("`game_event_gameobject` game event id (%i) is out of range compared to max event id in `game_event`",event_id);
continue;
}
++count;
// spawn objects at event can be grouped in pools and then affected pools have stricter requirements for this case
if (event_id > 0)
{
go2event[guid] = event_id;
// not list explicitly gameobjects from pools in event gameobject list
if (uint16 topPoolId = sPoolMgr.IsPartOfTopPool<GameObject>(guid))
{
int16& eventRef = pool2event[topPoolId];
if (eventRef != 0)
{
if (eventRef != event_id)
sLog.outErrorDb("`game_event_gameobject` have gameobject (GUID: %u) for event %i from pool or subpool of pool (ID: %u) but pool have already content from event %i. Pool don't must have content for different events!", guid, event_id, topPoolId, eventRef);
}
else
{
eventRef = event_id;
mGameEventSpawnPoolIds[event_id].push_back(topPoolId);
sPoolMgr.RemoveAutoSpawnForPool(topPoolId);
}
continue;
}
}
GuidList& golist = mGameEventGameobjectGuids[internal_event_id];
golist.push_back(guid);
} while( result->NextRow() );
delete result;
sLog.outString();
sLog.outString( ">> Loaded %u gameobjects in game events", count );
}
// now recheck that all eventPools linked with events after our skip pools with parents
for(std::map<uint16,int16>::const_iterator itr = pool2event.begin(); itr != pool2event.end(); ++itr)
{
uint16 pool_id = itr->first;
int16 event_id = itr->second;
sPoolMgr.CheckEventLinkAndReport(pool_id, event_id, creature2event, go2event);
}
mGameEventModelEquip.resize(mGameEvent.size());
// 0 1 2
result = WorldDatabase.Query("SELECT creature.guid, game_event_model_equip.event, game_event_model_equip.modelid,"
// 3
"game_event_model_equip.equipment_id "
"FROM creature JOIN game_event_model_equip ON creature.guid=game_event_model_equip.guid");
count = 0;
if( !result )
{
barGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded %u model/equipment changes in game events", count );
}
else
{
barGoLink bar( (int)result->GetRowCount() );
do
{
Field *fields = result->Fetch();
bar.step();
uint32 guid = fields[0].GetUInt32();
uint16 event_id = fields[1].GetUInt16();
if(event_id >= mGameEventModelEquip.size())
{
sLog.outErrorDb("`game_event_model_equip` game event id (%u) is out of range compared to max event id in `game_event`",event_id);
continue;
}
++count;
ModelEquipList& equiplist = mGameEventModelEquip[event_id];
ModelEquip newModelEquipSet;
newModelEquipSet.modelid = fields[2].GetUInt32();
newModelEquipSet.equipment_id = fields[3].GetUInt32();
newModelEquipSet.equipement_id_prev = 0;
newModelEquipSet.modelid_prev = 0;
if(newModelEquipSet.equipment_id > 0)
{
if(!sObjectMgr.GetEquipmentInfo(newModelEquipSet.equipment_id))
{
sLog.outErrorDb("Table `game_event_model_equip` have creature (Guid: %u) with equipment_id %u not found in table `creature_equip_template`, set to no equipment.", guid, newModelEquipSet.equipment_id);
continue;
}
}
equiplist.push_back(std::pair<uint32, ModelEquip>(guid, newModelEquipSet));
} while( result->NextRow() );
delete result;
sLog.outString();
sLog.outString( ">> Loaded %u model/equipment changes in game events", count );
}
mGameEventQuests.resize(mGameEvent.size());
result = WorldDatabase.Query("SELECT quest, event FROM game_event_quest");
count = 0;
if( !result )
{
barGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded %u quests additions in game events", count );
}
else
{
barGoLink bar( (int)result->GetRowCount() );
do
{
Field *fields = result->Fetch();
bar.step();
uint32 quest = fields[0].GetUInt32();
uint16 event_id = fields[1].GetUInt16();
if(event_id >= mGameEventQuests.size())
{
sLog.outErrorDb("`game_event_quest` game event id (%u) is out of range compared to max event id in `game_event`",event_id);
continue;
}
const Quest* pQuest = sObjectMgr.GetQuestTemplate(quest);
if (!pQuest)
{
sLog.outErrorDb("Table `game_event_quest` contain entry for quest %u (event %u) but this quest does not exist. Skipping.", quest, event_id);
continue;
}
// disable any event specific quest (for cases where creature is spawned, but event not active).
const_cast<Quest*>(pQuest)->SetQuestActiveState(false);
++count;
QuestList& questlist = mGameEventQuests[event_id];
questlist.push_back(quest);
} while( result->NextRow() );
delete result;
sLog.outString();
sLog.outString( ">> Loaded %u quest additions in game events", count );
}
}
void WorldSession::HandleOpenItemOpcode(WorldPacket& recvPacket)
{
DETAIL_LOG("WORLD: CMSG_OPEN_ITEM packet, data length = %i",(uint32)recvPacket.size());
uint8 bagIndex, slot;
recvPacket >> bagIndex >> slot;
DETAIL_LOG("bagIndex: %u, slot: %u",bagIndex,slot);
Player* pUser = _player;
// ignore for remote control state
if (!pUser->IsSelfMover())
return;
Item *pItem = pUser->GetItemByPos(bagIndex, slot);
if(!pItem)
{
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, NULL, NULL );
return;
}
ItemPrototype const *proto = pItem->GetProto();
if(!proto)
{
pUser->SendEquipError(EQUIP_ERR_ITEM_NOT_FOUND, pItem, NULL );
return;
}
// locked item
uint32 lockId = proto->LockID;
if(lockId && !pItem->HasFlag(ITEM_FIELD_FLAGS, ITEM_DYNFLAG_UNLOCKED))
{
LockEntry const *lockInfo = sLockStore.LookupEntry(lockId);
if (!lockInfo)
{
pUser->SendEquipError(EQUIP_ERR_ITEM_LOCKED, pItem, NULL );
sLog.outError( "WORLD::OpenItem: item [guid = %u] has an unknown lockId: %u!", pItem->GetGUIDLow() , lockId);
return;
}
// required picklocking
if(lockInfo->Skill[1] || lockInfo->Skill[0])
{
pUser->SendEquipError(EQUIP_ERR_ITEM_LOCKED, pItem, NULL );
return;
}
}
if (pItem->HasFlag(ITEM_FIELD_FLAGS, ITEM_DYNFLAG_WRAPPED))// wrapped?
{
QueryResult *result = CharacterDatabase.PQuery("SELECT entry, flags FROM character_gifts WHERE item_guid = '%u'", pItem->GetGUIDLow());
if (result)
{
Field *fields = result->Fetch();
uint32 entry = fields[0].GetUInt32();
uint32 flags = fields[1].GetUInt32();
pItem->SetGuidValue(ITEM_FIELD_GIFTCREATOR, ObjectGuid());
pItem->SetEntry(entry);
pItem->SetUInt32Value(ITEM_FIELD_FLAGS, flags);
pItem->SetState(ITEM_CHANGED, pUser);
delete result;
}
else
{
sLog.outError("Wrapped item %u don't have record in character_gifts table and will deleted", pItem->GetGUIDLow());
pUser->DestroyItem(pItem->GetBagSlot(), pItem->GetSlot(), true);
return;
}
static SqlStatementID delGifts ;
SqlStatement stmt = CharacterDatabase.CreateStatement(delGifts, "DELETE FROM character_gifts WHERE item_guid = ?");
stmt.PExecute(pItem->GetGUIDLow());
}
else
pUser->SendLoot(pItem->GetObjectGuid(),LOOT_CORPSE);
}
/// Read data from the network
void RASocket::OnRead()
{
///- Read data and check input length
TcpSocket::OnRead();
unsigned int sz=ibuf.GetLength();
if(iInputLength+sz>=RA_BUFF_SIZE)
{
sLog.outRALog("Input buffer overflow, possible DOS attack.\n");
SetCloseAndDelete();
return;
}
///- If there is already an active admin (other than you), drop the connection
if(stage!=OK && iUsers)
dropclient
char *inp = new char [sz+1];
ibuf.Read(inp,sz);
/// \todo Can somebody explain this 'Linux bugfix'?
if(stage==NONE)
if(sz>4) //linux remote telnet
if(memcmp(inp ,"USER ",5))
{
delete [] inp;return;
printf("lin bugfix");
} //linux bugfix
///- Discard data after line break or line feed
bool gotenter=false;
unsigned int y=0;
for(;y<sz;y++)
if(inp[y]=='\r'||inp[y]=='\n')
{
gotenter=true;
break;
}
//No buffer overflow (checked above)
memcpy(&buff[iInputLength],inp,y);
iInputLength+=y;
delete [] inp;
if(gotenter)
{
buff[iInputLength]=0;
iInputLength=0;
switch(stage)
{
/// <ul> <li> If the input is 'USER <username>'
case NONE:
if(!memcmp(buff,"USER ",5)) //got "USER" cmd
{
szLogin=&buff[5];
///- Get the gmlevel and password from the account table
std::string login = szLogin;
///- Convert Account name to Upper Format
AccountMgr::normilizeString(login);
///- Escape the Login to allow quotes in names
loginDatabase.escape_string(login);
QueryResult* result = loginDatabase.PQuery("SELECT gmlevel FROM account WHERE username = '******'",login.c_str());
///- If the user is not found, deny access
if(!result)
{
Sendf("-No such user.\r\n");
sLog.outRALog("User %s does not exist.\n",szLogin.c_str());
if(bSecure)SetCloseAndDelete();
}
else
{
Field *fields = result->Fetch();
//szPass=fields[0].GetString();
///- if gmlevel is too low, deny access
if(fields[0].GetUInt32()<iMinLevel)
{
Sendf("-Not enough privileges.\r\n");
sLog.outRALog("User %s has no privilege.\n",szLogin.c_str());
if(bSecure)SetCloseAndDelete();
} else
{
stage=LG;
}
delete result;
}
}
break;
///<li> If the input is 'PASS <password>' (and the user already gave his username)
case LG:
if(!memcmp(buff,"PASS ",5)) //got "PASS" cmd
{ //login+pass ok
///- If password is correct, increment the number of active administrators
std::string login = szLogin;
std::string pw = &buff[5];
AccountMgr::normilizeString(login);
AccountMgr::normilizeString(pw);
loginDatabase.escape_string(login);
loginDatabase.escape_string(pw);
QueryResult *check = loginDatabase.PQuery("SELECT 1 FROM account WHERE username = '******' AND sha_pass_hash=SHA1(CONCAT(username,':','%s'))", login.c_str(), pw.c_str());
if(check)
{
delete check;
r=GetSocket();
stage=OK;
++iUsers;
Sendf("+Logged in.\r\n");
sLog.outRALog("User %s has logged in.\n",szLogin.c_str());
Sendf("TC>");
}
else
{
///- Else deny access
Sendf("-Wrong pass.\r\n");
sLog.outRALog("User %s has failed to log in.\n",szLogin.c_str());
if(bSecure)SetCloseAndDelete();
}
}
break;
///<li> If user is logged, parse and execute the command
case OK:
if(strlen(buff))
{
sLog.outRALog("Got '%s' cmd.\n",buff);
ParseCommand(&RASocket::zprintf , buff);
}
else
Sendf("TC>");
break;
///</ul>
};
}
}
void SQLStorage::Load ()
{
uint32 maxi;
Field *fields;
QueryResult *result = WorldDatabase.PQuery("SELECT MAX(%s) FROM %s",entry_field,table);
if(!result)
{
sLog.outError("Error loading %s table (not exist?)\n",table);
exit(1); // Stop server at loading non exited table or not accessable table
}
maxi= (*result)[0].GetUInt32()+1;
delete result;
result = WorldDatabase.PQuery("SELECT COUNT(*) FROM %s",table);
if(result)
{
fields = result->Fetch();
RecordCount=fields[0].GetUInt32();
delete result;
}
else
RecordCount = 0;
result = WorldDatabase.PQuery("SELECT * FROM %s",table);
if(!result)
{
sLog.outError("%s table is empty!\n",table);
RecordCount = 0;
return;
}
uint32 recordsize=0;
uint32 offset=0;
if(iNumFields!=result->GetFieldCount())
{
RecordCount = 0;
sLog.outError("Error in %s table, probably sql file format was updated (there should be %d fields in sql).\n",table,iNumFields);
delete result;
exit(1); // Stop server at loading broken or non-compatible table.
}
//get struct size
uint32 sc=0;
uint32 bo=0;
uint32 bb=0;
for(uint32 x=0;x<iNumFields;x++)
if(format[x]==FT_STRING)
++sc;
else if (format[x]==FT_LOGIC)
++bo;
else if (format[x]==FT_BYTE)
++bb;
recordsize=(iNumFields-sc-bo-bb)*4+sc*sizeof(char*)+bo*sizeof(bool)+bb*sizeof(char);
char** newIndex=new char*[maxi];
memset(newIndex,0,maxi*sizeof(char*));
char * _data= new char[RecordCount *recordsize];
uint32 count=0;
barGoLink bar( RecordCount );
do
{
fields = result->Fetch();
bar.step();
char *p=(char*)&_data[recordsize*count];
newIndex[fields[0].GetUInt32()]=p;
offset=0;
for(uint32 x=0;x<iNumFields;x++)
switch(format[x])
{
case FT_LOGIC:
*((bool*)(&p[offset]))=(fields[x].GetUInt32()>0);
offset+=sizeof(bool);
break;
case FT_BYTE:
*((char*)(&p[offset]))=(fields[x].GetUInt8());
offset+=sizeof(char);
break;
case FT_INT:
*((uint32*)(&p[offset]))=fields[x].GetUInt32();
offset+=sizeof(uint32);
break;
case FT_FLOAT:
*((float*)(&p[offset]))=fields[x].GetFloat();
offset+=sizeof(float);
break;
case FT_STRING:
char const* tmp = fields[x].GetString();
char* st;
if(!tmp)
{
st=new char[1];
*st=0;
}
else
{
uint32 l=strlen(tmp)+1;
st=new char[l];
memcpy(st,tmp,l);
}
*((char**)(&p[offset]))=st;
offset+=sizeof(char*);
break;
}
++count;
}while( result->NextRow() );
delete result;
pIndex =newIndex;
MaxEntry=maxi;
data=_data;
}
void SystemMgr::LoadScriptSplineChains()
{
uint32 oldMSTime = getMSTime();
m_mSplineChainsMap.clear();
// 0 1 2 3 4
QueryResult resultMeta = WorldDatabase.Query("SELECT entry, chainId, splineId, expectedDuration, msUntilNext FROM script_spline_chain_meta ORDER BY entry asc, chainId asc, splineId asc");
// 0 1 2 3 4 5 6
QueryResult resultWP = WorldDatabase.Query("SELECT entry, chainId, splineId, wpId, x, y, z FROM script_spline_chain_waypoints ORDER BY entry asc, chainId asc, splineId asc, wpId asc");
if (!resultMeta || !resultWP)
{
TC_LOG_INFO("server.loading", ">> Loaded spline chain data for 0 chains, consisting of 0 splines with 0 waypoints. DB tables `script_spline_chain_meta` and `script_spline_chain_waypoints` are empty.");
}
else
{
uint32 chainCount = 0, splineCount = 0, wpCount = 0;
do
{
Field* fieldsMeta = resultMeta->Fetch();
uint32 entry = fieldsMeta[0].GetUInt32();
uint16 chainId = fieldsMeta[1].GetUInt16();
uint8 splineId = fieldsMeta[2].GetUInt8();
std::vector<SplineChainLink>& chain = m_mSplineChainsMap[{entry,chainId}];
if (splineId != chain.size())
{
TC_LOG_WARN("server.loading", "Creature #%u: Chain %u has orphaned spline %u, skipped.", entry, chainId, splineId);
continue;
}
uint32 expectedDuration = fieldsMeta[3].GetUInt32();
uint32 msUntilNext = fieldsMeta[4].GetUInt32();
chain.emplace_back(expectedDuration, msUntilNext);
if (splineId == 0)
++chainCount;
++splineCount;
} while (resultMeta->NextRow());
do
{
Field* fieldsWP = resultWP->Fetch();
uint32 entry = fieldsWP[0].GetUInt32();
uint16 chainId = fieldsWP[1].GetUInt16();
uint8 splineId = fieldsWP[2].GetUInt8(), wpId = fieldsWP[3].GetUInt8();
float posX = fieldsWP[4].GetFloat(), posY = fieldsWP[5].GetFloat(), posZ = fieldsWP[6].GetFloat();
auto it = m_mSplineChainsMap.find({entry,chainId});
if (it == m_mSplineChainsMap.end())
{
TC_LOG_WARN("server.loading", "Creature #%u has waypoint data for spline chain %u. No such chain exists - entry skipped.", entry, chainId);
continue;
}
std::vector<SplineChainLink>& chain = it->second;
if (splineId >= chain.size())
{
TC_LOG_WARN("server.loading", "Creature #%u has waypoint data for spline (%u,%u). The specified chain does not have a spline with this index - entry skipped.", entry, chainId, splineId);
continue;
}
SplineChainLink& spline = chain[splineId];
if (wpId != spline.Points.size())
{
TC_LOG_WARN("server.loading", "Creature #%u has orphaned waypoint data in spline (%u,%u) at index %u. Skipped.", entry, chainId, splineId, wpId);
continue;
}
spline.Points.emplace_back(posX, posY, posZ);
++wpCount;
} while (resultWP->NextRow());
TC_LOG_INFO("server.loading", ">> Loaded spline chain data for %u chains, consisting of %u splines with %u waypoints in %u ms", chainCount, splineCount, wpCount, GetMSTimeDiffToNow(oldMSTime));
}
}
static bool HandleGameObjectTargetCommand(ChatHandler* handler, char const* args)
{
Player* player = handler->GetSession()->GetPlayer();
QueryResult result;
GameEventMgr::ActiveEvents const& activeEventsList = sGameEventMgr->GetActiveEventList();
if (*args)
{
// number or [name] Shift-click form |color|Hgameobject_entry:go_id|h[name]|h|r
char* id = handler->extractKeyFromLink((char*)args, "Hgameobject_entry");
if (!id)
return false;
uint32 objectId = atoul(id);
if (objectId)
result = WorldDatabase.PQuery("SELECT guid, id, position_x, position_y, position_z, orientation, map, PhaseId, PhaseGroup, (POW(position_x - '%f', 2) + POW(position_y - '%f', 2) + POW(position_z - '%f', 2)) AS order_ FROM gameobject WHERE map = '%i' AND id = '%u' ORDER BY order_ ASC LIMIT 1",
player->GetPositionX(), player->GetPositionY(), player->GetPositionZ(), player->GetMapId(), objectId);
else
{
std::string name = id;
WorldDatabase.EscapeString(name);
result = WorldDatabase.PQuery(
"SELECT guid, id, position_x, position_y, position_z, orientation, map, PhaseId, PhaseGroup, (POW(position_x - %f, 2) + POW(position_y - %f, 2) + POW(position_z - %f, 2)) AS order_ "
"FROM gameobject, gameobject_template WHERE gameobject_template.entry = gameobject.id AND map = %i AND name " _LIKE_" " _CONCAT3_("'%%'", "'%s'", "'%%'")" ORDER BY order_ ASC LIMIT 1",
player->GetPositionX(), player->GetPositionY(), player->GetPositionZ(), player->GetMapId(), name.c_str());
}
}
else
{
std::ostringstream eventFilter;
eventFilter << " AND (eventEntry IS NULL ";
bool initString = true;
for (GameEventMgr::ActiveEvents::const_iterator itr = activeEventsList.begin(); itr != activeEventsList.end(); ++itr)
{
if (initString)
{
eventFilter << "OR eventEntry IN (" << *itr;
initString = false;
}
else
eventFilter << ',' << *itr;
}
if (!initString)
eventFilter << "))";
else
eventFilter << ')';
result = WorldDatabase.PQuery("SELECT gameobject.guid, id, position_x, position_y, position_z, orientation, map, PhaseId, PhaseGroup, "
"(POW(position_x - %f, 2) + POW(position_y - %f, 2) + POW(position_z - %f, 2)) AS order_ FROM gameobject "
"LEFT OUTER JOIN game_event_gameobject on gameobject.guid = game_event_gameobject.guid WHERE map = '%i' %s ORDER BY order_ ASC LIMIT 10",
handler->GetSession()->GetPlayer()->GetPositionX(), handler->GetSession()->GetPlayer()->GetPositionY(), handler->GetSession()->GetPlayer()->GetPositionZ(),
handler->GetSession()->GetPlayer()->GetMapId(), eventFilter.str().c_str());
}
if (!result)
{
handler->SendSysMessage(LANG_COMMAND_TARGETOBJNOTFOUND);
return true;
}
bool found = false;
float x, y, z, o;
ObjectGuid::LowType guidLow;
uint32 id, phaseId, phaseGroup;
uint16 mapId;
uint32 poolId;
do
{
Field* fields = result->Fetch();
guidLow = fields[0].GetUInt64();
id = fields[1].GetUInt32();
x = fields[2].GetFloat();
y = fields[3].GetFloat();
z = fields[4].GetFloat();
o = fields[5].GetFloat();
mapId = fields[6].GetUInt16();
phaseId = fields[7].GetUInt32();
phaseGroup = fields[8].GetUInt32();
poolId = sPoolMgr->IsPartOfAPool<GameObject>(guidLow);
if (!poolId || sPoolMgr->IsSpawnedObject<GameObject>(guidLow))
found = true;
} while (result->NextRow() && !found);
if (!found)
{
handler->PSendSysMessage(LANG_GAMEOBJECT_NOT_EXIST, id);
return false;
}
GameObjectTemplate const* objectInfo = sObjectMgr->GetGameObjectTemplate(id);
if (!objectInfo)
{
handler->PSendSysMessage(LANG_GAMEOBJECT_NOT_EXIST, id);
return false;
}
GameObject* target = handler->GetSession()->GetPlayer()->GetMap()->GetGameObject(ObjectGuid::Create<HighGuid::GameObject>(mapId, id, guidLow));
handler->PSendSysMessage(LANG_GAMEOBJECT_DETAIL, guidLow, objectInfo->name.c_str(), guidLow, id, x, y, z, mapId, o, phaseId, phaseGroup);
if (target)
{
int32 curRespawnDelay = int32(target->GetRespawnTimeEx() - time(NULL));
if (curRespawnDelay < 0)
curRespawnDelay = 0;
std::string curRespawnDelayStr = secsToTimeString(curRespawnDelay, true);
std::string defRespawnDelayStr = secsToTimeString(target->GetRespawnDelay(), true);
handler->PSendSysMessage(LANG_COMMAND_RAWPAWNTIMES, defRespawnDelayStr.c_str(), curRespawnDelayStr.c_str());
}
return true;
}
void LoadSkillDiscoveryTable()
{
SkillDiscoveryStore.clear(); // need for reload
uint32 count = 0;
// 0 1 2 3
QueryResult *result = WorldDatabase.Query("SELECT spellId, reqSpell, reqSkillValue, chance FROM skill_discovery_template");
if (!result)
{
sLog.outString();
sLog.outString( ">> Loaded 0 skill discovery definitions. DB table `skill_discovery_template` is empty." );
return;
}
barGoLink bar(result->GetRowCount());
std::ostringstream ssNonDiscoverableEntries;
std::set<uint32> reportedReqSpells;
do
{
Field *fields = result->Fetch();
bar.step();
uint32 spellId = fields[0].GetUInt32();
int32 reqSkillOrSpell = fields[1].GetInt32();
uint32 reqSkillValue = fields[2].GetInt32();
float chance = fields[3].GetFloat();
if (chance <= 0) // chance
{
ssNonDiscoverableEntries << "spellId = " << spellId << " reqSkillOrSpell = " << reqSkillOrSpell
<< " reqSkillValue = " << reqSkillValue << " chance = " << chance << "(chance problem)\n";
continue;
}
if (reqSkillOrSpell > 0) // spell case
{
SpellEntry const* reqSpellEntry = sSpellStore.LookupEntry(reqSkillOrSpell);
if (!reqSpellEntry)
{
if(reportedReqSpells.count(reqSkillOrSpell)==0)
{
sLog.outErrorDb("Spell (ID: %u) have not existed spell (ID: %i) in `reqSpell` field in `skill_discovery_template` table",spellId,reqSkillOrSpell);
reportedReqSpells.insert(reqSkillOrSpell);
}
continue;
}
// mechanic discovery
if (reqSpellEntry->Mechanic != MECHANIC_DISCOVERY &&
// explicit discovery ability
!IsExplicitDiscoverySpell(reqSpellEntry))
{
if (reportedReqSpells.count(reqSkillOrSpell)==0)
{
sLog.outErrorDb("Spell (ID: %u) not have MECHANIC_DISCOVERY (28) value in Mechanic field in spell.dbc"
" and not 100%% chance random discovery ability but listed for spellId %u (and maybe more) in `skill_discovery_template` table",
reqSkillOrSpell,spellId);
reportedReqSpells.insert(reqSkillOrSpell);
}
continue;
}
SkillDiscoveryStore[reqSkillOrSpell].push_back( SkillDiscoveryEntry(spellId, reqSkillValue, chance) );
}
else if (reqSkillOrSpell == 0) // skill case
{
SkillLineAbilityMapBounds bounds = sSpellMgr.GetSkillLineAbilityMapBounds(spellId);
if (bounds.first==bounds.second)
{
sLog.outErrorDb("Spell (ID: %u) not listed in `SkillLineAbility.dbc` but listed with `reqSpell`=0 in `skill_discovery_template` table",spellId);
continue;
}
for(SkillLineAbilityMap::const_iterator _spell_idx = bounds.first; _spell_idx != bounds.second; ++_spell_idx)
SkillDiscoveryStore[-int32(_spell_idx->second->skillId)].push_back( SkillDiscoveryEntry(spellId, reqSkillValue, chance) );
}
else
{
sLog.outErrorDb("Spell (ID: %u) have negative value in `reqSpell` field in `skill_discovery_template` table",spellId);
continue;
}
++count;
} while (result->NextRow());
delete result;
sLog.outString();
sLog.outString( ">> Loaded %u skill discovery definitions", count );
if (!ssNonDiscoverableEntries.str().empty())
sLog.outErrorDb("Some items can't be successfully discovered: have in chance field value < 0.000001 in `skill_discovery_template` DB table . List:\n%s",ssNonDiscoverableEntries.str().c_str());
// report about empty data for explicit discovery spells
for(uint32 spell_id = 1; spell_id < sSpellStore.GetNumRows(); ++spell_id)
{
SpellEntry const* spellEntry = sSpellStore.LookupEntry(spell_id);
if (!spellEntry)
continue;
// skip not explicit discovery spells
if (!IsExplicitDiscoverySpell(spellEntry))
continue;
if (SkillDiscoveryStore.find(spell_id)==SkillDiscoveryStore.end())
sLog.outErrorDb("Spell (ID: %u) is 100%% chance random discovery ability but not have data in `skill_discovery_template` table",spell_id);
}
}
void FormationMgr::LoadCreatureFormations()
{
uint32 oldMSTime = getMSTime();
for (CreatureGroupInfoType::iterator itr = CreatureGroupMap.begin(); itr != CreatureGroupMap.end(); ++itr) // for reload case
delete itr->second;
CreatureGroupMap.clear();
//Get group data
QueryResult result = WorldDatabase.Query("SELECT leaderGUID, memberGUID, dist, angle, groupAI, point_1, point_2 FROM creature_formations ORDER BY leaderGUID");
if (!result)
{
TC_LOG_ERROR("server.loading", ">> Loaded 0 creatures in formations. DB table `creature_formations` is empty!");
return;
}
uint32 count = 0;
Field* fields;
FormationInfo* group_member;
do
{
fields = result->Fetch();
//Load group member data
group_member = new FormationInfo();
group_member->leaderGUID = fields[0].GetUInt32();
uint32 memberGUID = fields[1].GetUInt32();
group_member->groupAI = fields[4].GetUInt32();
group_member->point_1 = fields[5].GetUInt16();
group_member->point_2 = fields[6].GetUInt16();
//If creature is group leader we may skip loading of dist/angle
if (group_member->leaderGUID != memberGUID)
{
group_member->follow_dist = fields[2].GetFloat();
group_member->follow_angle = fields[3].GetFloat() * M_PI / 180;
}
else
{
group_member->follow_dist = 0;
group_member->follow_angle = 0;
}
// check data correctness
{
if (!sObjectMgr->GetCreatureData(group_member->leaderGUID))
{
TC_LOG_ERROR("sql.sql", "creature_formations table leader guid %u incorrect (not exist)", group_member->leaderGUID);
delete group_member;
continue;
}
if (!sObjectMgr->GetCreatureData(memberGUID))
{
TC_LOG_ERROR("sql.sql", "creature_formations table member guid %u incorrect (not exist)", memberGUID);
delete group_member;
continue;
}
}
CreatureGroupMap[memberGUID] = group_member;
++count;
}
while (result->NextRow());
TC_LOG_INFO("server.loading", ">> Loaded %u creatures in formations in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
}
void InstanceSaveManager::LoadResetTimes()
{
time_t now = time(NULL);
time_t today = (now / DAY) * DAY;
// NOTE: Use DirectPExecute for tables that will be queried later
// get the current reset times for normal instances (these may need to be updated)
// these are only kept in memory for InstanceSaves that are loaded later
// resettime = 0 in the DB for raid/heroic instances so those are skipped
typedef std::pair<uint32 /*PAIR32(map, difficulty)*/, time_t> ResetTimeMapDiffType;
typedef std::map<uint32, ResetTimeMapDiffType> InstResetTimeMapDiffType;
InstResetTimeMapDiffType instResetTime;
// index instance ids by map/difficulty pairs for fast reset warning send
typedef std::multimap<uint32 /*PAIR32(map, difficulty)*/, uint32 /*instanceid*/ > ResetTimeMapDiffInstances;
typedef std::pair<ResetTimeMapDiffInstances::const_iterator, ResetTimeMapDiffInstances::const_iterator> ResetTimeMapDiffInstancesBounds;
ResetTimeMapDiffInstances mapDiffResetInstances;
QueryResult result = CharacterDatabase.Query("SELECT id, map, difficulty, resettime FROM instance ORDER BY id ASC");
if (result)
{
do
{
Field* fields = result->Fetch();
uint32 instanceId = fields[0].GetUInt32();
// Instances are pulled in ascending order from db and nextInstanceId is initialized with 1,
// so if the instance id is used, increment until we find the first unused one for a potential new instance
if (sMapMgr->GetNextInstanceId() == instanceId)
sMapMgr->SetNextInstanceId(instanceId + 1);
// Mark instance id as being used
sMapMgr->RegisterInstanceId(instanceId);
if (time_t resettime = time_t(fields[3].GetUInt32()))
{
uint32 mapid = fields[1].GetUInt16();
uint32 difficulty = fields[2].GetUInt8();
instResetTime[instanceId] = ResetTimeMapDiffType(MAKE_PAIR32(mapid, difficulty), resettime);
mapDiffResetInstances.insert(ResetTimeMapDiffInstances::value_type(MAKE_PAIR32(mapid, difficulty), instanceId));
}
}
while (result->NextRow());
// update reset time for normal instances with the max creature respawn time + X hours
if (PreparedQueryResult result2 = CharacterDatabase.Query(CharacterDatabase.GetPreparedStatement(CHAR_SEL_MAX_CREATURE_RESPAWNS)))
{
do
{
Field* fields = result2->Fetch();
uint32 instance = fields[1].GetUInt32();
time_t resettime = time_t(fields[0].GetUInt32() + 2 * HOUR);
InstResetTimeMapDiffType::iterator itr = instResetTime.find(instance);
if (itr != instResetTime.end() && itr->second.second != resettime)
{
CharacterDatabase.DirectPExecute("UPDATE instance SET resettime = '" UI64FMTD "' WHERE id = '%u'", uint64(resettime), instance);
itr->second.second = resettime;
}
}
while (result->NextRow());
}
// schedule the reset times
for (InstResetTimeMapDiffType::iterator itr = instResetTime.begin(); itr != instResetTime.end(); ++itr)
if (itr->second.second > now)
ScheduleReset(true, itr->second.second, InstResetEvent(0, PAIR32_LOPART(itr->second.first), Difficulty(PAIR32_HIPART(itr->second.first)), itr->first));
}
// load the global respawn times for raid/heroic instances
uint32 diff = sWorld->getIntConfig(CONFIG_INSTANCE_RESET_TIME_HOUR) * HOUR;
result = CharacterDatabase.Query("SELECT mapid, difficulty, resettime FROM instance_reset");
if (result)
{
do
{
Field* fields = result->Fetch();
uint32 mapid = fields[0].GetUInt16();
Difficulty difficulty = Difficulty(fields[1].GetUInt8());
uint64 oldresettime = fields[2].GetUInt32();
MapDifficultyEntry const* mapDiff = GetMapDifficultyData(mapid, difficulty);
if (!mapDiff)
{
TC_LOG_ERROR("misc", "InstanceSaveManager::LoadResetTimes: invalid mapid(%u)/difficulty(%u) pair in instance_reset!", mapid, difficulty);
CharacterDatabase.DirectPExecute("DELETE FROM instance_reset WHERE mapid = '%u' AND difficulty = '%u'", mapid, difficulty);
continue;
}
// update the reset time if the hour in the configs changes
uint64 newresettime = (oldresettime / DAY) * DAY + diff;
if (oldresettime != newresettime)
CharacterDatabase.DirectPExecute("UPDATE instance_reset SET resettime = '%u' WHERE mapid = '%u' AND difficulty = '%u'", uint32(newresettime), mapid, difficulty);
InitializeResetTimeFor(mapid, difficulty, newresettime);
} while (result->NextRow());
}
// calculate new global reset times for expired instances and those that have never been reset yet
// add the global reset times to the priority queue
for (auto& mapDifficultyPair : sMapDifficultyMap)
{
uint32 mapid = mapDifficultyPair.first;
for (auto& difficultyPair : mapDifficultyPair.second)
{
Difficulty difficulty = Difficulty(difficultyPair.first);
MapDifficultyEntry const* mapDiff = difficultyPair.second;
if (!mapDiff->RaidDuration)
continue;
// the reset_delay must be at least one day
uint32 period = uint32(((mapDiff->RaidDuration * sWorld->getRate(RATE_INSTANCE_RESET_TIME)) / DAY) * DAY);
if (period < DAY)
period = DAY;
time_t t = GetResetTimeFor(mapid, difficulty);
if (!t)
{
// initialize the reset time
t = today + period + diff;
CharacterDatabase.DirectPExecute("INSERT INTO instance_reset VALUES ('%u', '%u', '%u')", mapid, difficulty, (uint32)t);
}
if (t < now)
{
// assume that expired instances have already been cleaned
// calculate the next reset time
t = (t / DAY) * DAY;
t += ((today - t) / period + 1) * period + diff;
CharacterDatabase.DirectPExecute("UPDATE instance_reset SET resettime = '" UI64FMTD "' WHERE mapid = '%u' AND difficulty= '%u'", (uint64)t, mapid, difficulty);
}
InitializeResetTimeFor(mapid, difficulty, t);
// schedule the global reset/warning
uint8 type;
for (type = 1; type < 4; ++type)
if (t - ResetTimeDelay[type - 1] > now)
break;
ScheduleReset(true, t - ResetTimeDelay[type - 1], InstResetEvent(type, mapid, difficulty, 0));
ResetTimeMapDiffInstancesBounds range = mapDiffResetInstances.equal_range(MAKE_PAIR32(mapid, difficulty));
for (; range.first != range.second; ++range.first)
ScheduleReset(true, t - ResetTimeDelay[type - 1], InstResetEvent(type, mapid, difficulty, range.first->second));
}
}
}
void PoolMgr::LoadFromDB()
{
// Pool templates
{
uint32 oldMSTime = getMSTime();
QueryResult result = WorldDatabase.Query("SELECT entry, max_limit FROM pool_template");
if (!result)
{
mPoolTemplate.clear();
TC_LOG_INFO("server.loading", ">> Loaded 0 object pools. DB table `pool_template` is empty.");
return;
}
uint32 count = 0;
do
{
Field* fields = result->Fetch();
uint32 pool_id = fields[0].GetUInt32();
PoolTemplateData& pPoolTemplate = mPoolTemplate[pool_id];
pPoolTemplate.MaxLimit = fields[1].GetUInt32();
++count;
}
while (result->NextRow());
TC_LOG_INFO("server.loading", ">> Loaded %u objects pools in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
}
// Creatures
TC_LOG_INFO("server.loading", "Loading Creatures Pooling Data...");
{
uint32 oldMSTime = getMSTime();
// 1 2 3
QueryResult result = WorldDatabase.Query("SELECT guid, pool_entry, chance FROM pool_creature");
if (!result)
{
TC_LOG_INFO("server.loading", ">> Loaded 0 creatures in pools. DB table `pool_creature` is empty.");
}
else
{
uint32 count = 0;
do
{
Field* fields = result->Fetch();
uint64 guid = fields[0].GetUInt64();
uint32 pool_id = fields[1].GetUInt32();
float chance = fields[2].GetFloat();
CreatureData const* data = sObjectMgr->GetCreatureData(guid);
if (!data)
{
TC_LOG_ERROR("sql.sql", "`pool_creature` has a non existing creature spawn (GUID: " UI64FMTD ") defined for pool id (%u), skipped.", guid, pool_id);
continue;
}
if (pool_id > max_pool_id)
{
TC_LOG_ERROR("sql.sql", "`pool_creature` pool id (%u) is out of range compared to max pool id in `pool_template`, skipped.", pool_id);
continue;
}
if (chance < 0 || chance > 100)
{
TC_LOG_ERROR("sql.sql", "`pool_creature` has an invalid chance (%f) for creature guid (" UI64FMTD ") in pool id (%u), skipped.", chance, guid, pool_id);
continue;
}
PoolTemplateData* pPoolTemplate = &mPoolTemplate[pool_id];
PoolObject plObject = PoolObject(guid, chance);
PoolGroup<Creature>& cregroup = mPoolCreatureGroups[pool_id];
cregroup.SetPoolId(pool_id);
cregroup.AddEntry(plObject, pPoolTemplate->MaxLimit);
SearchPair p(guid, pool_id);
mCreatureSearchMap.insert(p);
++count;
}
while (result->NextRow());
TC_LOG_INFO("server.loading", ">> Loaded %u creatures in pools in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
}
}
// Gameobjects
TC_LOG_INFO("server.loading", "Loading Gameobject Pooling Data...");
{
uint32 oldMSTime = getMSTime();
// 1 2 3
QueryResult result = WorldDatabase.Query("SELECT guid, pool_entry, chance FROM pool_gameobject");
if (!result)
{
TC_LOG_INFO("server.loading", ">> Loaded 0 gameobjects in pools. DB table `pool_gameobject` is empty.");
}
else
{
uint32 count = 0;
do
{
Field* fields = result->Fetch();
uint64 guid = fields[0].GetUInt64();
uint32 pool_id = fields[1].GetUInt32();
float chance = fields[2].GetFloat();
GameObjectData const* data = sObjectMgr->GetGOData(guid);
if (!data)
{
TC_LOG_ERROR("sql.sql", "`pool_gameobject` has a non existing gameobject spawn (GUID: " UI64FMTD ") defined for pool id (%u), skipped.", guid, pool_id);
continue;
}
GameObjectTemplate const* goinfo = sObjectMgr->GetGameObjectTemplate(data->id);
if (goinfo->type != GAMEOBJECT_TYPE_CHEST &&
goinfo->type != GAMEOBJECT_TYPE_FISHINGHOLE &&
goinfo->type != GAMEOBJECT_TYPE_GATHERING_NODE &&
goinfo->type != GAMEOBJECT_TYPE_GOOBER)
{
TC_LOG_ERROR("sql.sql", "`pool_gameobject` has a not lootable gameobject spawn (GUID: " UI64FMTD ", type: %u) defined for pool id (%u), skipped.", guid, goinfo->type, pool_id);
continue;
}
if (pool_id > max_pool_id)
{
TC_LOG_ERROR("sql.sql", "`pool_gameobject` pool id (%u) is out of range compared to max pool id in `pool_template`, skipped.", pool_id);
continue;
}
if (chance < 0 || chance > 100)
{
TC_LOG_ERROR("sql.sql", "`pool_gameobject` has an invalid chance (%f) for gameobject guid (" UI64FMTD ") in pool id (%u), skipped.", chance, guid, pool_id);
continue;
}
PoolTemplateData* pPoolTemplate = &mPoolTemplate[pool_id];
PoolObject plObject = PoolObject(guid, chance);
PoolGroup<GameObject>& gogroup = mPoolGameobjectGroups[pool_id];
gogroup.SetPoolId(pool_id);
gogroup.AddEntry(plObject, pPoolTemplate->MaxLimit);
SearchPair p(guid, pool_id);
mGameobjectSearchMap.insert(p);
++count;
}
while (result->NextRow());
TC_LOG_INFO("server.loading", ">> Loaded %u gameobject in pools in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
}
}
// Pool of pools
TC_LOG_INFO("server.loading", "Loading Mother Pooling Data...");
{
uint32 oldMSTime = getMSTime();
// 1 2 3
QueryResult result = WorldDatabase.Query("SELECT pool_id, mother_pool, chance FROM pool_pool");
if (!result)
{
TC_LOG_INFO("server.loading", ">> Loaded 0 pools in pools");
}
else
{
uint32 count = 0;
do
{
Field* fields = result->Fetch();
uint32 child_pool_id = fields[0].GetUInt32();
uint32 mother_pool_id = fields[1].GetUInt32();
float chance = fields[2].GetFloat();
if (mother_pool_id > max_pool_id)
{
TC_LOG_ERROR("sql.sql", "`pool_pool` mother_pool id (%u) is out of range compared to max pool id in `pool_template`, skipped.", mother_pool_id);
continue;
}
if (child_pool_id > max_pool_id)
{
TC_LOG_ERROR("sql.sql", "`pool_pool` included pool_id (%u) is out of range compared to max pool id in `pool_template`, skipped.", child_pool_id);
continue;
}
if (mother_pool_id == child_pool_id)
{
TC_LOG_ERROR("sql.sql", "`pool_pool` pool_id (%u) includes itself, dead-lock detected, skipped.", child_pool_id);
continue;
}
if (chance < 0 || chance > 100)
{
TC_LOG_ERROR("sql.sql", "`pool_pool` has an invalid chance (%f) for pool id (%u) in mother pool id (%u), skipped.", chance, child_pool_id, mother_pool_id);
continue;
}
PoolTemplateData* pPoolTemplateMother = &mPoolTemplate[mother_pool_id];
PoolObject plObject = PoolObject(child_pool_id, chance);
PoolGroup<Pool>& plgroup = mPoolPoolGroups[mother_pool_id];
plgroup.SetPoolId(mother_pool_id);
plgroup.AddEntry(plObject, pPoolTemplateMother->MaxLimit);
SearchPair p(child_pool_id, mother_pool_id);
mPoolSearchMap.insert(p);
++count;
}
while (result->NextRow());
// Now check for circular reference
for (uint32 i=0; i < max_pool_id; ++i)
{
std::set<uint32> checkedPools;
for (SearchMap::iterator poolItr = mPoolSearchMap.find(i); poolItr != mPoolSearchMap.end(); poolItr = mPoolSearchMap.find(poolItr->second))
{
checkedPools.insert(poolItr->first);
if (checkedPools.find(poolItr->second) != checkedPools.end())
{
std::ostringstream ss;
ss<< "The pool(s) ";
for (std::set<uint32>::const_iterator itr=checkedPools.begin(); itr != checkedPools.end(); ++itr)
ss << *itr << ' ';
ss << "create(s) a circular reference, which can cause the server to freeze.\nRemoving the last link between mother pool "
<< poolItr->first << " and child pool " << poolItr->second;
TC_LOG_ERROR("sql.sql", "%s", ss.str().c_str());
mPoolPoolGroups[poolItr->second].RemoveOneRelation(poolItr->first);
mPoolSearchMap.erase(poolItr);
--count;
break;
}
}
}
TC_LOG_INFO("server.loading", ">> Loaded %u pools in mother pools in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
}
}
TC_LOG_INFO("server.loading", "Loading Quest Pooling Data...");
{
uint32 oldMSTime = getMSTime();
PreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_QUEST_POOLS);
PreparedQueryResult result = WorldDatabase.Query(stmt);
if (!result)
{
TC_LOG_INFO("server.loading", ">> Loaded 0 quests in pools");
}
else
{
PooledQuestRelationBounds creBounds;
PooledQuestRelationBounds goBounds;
enum eQuestTypes
{
QUEST_NONE = 0,
QUEST_DAILY = 1,
QUEST_WEEKLY = 2
};
std::map<uint32, int32> poolTypeMap;
uint32 count = 0;
do
{
Field* fields = result->Fetch();
uint32 entry = fields[0].GetUInt32();
uint32 pool_id = fields[1].GetUInt32();
Quest const* quest = sObjectMgr->GetQuestTemplate(entry);
if (!quest)
{
TC_LOG_ERROR("sql.sql", "`pool_quest` has a non existing quest template (Entry: %u) defined for pool id (%u), skipped.", entry, pool_id);
continue;
}
if (pool_id > max_pool_id)
{
TC_LOG_ERROR("sql.sql", "`pool_quest` pool id (%u) is out of range compared to max pool id in `pool_template`, skipped.", pool_id);
continue;
}
if (!quest->IsDailyOrWeekly())
{
TC_LOG_ERROR("sql.sql", "`pool_quest` has an quest (%u) which is not daily or weekly in pool id (%u), use ExclusiveGroup instead, skipped.", entry, pool_id);
continue;
}
if (poolTypeMap[pool_id] == QUEST_NONE)
poolTypeMap[pool_id] = quest->IsDaily() ? QUEST_DAILY : QUEST_WEEKLY;
int32 currType = quest->IsDaily() ? QUEST_DAILY : QUEST_WEEKLY;
if (poolTypeMap[pool_id] != currType)
{
TC_LOG_ERROR("sql.sql", "`pool_quest` quest %u is %s but pool (%u) is specified for %s, mixing not allowed, skipped.",
entry, currType == QUEST_DAILY ? "QUEST_DAILY" : "QUEST_WEEKLY", pool_id, poolTypeMap[pool_id] == QUEST_DAILY ? "QUEST_DAILY" : "QUEST_WEEKLY");
continue;
}
creBounds = mQuestCreatureRelation.equal_range(entry);
goBounds = mQuestGORelation.equal_range(entry);
if (creBounds.first == creBounds.second && goBounds.first == goBounds.second)
{
TC_LOG_ERROR("sql.sql", "`pool_quest` lists entry (%u) as member of pool (%u) but is not started anywhere, skipped.", entry, pool_id);
continue;
}
PoolTemplateData* pPoolTemplate = &mPoolTemplate[pool_id];
PoolObject plObject = PoolObject(entry, 0.0f);
PoolGroup<Quest>& questgroup = mPoolQuestGroups[pool_id];
questgroup.SetPoolId(pool_id);
questgroup.AddEntry(plObject, pPoolTemplate->MaxLimit);
SearchPair p(entry, pool_id);
mQuestSearchMap.insert(p);
++count;
}
while (result->NextRow());
TC_LOG_INFO("server.loading", ">> Loaded %u quests in pools in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
}
}
// The initialize method will spawn all pools not in an event and not in another pool, this is why there is 2 left joins with 2 null checks
TC_LOG_INFO("server.loading", "Starting objects pooling system...");
{
uint32 oldMSTime = getMSTime();
QueryResult result = WorldDatabase.Query("SELECT DISTINCT pool_template.entry, pool_pool.pool_id, pool_pool.mother_pool FROM pool_template"
" LEFT JOIN game_event_pool ON pool_template.entry=game_event_pool.pool_entry"
" LEFT JOIN pool_pool ON pool_template.entry=pool_pool.pool_id WHERE game_event_pool.pool_entry IS NULL");
if (!result)
{
TC_LOG_INFO("server.loading", ">> Pool handling system initialized, 0 pools spawned.");
}
else
{
uint32 count = 0;
do
{
Field* fields = result->Fetch();
uint32 pool_entry = fields[0].GetUInt32();
uint32 pool_pool_id = fields[1].GetUInt32();
if (!CheckPool(pool_entry))
{
if (pool_pool_id)
// The pool is a child pool in pool_pool table. Ideally we should remove it from the pool handler to ensure it never gets spawned,
// however that could recursively invalidate entire chain of mother pools. It can be done in the future but for now we'll do nothing.
TC_LOG_ERROR("sql.sql", "Pool Id %u has no equal chance pooled entites defined and explicit chance sum is not 100. This broken pool is a child pool of Id %u and cannot be safely removed.", pool_entry, fields[2].GetUInt32());
else
TC_LOG_ERROR("sql.sql", "Pool Id %u has no equal chance pooled entites defined and explicit chance sum is not 100. The pool will not be spawned.", pool_entry);
continue;
}
// Don't spawn child pools, they are spawned recursively by their parent pools
if (!pool_pool_id)
{
SpawnPool(pool_entry);
count++;
}
}
while (result->NextRow());
TC_LOG_DEBUG("pool", "Pool handling system initialized, %u pools spawned in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
}
}
}
void AuctionHouseMgr::LoadAuctions()
{
QueryResult* result = CharacterDatabase.Query("SELECT COUNT(*) FROM auction");
if (!result)
{
BarGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded 0 auctions. DB table `auction` is empty.");
return;
}
Field* fields = result->Fetch();
uint32 AuctionCount = fields[0].GetUInt32();
delete result;
if (!AuctionCount)
{
BarGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded 0 auctions. DB table `auction` is empty.");
return;
}
result = CharacterDatabase.Query("SELECT id,houseid,itemguid,item_template,item_count,item_randompropertyid,itemowner,buyoutprice,time,moneyTime,buyguid,lastbid,startbid,deposit FROM auction");
if (!result)
{
BarGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded 0 auctions. DB table `auction` is empty.");
return;
}
BarGoLink bar(AuctionCount);
typedef UNORDERED_MAP<uint32, std::wstring> PlayerNames;
PlayerNames playerNames; // caching for load time
do
{
fields = result->Fetch();
bar.step();
AuctionEntry* auction = new AuctionEntry;
auction->Id = fields[0].GetUInt32();
uint32 houseid = fields[1].GetUInt32();
auction->itemGuidLow = fields[2].GetUInt32();
auction->itemTemplate = fields[3].GetUInt32();
auction->itemCount = fields[4].GetUInt32();
auction->itemRandomPropertyId = fields[5].GetUInt32();
auction->owner = fields[6].GetUInt32();
if (auction->owner)
{
std::wstring& plWName = playerNames[auction->owner];
if (plWName.empty())
{
std::string plName;
if (!sAccountMgr.GetPlayerNameByGUID(ObjectGuid(HIGHGUID_PLAYER, auction->owner), plName))
plName = sObjectMgr.GetMangosStringForDBCLocale(LANG_UNKNOWN);
Utf8toWStr(plName, plWName);
}
auction->ownerName = plWName;
}
auction->buyout = fields[7].GetUInt64();
auction->expireTime = time_t(fields[8].GetUInt64());
auction->moneyDeliveryTime = time_t(fields[9].GetUInt64());
auction->bidder = fields[10].GetUInt32();
auction->bid = fields[11].GetUInt64();
auction->startbid = fields[12].GetUInt64();
auction->deposit = fields[13].GetUInt64();
auction->auctionHouseEntry = NULL; // init later
if (auction->moneyDeliveryTime)
auction->itemGuidLow = 0; // must be 0 if auction delivery pending
else
{
// check if sold item exists for guid
// and item_template in fact (GetAItem will fail if problematic in result check in AuctionHouseMgr::LoadAuctionItems)
Item* pItem = GetAItem(auction->itemGuidLow);
if (!pItem)
{
auction->DeleteFromDB();
sLog.outError("Auction %u has not a existing item : %u, deleted", auction->Id, auction->itemGuidLow);
delete auction;
continue;
}
// overwrite by real item data
if ((auction->itemTemplate != pItem->GetEntry()) ||
(auction->itemCount != pItem->GetCount()) ||
(auction->itemRandomPropertyId != pItem->GetItemRandomPropertyId()))
{
auction->itemTemplate = pItem->GetEntry();
auction->itemCount = pItem->GetCount();
auction->itemRandomPropertyId = pItem->GetItemRandomPropertyId();
// No SQL injection (no strings)
CharacterDatabase.PExecute("UPDATE auction SET item_template = %u, item_count = %u, item_randompropertyid = %i WHERE itemguid = %u",
auction->itemTemplate, auction->itemCount, auction->itemRandomPropertyId, auction->itemGuidLow);
}
}
auction->auctionHouseEntry = sAuctionHouseStore.LookupEntry(houseid);
if (!auction->auctionHouseEntry)
{
// need for send mail, use goblin auctionhouse
auction->auctionHouseEntry = sAuctionHouseStore.LookupEntry(7);
// Attempt send item back to owner
std::ostringstream msgAuctionCanceledOwner;
msgAuctionCanceledOwner << auction->itemTemplate << ":" << auction->itemRandomPropertyId << ":" << AUCTION_CANCELED << ":" << auction->Id << ":" << auction->itemCount;
if (auction->itemGuidLow)
{
Item* pItem = GetAItem(auction->itemGuidLow);
RemoveAItem(auction->itemGuidLow);
auction->itemGuidLow = 0;
// item will deleted or added to received mail list
MailDraft(msgAuctionCanceledOwner.str(), "")// TODO: fix body
.AddItem(pItem)
.SendMailTo(MailReceiver(ObjectGuid(HIGHGUID_PLAYER, auction->owner)), auction, MAIL_CHECK_MASK_COPIED);
}
auction->DeleteFromDB();
delete auction;
continue;
}
GetAuctionsMap(auction->auctionHouseEntry)->AddAuction(auction);
}
while (result->NextRow());
delete result;
sLog.outString();
sLog.outString(">> Loaded %u auctions", AuctionCount);
}
static bool HandleBoutiqueLevelCommand(ChatHandler *handler, const char *args) {
const char* reqcount = "SELECT id FROM boutique_service_achat WHERE accountId='%u' AND type=1 AND recup=0 LIMIT 1";
sLog->outDebug(LOG_FILTER_NETWORKIO, reqcount, handler->GetSession()->GetAccountId());
QueryResult resultcount = LoginDatabase.PQuery(reqcount, handler->GetSession()->GetAccountId());
if (!resultcount) {
//Vous ne disposez actuellement d'aucun service de ce type. Vous pouvez acheter ce service sur la boutique
handler->PSendSysMessage(11016);
return true;
}
Field* fieldscount = resultcount->Fetch();
const char* qmask = "SELECT 1 FROM boutique_service WHERE realmMask & '%u' != 0 and type = 1";
QueryResult reqmask = LoginDatabase.PQuery(qmask, (1<<(realmID-1)));
if (!reqmask) {
//Ce produit ou service n'est pas disponible pour ce royaume.
handler->PSendSysMessage(11018);
return true;
}
int id = fieldscount[0].GetInt32();
Player* target = handler->GetSession()->GetPlayer();
if (target) {
int levelToAdd = 0;
int level = target->getLevel();
if (level<40) levelToAdd = 8;
else if (level<50) levelToAdd = 8;
else if (level<60) levelToAdd = 7;
else if (level<70) levelToAdd = 6;
else if (level<75) levelToAdd = 5;
else if (level<80) levelToAdd = 4;
else if (level<83) levelToAdd = 3;
else if (level<86) levelToAdd = 2;
else if (level<90) levelToAdd = 1;
else {
return false;
}
uint32 oldlevel = target->getLevel();
uint32 newlevel = target->getLevel()+levelToAdd;
if (target)
{
target->GiveLevel(newlevel);
target->InitTalentForLevel();
target->SetUInt32Value(PLAYER_XP,0);
if (handler->needReportToTarget(target))
{
if (oldlevel == newlevel)
handler->PSendSysMessage(559,handler->GetNameLink().c_str());
else if (oldlevel < newlevel)
handler->PSendSysMessage(557,handler->GetNameLink().c_str(),newlevel);
else // if (oldlevel > newlevel)
handler->PSendSysMessage(558,handler->GetNameLink().c_str(),newlevel);
}
}
else
{
// update level and XP at level, all other will be updated at loading
CharacterDatabase.PExecute("UPDATE characters SET level = '%u', xp = 0 WHERE guid = '%u'", newlevel, GUID_LOPART(target->GetGUIDLow()));
}
target->SaveToDB();
const char* requpdate = "UPDATE boutique_service_achat SET realmID = '%u', recup='%u' WHERE id='%u'";
LoginDatabase.PExecute(requpdate, realmID, (uint32)handler->GetSession()->GetPlayer()->GetGUID(), id);
}
return true;
}