void RealmList::UpdateRealms(bool init) { sLog.outDetail("Updating Realm List..."); // 0 1 2 3 4 5 6 7 8 9 QueryResult_AutoPtr result = LoginDatabase.Query( "SELECT id, name, address, port, icon, flag, timezone, allowedSecurityLevel, population, gamebuild FROM realmlist WHERE (flag & 1) = 0 ORDER BY name" ); // Circle through results and add them to the realm map if (result) { do { Field *fields = result->Fetch(); uint8 allowedSecurityLevel = fields[7].GetUInt8(); uint8 realmflags = fields[5].GetUInt8(); if (realmflags & ~(REALM_FLAG_OFFLINE|REALM_FLAG_NEW_PLAYERS|REALM_FLAG_RECOMMENDED|REALM_FLAG_SPECIFYBUILD)) { sLog.outError("Realm allowed have only OFFLINE Mask 0x2), or NEWPLAYERS (mask 0x20), or RECOMENDED (mask 0x40), or SPECIFICBUILD (mask 0x04) flags in DB"); realmflags &= (REALM_FLAG_OFFLINE|REALM_FLAG_NEW_PLAYERS|REALM_FLAG_RECOMMENDED|REALM_FLAG_SPECIFYBUILD); } UpdateRealm( fields[0].GetUInt32(), fields[1].GetCppString(),fields[2].GetCppString(),fields[3].GetUInt32(), fields[4].GetUInt8(), RealmFlags(realmflags), fields[6].GetUInt8(), (allowedSecurityLevel <= SEC_ADMINISTRATOR ? AccountTypes(allowedSecurityLevel) : SEC_ADMINISTRATOR), fields[8].GetFloat(), fields[9].GetString()); if (init) sLog.outString("Added realm \"%s\"", fields[1].GetString()); } while ( result->NextRow() ); } }
bool showBuyList(Player *player, Creature *_creature, uint32 showFromId = 0) { //show not occupied guildhouses QueryResult_AutoPtr result; result = WorldDatabase.PQuery("SELECT `id`, `comment` FROM `guildhouses` WHERE `guildId` = 0 AND `id` > %u ORDER BY `id` ASC LIMIT %u",showFromId, GOSSIP_COUNT_MAX); // QueryResult_AutoPtr result2; // result2 = WorldDatabase.PQuery("SELECT count(id) FROM `guildhouses` WHERE `guildId` = 0 "); // if (result2) // { if (result) { uint32 guildhouseId = 0; std::string comment = ""; do { Field *fields = result->Fetch(); guildhouseId = fields[0].GetInt32(); comment = fields[1].GetString(); //send comment as a gossip item //transmit guildhouseId in Action variable player->ADD_GOSSIP_ITEM(ICON_GOSSIP_TABARD, comment, GOSSIP_SENDER_MAIN, guildhouseId + OFFSET_GH_ID_TO_ACTION); } while (result->NextRow()); if (result->GetRowCount() == GOSSIP_COUNT_MAX) { //assume that we have additional page //add link to next GOSSIP_COUNT_MAX items player->ADD_GOSSIP_ITEM(ICON_GOSSIP_BALOONDOTS, MSG_GOSSIP_NEXTPAGE, GOSSIP_SENDER_MAIN, guildhouseId + OFFSET_SHOWBUY_FROM); } //delete result; player->SEND_GOSSIP_MENU(DEFAULT_GOSSIP_MESSAGE, _creature->GetGUID()); return true; } else { if (showFromId == 0) { //all guildhouses are occupied _creature->MonsterWhisper(MSG_NOFREEGH, player->GetGUID()); player->CLOSE_GOSSIP_MENU(); } else { //this condition occurs when COUNT(guildhouses) % GOSSIP_COUNT_MAX == 0 //just show GHs from beginning //showBuyList(player, _creature, 0); } } return false; }
void AuctionHouseObject::Update() { time_t curTime = sWorld.GetGameTime(); // Handle expired auctions // If storage is empty, no need to update. next == NULL in this case. if (AuctionsMap.empty()) return; QueryResult_AutoPtr result = CharacterDatabase.PQuery("SELECT id FROM auctionhouse WHERE time <= %u ORDER BY TIME ASC", (uint32)curTime+60); if (!result) return; if (result->GetRowCount() == 0) return; vector<uint32> expiredAuctions; do { uint32 tmpdata = result->Fetch()->GetUInt32(); expiredAuctions.push_back(tmpdata); } while (result->NextRow()); while (!expiredAuctions.empty()) { vector<uint32>::iterator iter = expiredAuctions.begin(); // from auctionhousehandler.cpp, creates auction pointer & player pointer AuctionEntry* auction = GetAuction(*iter); // Erase the auction from the vector. expiredAuctions.erase(iter); if (!auction) continue; ///- Either cancel the auction if there was no bidder if (auction->bidder == 0) sAuctionMgr->SendAuctionExpiredMail(auction); ///- Or perform the transaction else { //we should send an "item sold" message if the seller is online //we send the item to the winner //we send the money to the seller sAuctionMgr->SendAuctionSuccessfulMail(auction); sAuctionMgr->SendAuctionWonMail(auction); } ///- In any case clear the auction CharacterDatabase.BeginTransaction(); auction->DeleteFromDB(); uint32 item_template = auction->item_template; sAuctionMgr->RemoveAItem(auction->item_guidlow); RemoveAuction(auction, item_template); CharacterDatabase.CommitTransaction(); } }
void ArenaTeam::LoadMembersFromDB(uint32 ArenaTeamId) { // 0 1 2 3 4 5 6 7 QueryResult_AutoPtr result = CharacterDatabase.PQuery("SELECT member.guid,played_week,wons_week,played_season,wons_season,personal_rating,name,class " "FROM arena_team_member member " "INNER JOIN characters chars on member.guid = chars.guid " "WHERE member.arenateamid = '%u'", ArenaTeamId); if (!result) return; do { Field *fields = result->Fetch(); ArenaTeamMember newmember; newmember.guid = MAKE_NEW_GUID(fields[0].GetUInt32(), 0, HIGHGUID_PLAYER); newmember.games_week = fields[1].GetUInt32(); newmember.wins_week = fields[2].GetUInt32(); newmember.games_season = fields[3].GetUInt32(); newmember.wins_season = fields[4].GetUInt32(); newmember.personal_rating = fields[5].GetUInt32(); newmember.name = fields[6].GetCppString(); newmember.Class = fields[7].GetUInt8(); m_members.push_back(newmember); }while (result->NextRow()); }
// 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 void PoolHandler::Initialize() { QueryResult_AutoPtr result = WorldDatabase.Query("SELECT DISTINCT pool_template.entry 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 AND pool_pool.pool_id IS NULL"); uint32 count=0; if (result) { do { Field *fields = result->Fetch(); uint16 pool_entry = fields[0].GetUInt16(); if (!CheckPool(pool_entry)) { sLog.outErrorDb("Pool Id (%u) has all creatures or gameobjects with explicit chance sum <>100 and no equal chance defined. The pool system cannot pick one to spawn.", pool_entry); continue; } SpawnPool(pool_entry, 0, 0); SpawnPool(pool_entry, 0, TYPEID_GAMEOBJECT); SpawnPool(pool_entry, 0, TYPEID_UNIT); count++; } while (result->NextRow()); } sLog.outBasic("Pool handling system initialized, %u pools spawned.", count); m_IsPoolSystemStarted = true; }
void AddonMgr::LoadFromDB() { QueryResult_AutoPtr result = CharacterDatabase.PQuery("SELECT name, crc FROM addons"); if(!result) { sLog.outErrorDb("The table `addons` is empty"); return; } barGoLink bar(result->GetRowCount()); uint32 count = 0; Field *fields; do { fields = result->Fetch(); bar.step(); count++; std::string name = fields[0].GetCppString(); uint32 crc = fields[1].GetUInt32(); SavedAddon addon(name, crc); m_knownAddons.push_back(addon); } while(result->NextRow()); sLog.outString(); sLog.outString(">> Loaded %u known addons", count); }
void WorldSession::HandleCharEnum(QueryResult_AutoPtr result) { // keys can be non cleared if player open realm list and close it by 'cancel' LoginDatabase.PExecute("UPDATE account SET v = '0', s = '0' WHERE id = '%u'", GetAccountId()); WorldPacket data(SMSG_CHAR_ENUM, 100); // we guess size uint8 num = 0; data << num; if (result ) { Player *plr = new Player(this); do { uint32 guidlow = (*result)[0].GetUInt32(); sLog.outDetail("Loading char guid %u from account %u.",guidlow,GetAccountId()); if (plr->MinimalLoadFromDB(result, guidlow )) { plr->BuildEnumData(result, &data); ++num; } } while (result->NextRow()); delete plr; } data.put<uint8>(0, num); SendPacket(&data); }
void CreatureTextMgr::LoadCreatureTextLocales() { uint32 oldMSTime = getMSTime(); mLocaleTextMap.clear(); // for reload case QueryResult_AutoPtr result = WorldDatabase.Query("SELECT entry, groupid, id, text_loc1, text_loc2, text_loc3, text_loc4, text_loc5, text_loc6, text_loc7, text_loc8 FROM locales_creature_text"); if (!result) return; uint32 textCount = 0; do { Field* fields = result->Fetch(); CreatureTextLocale& loc = mLocaleTextMap[CreatureTextId(fields[0].GetUInt32(), uint32(fields[1].GetUInt8()), uint32(fields[2].GetUInt8()))]; for (uint8 i = MAX_LOCALE - 1; i > 0; --i) { LocaleConstant locale = LocaleConstant(i); ObjectMgr::AddLocaleString(fields[3 + i - 1].GetString(), locale, loc.Text); } ++textCount; } while (result->NextRow()); sLog.outString(">> Loaded %u creature localized texts in %u ms", textCount, GetMSTimeDiffToNow(oldMSTime)); }
void RealmList::UpdateRealms(bool init) { sLog->outDetail("Updating Realm List..."); QueryResult_AutoPtr result = LoginDatabase.Query("SELECT id, name, address, port, icon, color, timezone, allowedSecurityLevel, population, gamebuild FROM realmlist WHERE color <> 3 ORDER BY name"); // Circle through results and add them to the realm map if (result) { do { Field* fields = result->Fetch(); uint32 realmId = fields[0].GetUInt32(); const std::string& name = fields[1].GetString(); const std::string& address = fields[2].GetString(); uint32 port = fields[3].GetUInt32(); uint8 icon = fields[4].GetUInt8(); uint8 color = fields[5].GetUInt8(); uint8 timezone = fields[6].GetUInt8(); uint8 allowedSecurityLevel = fields[7].GetUInt8(); float pop = fields[8].GetFloat(); uint32 build = fields[9].GetUInt32(); UpdateRealm(realmId, name, address, port, icon, color, timezone, (allowedSecurityLevel <= SEC_ADMINISTRATOR ? AccountTypes(allowedSecurityLevel) : SEC_ADMINISTRATOR), pop, build); if (init) sLog->outString("Added realm \"%s\".", fields[1].GetString()); } while (result->NextRow()); } }
void InstanceSaveManager::_DelHelper(DatabaseType &db, const char *fields, const char *table, const char *queryTail,...) { Tokens fieldTokens = StrSplit(fields, ", "); ASSERT(fieldTokens.size() != 0); va_list ap; char szQueryTail [MAX_QUERY_LEN]; va_start(ap, queryTail); vsnprintf(szQueryTail, MAX_QUERY_LEN, queryTail, ap); va_end(ap); QueryResult_AutoPtr result = db.PQuery("SELECT %s FROM %s %s", fields, table, szQueryTail); if (result) { do { Field *fields = result->Fetch(); std::ostringstream ss; for (size_t i = 0; i < fieldTokens.size(); i++) { std::string fieldValue = fields[i].GetCppString(); db.escape_string(fieldValue); ss << (i != 0 ? " AND " : "") << fieldTokens[i] << " = '" << fieldValue << "'"; } db.DirectPExecute("DELETE FROM %s WHERE %s", table, ss.str().c_str()); } while (result->NextRow()); } }
// 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 void PoolMgr::Initialize() { QueryResult_AutoPtr 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"); uint32 count = 0; if (result) { do { Field *fields = result->Fetch(); uint16 pool_entry = fields[0].GetUInt16(); uint16 pool_pool_id = fields[1].GetUInt16(); 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. sLog->outErrorDb("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].GetUInt16()); else sLog->outErrorDb("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()); } sLog->outBasic("Pool handling system initialized, %u pools spawned.", count); }
bool ArenaTeam::LoadMembersFromDB(QueryResult_AutoPtr 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; ArenaTeamMember newmember; newmember.guid = MAKE_NEW_GUID(fields[1].GetUInt32(), 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.personal_rating = fields[6].GetUInt32(); newmember.name = fields[7].GetCppString(); newmember.Class = fields[8].GetUInt8(); //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 WorldSession::LoadAccountData(QueryResult_AutoPtr result, uint32 mask) { for (uint32 i = 0; i < NUM_ACCOUNT_DATA_TYPES; ++i) if (mask & (1 << i)) m_accountData[i] = AccountData(); if (!result) return; do { Field *fields = result->Fetch(); uint32 type = fields[0].GetUInt32(); if (type >= NUM_ACCOUNT_DATA_TYPES) { sLog.outError("Table `%s` have invalid account data type (%u), ignore.", mask == GLOBAL_CACHE_MASK ? "account_data" : "character_account_data", type); continue; } if ((mask & (1 << type)) == 0) { sLog.outError("Table `%s` have non appropriate for table account data type (%u), ignore.", mask == GLOBAL_CACHE_MASK ? "account_data" : "character_account_data", type); continue; } m_accountData[type].Time = fields[1].GetUInt32(); m_accountData[type].Data = fields[2].GetCppString(); } while (result->NextRow()); }
void WorldSession::HandleStablePet(WorldPacket& recv_data) { sLog->outDebug("WORLD: Recv CMSG_STABLE_PET"); uint64 npcGUID; recv_data >> npcGUID; if (!GetPlayer()->isAlive()) return; Creature *unit = GetPlayer()->GetNPCIfCanInteractWith(npcGUID, UNIT_NPC_FLAG_STABLEMASTER); if (!unit) { sLog->outDebug("WORLD: HandleStablePet - Unit (GUID: %u) not found or you can not interact with him.", uint32(GUID_LOPART(npcGUID))); return; } // remove fake death if (GetPlayer()->hasUnitState(UNIT_STAT_DIED)) GetPlayer()->RemoveSpellsCausingAura(SPELL_AURA_FEIGN_DEATH); Pet *pet = _player->GetPet(); WorldPacket data(SMSG_STABLE_RESULT, 200); // guess size // can't place in stable dead pet if (!pet||!pet->isAlive()||pet->getPetType() != HUNTER_PET) { data << uint8(0x06); SendPacket(&data); return; } uint32 free_slot = 1; QueryResult_AutoPtr result = CharacterDatabase.PQuery("SELECT owner, slot, id FROM character_pet WHERE owner = '%u' AND slot > 0 AND slot < 3 ORDER BY slot ", _player->GetGUIDLow()); if (result) { do { Field *fields = result->Fetch(); uint32 slot = fields[1].GetUInt32(); if (slot == free_slot) // this slot not free ++free_slot; }while (result->NextRow()); } if (free_slot > 0 && free_slot <= GetPlayer()->m_stableSlots) { _player->RemovePet(pet, PetSaveMode(free_slot)); data << uint8(0x08); } else data << uint8(0x06); SendPacket(&data); }
void ReputationMgr::LoadFromDB(QueryResult_AutoPtr result) { // Set initial reputations (so everything is nifty before DB data load) Initialize(); //QueryResult *result = CharacterDatabase.PQuery("SELECT faction,standing,flags FROM character_reputation WHERE guid = '%u'",GetGUIDLow()); if (result) { do { Field *fields = result->Fetch(); FactionEntry const *factionEntry = sFactionStore.LookupEntry(fields[0].GetUInt32()); if (factionEntry && (factionEntry->reputationListID >= 0)) { FactionState* faction = &_factions[factionEntry->reputationListID]; // update standing to current faction->Standing = int32(fields[1].GetUInt32()); uint32 dbFactionFlags = fields[2].GetUInt32(); if (dbFactionFlags & FACTION_FLAG_VISIBLE) SetVisible(faction); // have internal checks for forced invisibility if (dbFactionFlags & FACTION_FLAG_INACTIVE) SetInactive(faction, true); // have internal checks for visibility requirement if (dbFactionFlags & FACTION_FLAG_AT_WAR) // DB at war SetAtWar(faction, true); // have internal checks for FACTION_FLAG_PEACE_FORCED else // DB not at war { // allow remove if visible (and then not FACTION_FLAG_INVISIBLE_FORCED or FACTION_FLAG_HIDDEN) if (faction->Flags & FACTION_FLAG_VISIBLE) SetAtWar(faction, false); // have internal checks for FACTION_FLAG_PEACE_FORCED } // set atWar for hostile ForcedReactions::const_iterator forceItr = _forcedReactions.find(factionEntry->ID); if (forceItr != _forcedReactions.end()) { if (forceItr->second <= REP_HOSTILE) SetAtWar(faction, true); } else if (GetRank(factionEntry) <= REP_HOSTILE) SetAtWar(faction, true); // reset changed flag if values similar to saved in DB if (faction->Flags == dbFactionFlags) { faction->needSend = false; faction->needSave = false; } } } while (result->NextRow()); } }
void SystemMgr::LoadScriptWaypoints() { // Drop Existing Waypoint list m_mPointMoveMap.clear(); uint64 uiCreatureCount = 0; // Load Waypoints QueryResult_AutoPtr Result = WorldDatabase.Query("SELECT COUNT(entry) FROM script_waypoint GROUP BY entry"); if (Result) uiCreatureCount = Result->GetRowCount(); sLog->outString("TSCR: Loading Script Waypoints for %u creature(s)...", uiCreatureCount); Result = WorldDatabase.Query("SELECT entry, pointid, location_x, location_y, location_z, waittime FROM script_waypoint ORDER BY pointid"); if (Result) { uint32 uiNodeCount = 0; do { Field* pFields = Result->Fetch(); ScriptPointMove pTemp; pTemp.uiCreatureEntry = pFields[0].GetUInt32(); uint32 uiEntry = pTemp.uiCreatureEntry; pTemp.uiPointId = pFields[1].GetUInt32(); pTemp.fX = pFields[2].GetFloat(); pTemp.fY = pFields[3].GetFloat(); pTemp.fZ = pFields[4].GetFloat(); pTemp.uiWaitTime = pFields[5].GetUInt32(); CreatureTemplate const* pCInfo = GetCreatureTemplateStore(pTemp.uiCreatureEntry); if (!pCInfo) { sLog->outErrorDb("TSCR: DB table script_waypoint has waypoint for non-existant creature entry %u", pTemp.uiCreatureEntry); continue; } if (!pCInfo->ScriptID) sLog->outErrorDb("TSCR: DB table script_waypoint has waypoint for creature entry %u, but creature does not have ScriptName defined and then useless.", pTemp.uiCreatureEntry); m_mPointMoveMap[uiEntry].push_back(pTemp); ++uiNodeCount; } while (Result->NextRow()); sLog->outString(""); sLog->outString(">> Loaded %u Script Waypoint nodes.", uiNodeCount); } else { sLog->outString(""); sLog->outString(">> Loaded 0 Script Waypoints. DB table script_waypoint is empty."); } }
void SystemMgr::LoadScriptTexts() { LoadOregonStrings(WorldDatabase, "script_texts", TEXT_SOURCE_RANGE, 1 + (TEXT_SOURCE_RANGE * 2)); QueryResult_AutoPtr Result = WorldDatabase.Query("SELECT entry, sound, type, language, emote FROM script_texts"); if (Result) { uint32 uiCount = 0; do { Field* pFields = Result->Fetch(); StringTextData pTemp; int32 iId = pFields[0].GetInt32(); pTemp.uiSoundId = pFields[1].GetUInt32(); pTemp.uiType = pFields[2].GetUInt32(); pTemp.uiLanguage = pFields[3].GetUInt32(); pTemp.uiEmote = pFields[4].GetUInt32(); if (iId >= 0) { error_db_log("OSCR: Entry %i in table script_texts is not a negative value.", iId); continue; } if (iId > TEXT_SOURCE_RANGE || iId <= TEXT_SOURCE_RANGE * 2) { error_db_log("OSCR: Entry %i in table script_texts is out of accepted entry range for table.", iId); continue; } if (pTemp.uiSoundId) { if (!GetSoundEntriesStore()->LookupEntry(pTemp.uiSoundId)) error_db_log("OSCR: Entry %i in table script_texts has soundId %u but sound does not exist.", iId, pTemp.uiSoundId); } if (!GetLanguageDescByID(pTemp.uiLanguage)) error_db_log("OSCR: Entry %i in table script_texts using Language %u but Language does not exist.", iId, pTemp.uiLanguage); if (pTemp.uiType > CHAT_TYPE_ZONE_YELL) error_db_log("OSCR: Entry %i in table script_texts has Type %u but this Chat Type does not exist.", iId, pTemp.uiType); m_mTextDataMap[iId] = pTemp; ++uiCount; } while (Result->NextRow()); outstring_log(">> Loaded %u additional Script Texts data.", uiCount); } else outstring_log(">> Loaded 0 additional Script Texts data. DB table script_texts is empty."); }
// ------------------- void CreatureEventAIMgr::LoadCreatureEventAI_Summons(bool check_entry_use) { //Drop Existing EventSummon Map m_CreatureEventAI_Summon_Map.clear(); // Gather additional data for EventAI QueryResult_AutoPtr result = WorldDatabase.Query("SELECT id, position_x, position_y, position_z, orientation, spawntimesecs FROM creature_ai_summons"); if (result) { barGoLink bar(result->GetRowCount()); uint32 Count = 0; do { bar.step(); Field *fields = result->Fetch(); CreatureEventAI_Summon temp; uint32 i = fields[0].GetUInt32(); temp.position_x = fields[1].GetFloat(); temp.position_y = fields[2].GetFloat(); temp.position_z = fields[3].GetFloat(); temp.orientation = fields[4].GetFloat(); temp.SpawnTimeSecs = fields[5].GetUInt32(); if (!Oregon::IsValidMapCoord(temp.position_x,temp.position_y,temp.position_z,temp.orientation)) { sLog.outErrorDb("CreatureEventAI: Summon id %u has invalid coordinates (%f,%f,%f,%f), skipping.", i,temp.position_x,temp.position_y,temp.position_z,temp.orientation); continue; } //Add to map m_CreatureEventAI_Summon_Map[i] = temp; ++Count; } while (result->NextRow()); if (check_entry_use) CheckUnusedAISummons(); sLog.outString(); sLog.outString(">> Loaded %u CreatureEventAI summon definitions", Count); } else { barGoLink bar(1); bar.step(); sLog.outString(); sLog.outString(">> Loaded 0 CreatureEventAI Summon definitions. DB table creature_ai_summons is empty."); } }
void WorldSession::HandlePetitionShowSignOpcode(WorldPacket & recv_data) { // ok sLog.outDebug("Received opcode CMSG_PETITION_SHOW_SIGNATURES"); uint8 signs = 0; uint64 petitionguid; recv_data >> petitionguid; // petition guid // solve (possible) some strange compile problems with explicit use GUID_LOPART(petitionguid) at some GCC versions (wrong code optimization in compiler?) uint32 petitionguid_low = GUID_LOPART(petitionguid); QueryResult_AutoPtr result = CharacterDatabase.PQuery("SELECT type FROM petition WHERE petitionguid = '%u'", petitionguid_low); if (!result) { sLog.outError("any petition on server..."); return; } Field *fields = result->Fetch(); uint32 type = fields[0].GetUInt32(); // if guild petition and has guild => error, return; if (type == 9 && _player->GetGuildId()) return; result = CharacterDatabase.PQuery("SELECT playerguid FROM petition_sign WHERE petitionguid = '%u'", petitionguid_low); // result == NULL also correct in case no sign yet if (result) signs = result->GetRowCount(); sLog.outDebug("CMSG_PETITION_SHOW_SIGNATURES petition entry: '%u'", petitionguid_low); WorldPacket data(SMSG_PETITION_SHOW_SIGNATURES, (8+8+4+1+signs*12)); data << petitionguid; // petition guid data << _player->GetGUID(); // owner guid data << petitionguid_low; // guild guid (in Oregon always same as GUID_LOPART(petitionguid) data << signs; // sign's count for (uint8 i = 1; i <= signs; ++i) { Field *fields = result->Fetch(); uint64 plguid = fields[0].GetUInt64(); data << plguid; // Player GUID data << (uint32)0; // there 0 ... result->NextRow(); } SendPacket(&data); }
void AuctionHouseMgr::LoadAuctionItems() { // data needs to be at first place for Item::LoadFromDB QueryResult_AutoPtr result = CharacterDatabase.Query("SELECT data,itemguid,item_template FROM auctionhouse JOIN item_instance ON itemguid = guid"); if (!result) { barGoLink bar(1); bar.step(); sLog.outString(); sLog.outString(">> Loaded 0 auction items"); return; } barGoLink bar(result->GetRowCount()); uint32 count = 0; Field *fields; do { bar.step(); fields = result->Fetch(); uint32 item_guid = fields[1].GetUInt32(); uint32 item_template = fields[2].GetUInt32(); ItemPrototype const *proto = objmgr.GetItemPrototype(item_template); if (!proto) { sLog.outError("AuctionHouseMgr::LoadAuctionItems: Unknown item (GUID: %u id: #%u) in auction, skipped.", item_guid,item_template); continue; } Item *item = NewItemOrBag(proto); if (!item->LoadFromDB(item_guid,0, result)) { delete item; continue; } AddAItem(item); ++count; } while (result->NextRow()); sLog.outString(); sLog.outString(">> Loaded %u auction items", count); }
void WorldSession::SendStablePet(uint64 guid ) { sLog.outDebug("WORLD: Recv MSG_LIST_STABLED_PETS Send."); WorldPacket data(MSG_LIST_STABLED_PETS, 200); // guess size data << uint64 ( guid ); Pet *pet = _player->GetPet(); size_t wpos = data.wpos(); data << uint8(0); // place holder for slot show number data << uint8(GetPlayer()->m_stableSlots); uint8 num = 0; // counter for place holder // not let move dead pet in slot if (pet && pet->isAlive() && pet->getPetType()==HUNTER_PET) { data << uint32(pet->GetCharmInfo()->GetPetNumber()); data << uint32(pet->GetEntry()); data << uint32(pet->getLevel()); data << pet->GetName(); // petname data << uint8(1); // 1 = current, 2/3 = in stable (any from 4,5,... create problems with proper show) ++num; } // 0 1 2 3 4 QueryResult_AutoPtr result = CharacterDatabase.PQuery("SELECT owner, id, entry, level, name FROM character_pet WHERE owner = '%u' AND slot >= '%u' AND slot <= '%u' ORDER BY slot", _player->GetGUIDLow(),PET_SAVE_FIRST_STABLE_SLOT,PET_SAVE_LAST_STABLE_SLOT); if (result) { do { Field *fields = result->Fetch(); data << uint32(fields[1].GetUInt32()); // petnumber data << uint32(fields[2].GetUInt32()); // creature entry data << uint32(fields[3].GetUInt32()); // level data << fields[4].GetString(); // name data << uint8(2); // 1 = current, 2/3 = in stable (any from 4,5,... create problems with proper show) ++num; } while( result->NextRow() ); } data.put<uint8>(wpos, num); // set real data to placeholder SendPacket(&data); }
void WorldSession::SendStablePet(uint64 guid) { sLog->outDebug("WORLD: Recv MSG_LIST_STABLED_PETS Send."); WorldPacket data(MSG_LIST_STABLED_PETS, 200); // guess size data << uint64 (guid); Pet *pet = _player->GetPet(); data << uint8(0); // place holder for slot show number data << uint8(GetPlayer()->m_stableSlots); uint8 num = 0; // counter for place holder // not let move dead pet in slot if (pet && pet->isAlive() && pet->getPetType() == HUNTER_PET) { data << uint32(pet->GetCharmInfo()->GetPetNumber()); data << uint32(pet->GetEntry()); data << uint32(pet->getLevel()); data << pet->GetName(); // petname data << uint32(pet->GetLoyaltyLevel()); // loyalty data << uint8(0x01); // client slot 1 == current pet (0) ++num; } // 0 1 2 3 4 5 6 QueryResult_AutoPtr result = CharacterDatabase.PQuery("SELECT owner, slot, id, entry, level, loyalty, name FROM character_pet WHERE owner = '%u' AND slot > 0 AND slot < 3", _player->GetGUIDLow()); if (result) { do { Field *fields = result->Fetch(); data << uint32(fields[2].GetUInt32()); // petnumber data << uint32(fields[3].GetUInt32()); // creature entry data << uint32(fields[4].GetUInt32()); // level data << fields[6].GetString(); // name data << uint32(fields[5].GetUInt32()); // loyalty data << uint8(fields[1].GetUInt32()+1); // slot ++num; }while (result->NextRow()); } data.put<uint8>(8, num); // set real data to placeholder SendPacket(&data); }
void InstanceSaveManager::PackInstances() { // this routine renumbers player instance associations in such a way so they start from 1 and go up // TODO: this can be done a LOT more efficiently // obtain set of all associations std::set<uint32> InstanceSet; // all valid ids are in the instance table // any associations to ids not in this table are assumed to be // cleaned already in CleanupInstances QueryResult_AutoPtr result = CharacterDatabase.Query("SELECT id FROM instance"); if (result) { do { Field *fields = result->Fetch(); InstanceSet.insert(fields[0].GetUInt32()); } while (result->NextRow()); } barGoLink bar(InstanceSet.size() + 1); bar.step(); uint32 InstanceNumber = 1; // we do assume std::set is sorted properly on integer value for (std::set<uint32>::iterator i = InstanceSet.begin(); i != InstanceSet.end(); ++i) { if (*i != InstanceNumber) { // remap instance id WorldDatabase.PExecute("UPDATE creature_respawn SET instance = '%u' WHERE instance = '%u'", InstanceNumber, *i); WorldDatabase.PExecute("UPDATE gameobject_respawn SET instance = '%u' WHERE instance = '%u'", InstanceNumber, *i); CharacterDatabase.PExecute("UPDATE characters SET instance_id = '%u' WHERE instance_id = '%u'", InstanceNumber, *i); CharacterDatabase.PExecute("UPDATE corpse SET instance = '%u' WHERE instance = '%u'", InstanceNumber, *i); CharacterDatabase.PExecute("UPDATE character_instance SET instance = '%u' WHERE instance = '%u'", InstanceNumber, *i); CharacterDatabase.PExecute("UPDATE instance SET id = '%u' WHERE id = '%u'", InstanceNumber, *i); CharacterDatabase.PExecute("UPDATE group_instance SET instance = '%u' WHERE instance = '%u'", InstanceNumber, *i); } ++InstanceNumber; bar.step(); } sLog.outString(); sLog.outString(">> Instance numbers remapped, next instance id is %u", InstanceNumber); }
AccountOpResult AccountMgr::DeleteAccount(uint32 accid) { QueryResult_AutoPtr result = LoginDatabase.PQuery("SELECT 1 FROM account WHERE id='%d'", accid); if (!result) return AOR_NAME_NOT_EXIST; // account doesn't exist // existed characters list result = CharacterDatabase.PQuery("SELECT guid FROM characters WHERE account='%d'",accid); if (result) { do { Field *fields = result->Fetch(); uint32 guidlo = fields[0].GetUInt32(); uint64 guid = MAKE_NEW_GUID(guidlo, 0, HIGHGUID_PLAYER); // kick if player currently if (Player* p = ObjectAccessor::GetObjectInWorld(guid, (Player*)NULL)) { WorldSession* s = p->GetSession(); s->KickPlayer(); // mark session to remove at next session list update s->LogoutPlayer(false); // logout player without waiting next session list update } Player::DeleteFromDB(guid, accid, false); // no need to update realm characters } while (result->NextRow()); } // table realm specific but common for all characters of account for realm CharacterDatabase.PExecute("DELETE FROM character_tutorial WHERE account = '%u'",accid); CharacterDatabase.PExecute("DELETE FROM account_data WHERE account = '%u'",accid); LoginDatabase.BeginTransaction(); bool res = LoginDatabase.PExecute("DELETE FROM account WHERE id='%d'", accid) && LoginDatabase.PExecute("DELETE FROM account_access WHERE id ='%d'", accid) && LoginDatabase.PExecute("DELETE FROM realmcharacters WHERE acctid='%d'", accid); LoginDatabase.CommitTransaction(); if (!res) return AOR_DB_INTERNAL_ERROR; // unexpected error; return AOR_OK; }
void AuctionHouseMgr::LoadAuctionItems() { // data needs to be at first place for Item::LoadFromDB QueryResult_AutoPtr result = CharacterDatabase.Query("SELECT itemEntry, creatorGuid, giftCreatorGuid, count, duration, charges, flags, enchantments, randomPropertyId, durability, itemTextId, itemguid, item_template FROM auctionhouse JOIN item_instance ON itemguid = guid"); if (!result) { sLog.outString(">> Loaded 0 auction items"); return; } uint32 count = 0; Field* fields; do { fields = result->Fetch(); uint32 item_guid = fields[11].GetUInt32(); uint32 item_template = fields[12].GetUInt32(); ItemTemplate const* proto = sObjectMgr.GetItemTemplate(item_template); if (!proto) { sLog.outError("AuctionHouseMgr::LoadAuctionItems: Unknown item (GUID: %u id: #%u) in auction, skipped.", item_guid, item_template); continue; } Item* item = NewItemOrBag(proto); if (!item->LoadFromDB(item_guid, 0, fields)) { delete item; continue; } AddAItem(item); ++count; } while (result->NextRow()); sLog.outString(">> Loaded %u auction items", count); }
/// Display info on users currently in the realm bool ChatHandler::HandleAccountOnlineListCommand(const char* /*args*/) { ///- Get the list of accounts ID logged to the realm QueryResult_AutoPtr resultDB = CharacterDatabase.Query("SELECT name,account,map,zone FROM characters WHERE online > 0"); if (!resultDB) { SendSysMessage(LANG_ACCOUNT_LIST_EMPTY); return true; } ///- Display the list of account/characters online SendSysMessage(LANG_ACCOUNT_LIST_BAR_HEADER); SendSysMessage(LANG_ACCOUNT_LIST_HEADER); SendSysMessage(LANG_ACCOUNT_LIST_BAR); ///- Circle through accounts do { Field *fieldsDB = resultDB->Fetch(); std::string name = fieldsDB[0].GetCppString(); uint32 account = fieldsDB[1].GetUInt32(); ///- Get the username, last IP and GM level of each account // No SQL injection. account is uint32. QueryResult_AutoPtr resultLogin = loginDatabase.PQuery("SELECT a.username, a.last_ip, aa.gmlevel, a.expansion " "FROM account a " "LEFT JOIN account_access aa " "ON (a.id = aa.id) " "WHERE a.id = '%u'", account); if(resultLogin) { Field *fieldsLogin = resultLogin->Fetch(); PSendSysMessage(LANG_ACCOUNT_LIST_LINE, fieldsLogin[0].GetString(),name.c_str(),fieldsLogin[1].GetString(),fieldsDB[2].GetInt32(),fieldsDB[3].GetInt32(),fieldsLogin[3].GetUInt32(),fieldsLogin[2].GetUInt32()); } else PSendSysMessage(LANG_ACCOUNT_LIST_ERROR,name.c_str()); }while(resultDB->NextRow()); SendSysMessage(LANG_ACCOUNT_LIST_BAR); return true; }
/** * Collects all GUIDs (and related info) from deleted characters which are still in the database. * * @param foundList a reference to an std::list which will be filled with info data * @param searchString the search string which either contains a player GUID or a part fo the character-name * @return returns false if there was a problem while selecting the characters (e.g. player name not normalizeable) */ bool ChatHandler::GetDeletedCharacterInfoList(DeletedInfoList& foundList, std::string searchString) { QueryResult_AutoPtr resultChar; if (!searchString.empty()) { // search by GUID if (isNumeric(searchString.c_str())) resultChar = CharacterDatabase.PQuery("SELECT guid, deleteInfos_Name, deleteInfos_Account, deleteDate FROM characters WHERE deleteDate IS NOT NULL AND guid = %u", uint64(atoi(searchString.c_str()))); // search by name else { if(!normalizePlayerName(searchString)) return false; resultChar = CharacterDatabase.PQuery("SELECT guid, deleteInfos_Name, deleteInfos_Account, deleteDate FROM characters WHERE deleteDate IS NOT NULL AND deleteInfos_Name " _LIKE_ " " _CONCAT3_("'%%'", "'%s'", "'%%'"), searchString.c_str()); } } else resultChar = CharacterDatabase.Query("SELECT guid, deleteInfos_Name, deleteInfos_Account, deleteDate FROM characters WHERE deleteDate IS NOT NULL"); if (resultChar) { do { Field* fields = resultChar->Fetch(); DeletedInfo info; info.lowguid = fields[0].GetUInt32(); info.name = fields[1].GetCppString(); info.accountId = fields[2].GetUInt32(); // account name will be empty for not existed account accmgr.GetName(info.accountId, info.accountName); info.deleteDate = time_t(fields[3].GetUInt64()); foundList.push_back(info); } while (resultChar->NextRow()); } return true; }
void TicketMgr::LoadGMTickets() { // Delete all out of object holder GM_TicketList.clear(); QueryResult_AutoPtr result = CharacterDatabase.Query("SELECT guid, playerGuid, name, message, createtime, map, posX, posY, posZ, timestamp, closed, assignedto, comment, escalated, viewed FROM gm_tickets"); GM_Ticket *ticket; if (!result) { ticketmgr.InitTicketID(); sLog.outString(); sLog.outString(">> GM Tickets table is empty, no tickets were loaded."); return; } // Assign values from SQL to the object holder do { Field *fields = result->Fetch(); ticket = new GM_Ticket; ticket->guid = fields[0].GetUInt64(); ticket->playerGuid = fields[1].GetUInt64(); ticket->name = fields[2].GetString(); ticket->message = fields[3].GetString(); ticket->createtime = fields[4].GetUInt64(); ticket->map = fields[5].GetUInt32(); ticket->pos_x = fields[6].GetFloat(); ticket->pos_y = fields[7].GetFloat(); ticket->pos_z = fields[8].GetFloat(); ticket->timestamp = fields[9].GetUInt64(); ticket->closed = fields[10].GetUInt64(); ticket->assignedToGM = fields[11].GetUInt64(); ticket->comment = fields[12].GetString(); ticket->escalated = fields[13].GetUInt64(); ticket->viewed = fields[14].GetBool(); AddGMTicket(ticket, true); } while (result->NextRow()); sWorld.SendGMText(LANG_COMMAND_TICKETRELOAD, result->GetRowCount()); }
void WorldSession::LoadTutorialsData() { for (int aX = 0 ; aX < 8 ; ++aX) m_Tutorials[ aX ] = 0; QueryResult_AutoPtr result = CharacterDatabase.PQuery("SELECT tut0,tut1,tut2,tut3,tut4,tut5,tut6,tut7 FROM character_tutorial WHERE account = '%u'", GetAccountId()); if (result) { do { Field *fields = result->Fetch(); for (int iI = 0; iI < 8; ++iI) m_Tutorials[iI] = fields[iI].GetUInt32(); } while (result->NextRow()); } m_TutorialsChanged = false; }
void CharacterDatabaseCleaner::CheckUnique(const char* column, const char* table, bool (*check)(uint32)) { QueryResult_AutoPtr result = CharacterDatabase.PQuery("SELECT DISTINCT %s FROM %s", column, table); if(!result) { sLog.outString( "Table %s is empty.", table ); return; } bool found = false; std::ostringstream ss; barGoLink bar( (int)result->GetRowCount() ); do { bar.step(); Field *fields = result->Fetch(); uint32 id = fields[0].GetUInt32(); if(!check(id)) { if(!found) { ss << "DELETE FROM " << table << " WHERE " << column << " IN ("; found = true; } else ss << ","; ss << id; } } while( result->NextRow() ); if (found) { ss << ")"; CharacterDatabase.Execute( ss.str().c_str() ); } }