void AchievementGlobalMgr::LoadRewardLocales()
{
m_achievementRewardLocales.clear(); // need for reload case
QueryResult *result = WorldDatabase.Query("SELECT entry,subject_loc1,text_loc1,subject_loc2,text_loc2,subject_loc3,text_loc3,subject_loc4,text_loc4,subject_loc5,text_loc5,subject_loc6,text_loc6,subject_loc7,text_loc7,subject_loc8,text_loc8 FROM locales_achievement_reward");
if(!result)
{
barGoLink bar(1);
bar.step();
sLog.outString("");
sLog.outString(">> Loaded 0 achievement reward locale strings. DB table `locales_achievement_reward` is empty.");
return;
}
barGoLink bar(result->GetRowCount());
do
{
Field *fields = result->Fetch();
bar.step();
uint32 entry = fields[0].GetUInt32();
if(m_achievementRewards.find(entry)==m_achievementRewards.end())
{
sLog.outErrorDb( "Table `locales_achievement_reward` (Entry: %u) has locale strings for not existed achievement reward .", entry);
continue;
}
AchievementRewardLocale& data = m_achievementRewardLocales[entry];
for(int i = 1; i < MAX_LOCALE; ++i)
{
std::string str = fields[1+2*(i-1)].GetCppString();
if(!str.empty())
{
int idx = objmgr.GetOrNewIndexForLocale(LocaleConstant(i));
if(idx >= 0)
{
if(data.subject.size() <= idx)
data.subject.resize(idx+1);
data.subject[idx] = str;
}
}
str = fields[1+2*(i-1)+1].GetCppString();
if(!str.empty())
{
int idx = objmgr.GetOrNewIndexForLocale(LocaleConstant(i));
if(idx >= 0)
{
if(data.text.size() <= idx)
data.text.resize(idx+1);
data.text[idx] = str;
}
}
}
} while (result->NextRow());
delete result;
sLog.outString();
sLog.outString( ">> Loaded %u achievement reward locale strings", m_achievementRewardLocales.size() );
}
void SystemMgr::LoadScriptTexts()
{
outstring_log("SD2: Loading Script Texts...");
LoadMangosStrings(SD2Database, "script_texts", TEXT_SOURCE_TEXT_START, TEXT_SOURCE_TEXT_END);
QueryResult* pResult = SD2Database.PQuery("SELECT entry, sound, type, language, emote FROM script_texts WHERE entry BETWEEN %i AND %i", TEXT_SOURCE_GOSSIP_END, TEXT_SOURCE_TEXT_START);
outstring_log("SD2: Loading Script Texts additional data...");
if (pResult)
{
BarGoLink bar(pResult->GetRowCount());
uint32 uiCount = 0;
do
{
bar.step();
Field* pFields = pResult->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("SD2: Entry %i in table `script_texts` is not a negative value.", iId);
continue;
}
if (pTemp.uiSoundId)
{
if (!GetSoundEntriesStore()->LookupEntry(pTemp.uiSoundId))
error_db_log("SD2: Entry %i in table `script_texts` has soundId %u but sound does not exist.", iId, pTemp.uiSoundId);
}
if (!GetLanguageDescByID(pTemp.uiLanguage))
error_db_log("SD2: 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("SD2: 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 (pResult->NextRow());
delete pResult;
// outstring_log("");
outstring_log(">> Loaded %u additional Script Texts data.", uiCount);
}
else
{
BarGoLink bar(1);
bar.step();
// outstring_log("");
outstring_log(">> Loaded 0 additional Script Texts data. DB table `script_texts` is empty.");
}
}
void WorldSession::HandleTurnInPetitionOpcode(WorldPacket& recv_data)
{
DEBUG_LOG("Received opcode CMSG_TURN_IN_PETITION"); // ok
// recv_data.hexlike();
ObjectGuid petitionGuid;
recv_data >> petitionGuid;
DEBUG_LOG("Petition %s turned in by %s", petitionGuid.GetString().c_str(), _player->GetGuidStr().c_str());
/// Collect petition info data
ObjectGuid ownerGuid;
uint32 type;
std::string name;
// data
QueryResult* result = CharacterDatabase.PQuery("SELECT ownerguid, name, type FROM petition WHERE petitionguid = '%u'", petitionGuid.GetCounter());
if (result)
{
Field* fields = result->Fetch();
ownerGuid = ObjectGuid(HIGHGUID_PLAYER, fields[0].GetUInt32());
name = fields[1].GetCppString();
type = fields[2].GetUInt32();
delete result;
}
else
{
sLog.outError("CMSG_TURN_IN_PETITION: petition table not have data for guid %u!", petitionGuid.GetCounter());
return;
}
if (type == 9)
{
if (_player->GetGuildId())
{
WorldPacket data(SMSG_TURN_IN_PETITION_RESULTS, 4);
data << uint32(PETITION_TURN_ALREADY_IN_GUILD); // already in guild
_player->GetSession()->SendPacket(data);
return;
}
}
else
{
if (!IsArenaTypeValid(ArenaType(type)))
return;
uint8 slot = ArenaTeam::GetSlotByType(ArenaType(type));
if (slot >= MAX_ARENA_SLOT)
return;
if (_player->GetArenaTeamId(slot))
{
// data.Initialize(SMSG_TURN_IN_PETITION_RESULTS, 4);
// data << (uint32)PETITION_TURN_ALREADY_IN_GUILD; // already in guild
//_player->GetSession()->SendPacket(data);
SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, name, "", ERR_ALREADY_IN_ARENA_TEAM);
return;
}
}
if (_player->GetObjectGuid() != ownerGuid)
return;
// signs
result = CharacterDatabase.PQuery("SELECT playerguid FROM petition_sign WHERE petitionguid = '%u'", petitionGuid.GetCounter());
uint8 signs = result ? (uint8)result->GetRowCount() : 0;
uint32 count = type == 9 ? sWorld.getConfig(CONFIG_UINT32_MIN_PETITION_SIGNS) : type - 1;
if (signs < count)
{
WorldPacket data(SMSG_TURN_IN_PETITION_RESULTS, 4);
data << uint32(PETITION_TURN_NEED_MORE_SIGNATURES); // need more signatures...
SendPacket(data);
delete result;
return;
}
if (type == 9)
{
if (sGuildMgr.GetGuildByName(name))
{
SendGuildCommandResult(GUILD_CREATE_S, name, ERR_GUILD_NAME_EXISTS_S);
delete result;
return;
}
}
else
{
if (sObjectMgr.GetArenaTeamByName(name))
{
SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, name, "", ERR_ARENA_TEAM_NAME_EXISTS_S);
delete result;
return;
}
}
// and at last charter item check
Item* item = _player->GetItemByGuid(petitionGuid);
if (!item)
{
delete result;
return;
}
// OK!
// delete charter item
_player->DestroyItem(item->GetBagSlot(), item->GetSlot(), true);
if (type == 9) // create guild
{
Guild* guild = new Guild;
if (!guild->Create(_player, name))
{
delete guild;
delete result;
return;
}
// register guild and add guildmaster
sGuildMgr.AddGuild(guild);
// add members
for (uint8 i = 0; i < signs; ++i)
{
Field* fields = result->Fetch();
ObjectGuid signGuid = ObjectGuid(HIGHGUID_PLAYER, fields[0].GetUInt32());
if (!signGuid)
continue;
guild->AddMember(signGuid, guild->GetLowestRank());
result->NextRow();
}
}
else // or arena team
{
ArenaTeam* at = new ArenaTeam;
if (!at->Create(_player->GetObjectGuid(), ArenaType(type), name))
{
sLog.outError("PetitionsHandler: arena team create failed.");
delete at;
delete result;
return;
}
uint32 icon, iconcolor, border, bordercolor, backgroud;
recv_data >> backgroud >> icon >> iconcolor >> border >> bordercolor;
at->SetEmblem(backgroud, icon, iconcolor, border, bordercolor);
// register team and add captain
sObjectMgr.AddArenaTeam(at);
DEBUG_LOG("PetitonsHandler: arena team added to objmrg");
// add members
for (uint8 i = 0; i < signs; ++i)
{
Field* fields = result->Fetch();
ObjectGuid memberGUID = ObjectGuid(HIGHGUID_PLAYER, fields[0].GetUInt32());
if (!memberGUID)
continue;
DEBUG_LOG("PetitionsHandler: adding arena member %s", memberGUID.GetString().c_str());
at->AddMember(memberGUID);
result->NextRow();
}
}
delete result;
CharacterDatabase.BeginTransaction();
CharacterDatabase.PExecute("DELETE FROM petition WHERE petitionguid = '%u'", petitionGuid.GetCounter());
CharacterDatabase.PExecute("DELETE FROM petition_sign WHERE petitionguid = '%u'", petitionGuid.GetCounter());
CharacterDatabase.CommitTransaction();
// created
DEBUG_LOG("TURN IN PETITION %s", petitionGuid.GetString().c_str());
WorldPacket data(SMSG_TURN_IN_PETITION_RESULTS, 4);
data << uint32(PETITION_TURN_OK);
SendPacket(data);
}
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((int)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.find(reqSkillOrSpell) == reportedReqSpells.end())
{
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.find(reqSkillOrSpell) == reportedReqSpells.end())
{
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 MapManager::LoadTransports()
{
QueryResult* result = WorldDatabase.Query("SELECT entry, name, period FROM transports");
uint32 count = 0;
if (!result)
{
BarGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded %u transports", count);
return;
}
BarGoLink bar(result->GetRowCount());
do
{
bar.step();
Transport* t = new Transport;
Field* fields = result->Fetch();
uint32 entry = fields[0].GetUInt32();
std::string name = fields[1].GetCppString();
t->m_period = fields[2].GetUInt32();
const GameObjectInfo* goinfo = ObjectMgr::GetGameObjectInfo(entry);
if (!goinfo)
{
sLog.outErrorDb("Transport ID:%u, Name: %s, will not be loaded, gameobject_template missing", entry, name.c_str());
delete t;
continue;
}
if (goinfo->type != GAMEOBJECT_TYPE_MO_TRANSPORT)
{
sLog.outErrorDb("Transport ID:%u, Name: %s, will not be loaded, gameobject_template type wrong", entry, name.c_str());
delete t;
continue;
}
// sLog.outString("Loading transport %d between %s, %s", entry, name.c_str(), goinfo->name);
std::set<uint32> mapsUsed;
if (!t->GenerateWaypoints(goinfo->moTransport.taxiPathId, mapsUsed))
// skip transports with empty waypoints list
{
sLog.outErrorDb("Transport (path id %u) path size = 0. Transport ignored, check DBC files or transport GO data0 field.", goinfo->moTransport.taxiPathId);
delete t;
continue;
}
float x, y, z, o;
uint32 mapid;
x = t->m_WayPoints[0].x; y = t->m_WayPoints[0].y; z = t->m_WayPoints[0].z; mapid = t->m_WayPoints[0].mapid; o = 1;
// current code does not support transports in dungeon!
const MapEntry* pMapInfo = sMapStore.LookupEntry(mapid);
if (!pMapInfo || pMapInfo->Instanceable())
{
delete t;
continue;
}
// creates the Gameobject
if (!t->Create(entry, mapid, x, y, z, o, GO_ANIMPROGRESS_DEFAULT))
{
delete t;
continue;
}
m_Transports.insert(t);
for (std::set<uint32>::const_iterator i = mapsUsed.begin(); i != mapsUsed.end(); ++i)
m_TransportsByMap[*i].insert(t);
// If we someday decide to use the grid to track transports, here:
t->SetMap(sMapMgr.CreateMap(mapid, t));
// t->GetMap()->Add<GameObject>((GameObject *)t);
++count;
}
while (result->NextRow());
delete result;
sLog.outString();
sLog.outString(">> Loaded %u transports", count);
// check transport data DB integrity
result = WorldDatabase.Query("SELECT gameobject.guid,gameobject.id,transports.name FROM gameobject,transports WHERE gameobject.id = transports.entry");
if (result) // wrong data found
{
do
{
Field* fields = result->Fetch();
uint32 guid = fields[0].GetUInt32();
uint32 entry = fields[1].GetUInt32();
std::string name = fields[2].GetCppString();
sLog.outErrorDb("Transport %u '%s' have record (GUID: %u) in `gameobject`. Transports DON'T must have any records in `gameobject` or its behavior will be unpredictable/bugged.", entry, name.c_str(), guid);
}
while (result->NextRow());
delete result;
}
}
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(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(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;
}
if (!IsValidEvent(std::abs(event_id)))
{
sLog.outErrorDb("`game_event_creature` game event id (%i) not exist in `game_event`", event_id);
continue;
}
int32 internal_event_id = mGameEvent.size() + event_id - 1;
++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(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;
}
if (!IsValidEvent(std::abs(event_id)))
{
sLog.outErrorDb("`game_event_gameobject` game event id (%i) not exist in `game_event`", event_id);
continue;
}
int32 internal_event_id = mGameEvent.size() + event_id - 1;
++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);
}
mGameEventCreatureData.resize(mGameEvent.size());
// 0 1 2
result = WorldDatabase.Query("SELECT creature.guid, game_event_creature_data.event, game_event_creature_data.modelid,"
// 3 4
"game_event_creature_data.equipment_id, game_event_creature_data.entry_id, "
// 5 6
"game_event_creature_data.spell_start, game_event_creature_data.spell_end "
"FROM creature JOIN game_event_creature_data ON creature.guid=game_event_creature_data.guid");
count = 0;
if (!result)
{
BarGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded %u creature reactions at game events", count );
}
else
{
BarGoLink bar(result->GetRowCount());
do
{
Field *fields = result->Fetch();
bar.step();
uint32 guid = fields[0].GetUInt32();
uint16 event_id = fields[1].GetUInt16();
if (event_id == 0)
{
sLog.outErrorDb("`game_event_creature_data` game event id (%i) is reserved and can't be used." ,event_id);
continue;
}
if (!IsValidEvent(event_id))
{
sLog.outErrorDb("`game_event_creature_data` game event id (%u) not exist in `game_event`", event_id);
continue;
}
++count;
GameEventCreatureDataList& equiplist = mGameEventCreatureData[event_id];
GameEventCreatureData newData;
newData.modelid = fields[2].GetUInt32();
newData.equipment_id = fields[3].GetUInt32();
newData.entry_id = fields[4].GetUInt32();
newData.spell_id_start = fields[5].GetUInt32();
newData.spell_id_end = fields[6].GetUInt32();
if (newData.equipment_id && !sObjectMgr.GetEquipmentInfo(newData.equipment_id))
{
sLog.outErrorDb("Table `game_event_creature_data` have creature (Guid: %u) with equipment_id %u not found in table `creature_equip_template`, set to no equipment.", guid, newData.equipment_id);
newData.equipment_id = 0;
}
if (newData.entry_id && !ObjectMgr::GetCreatureTemplate(newData.entry_id))
{
sLog.outErrorDb("Table `game_event_creature_data` have creature (Guid: %u) with event time entry %u not found in table `creature_template`, set to no 0.", guid, newData.entry_id);
newData.entry_id = 0;
}
if (newData.spell_id_start && !sSpellStore.LookupEntry(newData.spell_id_start))
{
sLog.outErrorDb("Table `game_event_creature_data` have creature (Guid: %u) with nonexistent spell_start %u, set to no start spell.", guid, newData.spell_id_start);
newData.spell_id_start = 0;
}
if (newData.spell_id_end && !sSpellStore.LookupEntry(newData.spell_id_end))
{
sLog.outErrorDb("Table `game_event_creature_data` have creature (Guid: %u) with nonexistent spell_end %u, set to no end spell.", guid, newData.spell_id_end);
newData.spell_id_end = 0;
}
equiplist.push_back(GameEventCreatureDataPair(guid, newData));
mGameEventCreatureDataPerGuid.insert(GameEventCreatureDataPerGuidMap::value_type(guid, event_id));
} while( result->NextRow() );
delete result;
sLog.outString();
sLog.outString(">> Loaded %u creature reactions at 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(result->GetRowCount());
do
{
Field *fields = result->Fetch();
bar.step();
uint32 quest = fields[0].GetUInt32();
uint16 event_id = fields[1].GetUInt16();
if (event_id == 0)
{
sLog.outErrorDb("`game_event_quest` game event id (%i) is reserved and can't be used.", event_id);
continue;
}
if (!IsValidEvent(event_id))
{
sLog.outErrorDb("`game_event_quest` game event id (%u) not exist 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 );
}
mGameEventMails.resize(mGameEvent.size()*2-1);
result = WorldDatabase.Query("SELECT event, raceMask, quest, mailTemplateId, senderEntry FROM game_event_mail");
count = 0;
if (!result)
{
BarGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded %u start/end game event mails", count );
}
else
{
BarGoLink bar(result->GetRowCount());
do
{
Field *fields = result->Fetch();
bar.step();
uint16 event_id = fields[0].GetUInt16();
GameEventMail mail;
mail.raceMask = fields[1].GetUInt32();
mail.questId = fields[2].GetUInt32();
mail.mailTemplateId = fields[3].GetUInt32();
mail.senderEntry = fields[4].GetUInt32();
if (event_id == 0)
{
sLog.outErrorDb("`game_event_mail` game event id (%i) not allowed", event_id);
continue;
}
if (!IsValidEvent(event_id))
{
sLog.outErrorDb("`game_event_mail` game event id (%u) not exist in `game_event`", event_id);
continue;
}
int32 internal_event_id = mGameEvent.size() + event_id - 1;
if (!(mail.raceMask & RACEMASK_ALL_PLAYABLE))
{
sLog.outErrorDb("Table `game_event_mail` have raceMask (%u) requirement for game event %i that not include any player races, ignoring.", mail.raceMask, event_id);
continue;
}
if (mail.questId && !sObjectMgr.GetQuestTemplate(mail.questId))
{
sLog.outErrorDb("Table `game_event_mail` have nonexistent quest (%u) requirement for game event %i, ignoring.", mail.questId, event_id);
continue;
}
if (!sMailTemplateStore.LookupEntry(mail.mailTemplateId))
{
sLog.outErrorDb("Table `game_event_mail` have invalid mailTemplateId (%u) for game event %i that invalid not include any player races, ignoring.", mail.mailTemplateId, event_id);
continue;
}
if (!ObjectMgr::GetCreatureTemplate(mail.senderEntry))
{
sLog.outErrorDb("Table `game_event_mail` have nonexistent sender creature entry (%u) for game event %i that invalid not include any player races, ignoring.", mail.senderEntry, event_id);
continue;
}
++count;
MailList& maillist = mGameEventMails[internal_event_id];
maillist.push_back(mail);
} while( result->NextRow() );
delete result;
sLog.outString();
sLog.outString(">> Loaded %u start/end game event mails", count );
}
}
void MapPersistentStateManager::LoadCreatureRespawnTimes()
{
// remove outdated data
CharacterDatabase.DirectExecute("DELETE FROM creature_respawn WHERE respawntime <= UNIX_TIMESTAMP(NOW())");
uint32 count = 0;
// 0 1 2 3 4 5 6
QueryResult* result = CharacterDatabase.Query("SELECT guid, respawntime, map, instance, difficulty, resettime, encountersMask FROM creature_respawn LEFT JOIN instance ON instance = id");
if (!result)
{
BarGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded 0 creature respawn time.");
return;
}
BarGoLink bar(result->GetRowCount());
do
{
Field* fields = result->Fetch();
bar.step();
uint32 loguid = fields[0].GetUInt32();
uint64 respawn_time = fields[1].GetUInt64();
uint32 mapId = fields[2].GetUInt32();
uint32 instanceId = fields[3].GetUInt32();
uint8 difficulty = fields[4].GetUInt8();
time_t resetTime = (time_t)fields[5].GetUInt64();
uint32 completedEncounters = fields[6].GetUInt32();
CreatureData const* data = sObjectMgr.GetCreatureData(loguid);
if (!data)
continue;
if (mapId != data->mapid)
continue;
MapEntry const* mapEntry = sMapStore.LookupEntry(mapId);
if (!mapEntry || (mapEntry->Instanceable() != (instanceId != 0)))
continue;
if (difficulty >= (!mapEntry->Instanceable() ? REGULAR_DIFFICULTY : (mapEntry->IsRaid() ? MAX_RAID_DIFFICULTY : MAX_DUNGEON_DIFFICULTY)))
continue;
MapPersistentState* state = AddPersistentState(mapEntry, instanceId, Difficulty(difficulty), resetTime, mapEntry->IsDungeon(), true, true, completedEncounters);
if (!state)
continue;
state->SetCreatureRespawnTime(loguid, time_t(respawn_time));
++count;
}
while (result->NextRow());
delete result;
sLog.outString(">> Loaded %u creature respawn times", count);
sLog.outString();
}
bool IRCClient::LoadConfig()
{
if (!MCConfig.SetSource(CfgFile))
sLog.outString("MangChat: Unable to open configuration file (%s), All default options are being used.", CfgFile);
else
sLog.outString("MangChat: Found the configuration file, %s", CfgFile);
int ConfCnt = 0;
sIRC._chan_count = 0;
if (MCConfig.GetIntDefault("irc.active", 0))
sIRC.Active = true;
else
sIRC.Active = false;
sIRC._Host = MCConfig.GetStringDefault("irc.host", "irc.freenode.net");
if (sIRC._Host.size() > 0)
ConfCnt++;
sIRC._Mver = MCConfig.GetStringDefault("irc.mver", "Version 1.8.1");
sIRC._Port = MCConfig.GetIntDefault("irc.port", 6667);
sIRC._User = MCConfig.GetStringDefault("irc.user", "MangChat");
sIRC._Pass = MCConfig.GetStringDefault("irc.pass", "MyDumbPass");
sIRC._Nick = MCConfig.GetStringDefault("irc.nick", "MangChat");
sIRC._Auth = MCConfig.GetIntDefault("irc.auth", 0);
sIRC._Auth_Nick = MCConfig.GetStringDefault("irc.auth.nick", "AuthNick");
sIRC._ICC = MCConfig.GetStringDefault("irc.icc", "001");
sIRC._defchan = MCConfig.GetStringDefault("irc.defchan", "lobby");
sIRC._ldefc = MCConfig.GetIntDefault("irc.ldef", 0);
sIRC._wct = MCConfig.GetIntDefault("irc.wct", 30000);
sIRC.ajoin = MCConfig.GetIntDefault("irc.ajoin", 1);
sIRC.ajchan = MCConfig.GetStringDefault("irc.ajchan", "world");
sIRC.onlrslt = MCConfig.GetIntDefault("irc.online.result", 10);
sIRC.BOTMASK = MCConfig.GetIntDefault("Botmask", 0);
sIRC.logfile = MCConfig.GetStringDefault("irc.logfile.prefix", "IRC_");
for (int i = 1; i < MAX_CONF_CHANNELS;i++)
{
std::ostringstream ss;
ss << i;
std::string ci = "irc.chan_" + ss.str();
std::string t_chan = MCConfig.GetStringDefault(ci.c_str(), "");
if (t_chan.size() > 0)
{
sIRC._chan_count++;
sIRC._irc_chan[sIRC._chan_count] = t_chan;
ci = "wow.chan_" + ss.str();
sIRC._wow_chan[sIRC._chan_count] = MCConfig.GetStringDefault(ci.c_str(), t_chan.c_str());
}
}
sIRC.JoinMsg = MCConfig.GetStringDefault("irc.joinmsg", "Whhaaazzzzaaaa, MangChat $Ver Baby!!");
sIRC.RstMsg = MCConfig.GetStringDefault("irc.rstmsg", "MangChat Is Restarting, I Will Be Right Back!");
sIRC.kikmsg = MCConfig.GetStringDefault("irc.kickmsg", "Do Not Kick Me Again, Severe Actions Will Be Taken!");
// IRC LINES
sIRC.ILINES[WOW_IRC] = MCConfig.GetStringDefault("chat.wow_irc", "\003<WoW>[\002$Name($Level)\002\003] $Msg");
sIRC.ILINES[IRC_WOW] = MCConfig.GetStringDefault("chat.irc_wow", "\003<IRC>[$Name]: $Msg");
sIRC.ILINES[JOIN_WOW] = MCConfig.GetStringDefault("chat.join_wow", "\00312>>\00304 $Name \003Joined The Channel!");
sIRC.ILINES[JOIN_IRC] = MCConfig.GetStringDefault("chat.join_irc", "\003[$Name]: Has Joined IRC!");
sIRC.ILINES[LEAVE_WOW] = MCConfig.GetStringDefault("chat.leave_wow", "\00312<<\00304 $Name \003Left The Channel!");
sIRC.ILINES[LEAVE_IRC] = MCConfig.GetStringDefault("chat.leave_irc", "\003[$Name]: Has Left IRC!");
sIRC.ILINES[CHANGE_NICK] = MCConfig.GetStringDefault("chat.change_nick", "\003<> $Name Is Now Known As $NewName!");
// MangChat Options
sIRC._MCA = MCConfig.GetIntDefault("irc.maxattempt", 10);
sIRC._autojoinkick = MCConfig.GetIntDefault("irc.autojoin_kick", 1);
sIRC._cmd_prefx = MCConfig.GetStringDefault("irc.command_prefix", ".");
sIRC._op_gm = MCConfig.GetIntDefault("irc.op_gm_login", 0);
sIRC._op_gm_lev = MCConfig.GetIntDefault("irc.op_gm_level", 3);
// Misc Options
sIRC.games = MCConfig.GetIntDefault("irc.fun.games", 0);
sIRC.gmlog = MCConfig.GetIntDefault("irc.gmlog", 1);
sIRC.BOTMASK = MCConfig.GetIntDefault("BotMask", 0);
sIRC.Status = MCConfig.GetIntDefault("irc.StatusChannel", 1);
sIRC.anchn = MCConfig.GetIntDefault("irc.AnnounceChannel", 1);
sIRC.autoanc = MCConfig.GetIntDefault("irc.auto.announce", 30);
for (uint16 i = 0; i<SEC_ADMINISTRATOR; i++)
{
std::stringstream ircKeyWord, defaultEntry;
ircKeyWord << "irc.gm" << i;
if (!i)
defaultEntry << "";
else
defaultEntry << "[GM" << i << "]";
sIRC.ojGM[i] = MCConfig.GetStringDefault(ircKeyWord.str().c_str(), defaultEntry.str().c_str());
}
// REQUIRED GM LEVEL
QueryResult *result = WorldDatabase.PQuery("SELECT `Command`, `gmlevel` FROM `IRC_Commands` ORDER BY `Command`");
if (result)
{
Field *fields = result->Fetch();
for (uint64 i=0; i < result->GetRowCount(); i++)
{
std::string command = fields[0].GetCppString();
uint32 gmlvl = fields[1].GetUInt32();
if (command == "acct") sIRC.CACCT = gmlvl;
if (command == "ban") sIRC.CBAN = gmlvl;
if (command == "char") sIRC.CCHAN = gmlvl;
if (command == "char") sIRC.CCHAR = gmlvl;
if (command == "fun") sIRC.CFUN = gmlvl;
if (command == "help") sIRC.CHELP = gmlvl;
if (command == "inchan") sIRC.CINCHAN = gmlvl;
if (command == "info") sIRC.CINFO = gmlvl;
if (command == "item") sIRC.CITEM = gmlvl;
if (command == "jail") sIRC.CJAIL = gmlvl;
if (command == "kick") sIRC.CKICK = gmlvl;
if (command == "kill") sIRC._KILL = gmlvl;
if (command == "level") sIRC.CLEVEL = gmlvl;
if (command == "lookup") sIRC.CLOOKUP = gmlvl;
if (command == "money") sIRC.CMONEY = gmlvl;
if (command == "mute") sIRC.CMUTE = gmlvl;
if (command == "online") sIRC.CONLINE = gmlvl;
if (command == "pm") sIRC.CPM = gmlvl;
if (command == "restart") sIRC.CRESTART = gmlvl;
if (command == "revive") sIRC.CREVIVE = gmlvl;
if (command == "saveall") sIRC.CSAVEALL = gmlvl;
if (command == "shutdown") sIRC.CSHUTDOWN = gmlvl;
if (command == "spell") sIRC.CSPELL = gmlvl;
if (command == "sysmsg") sIRC.CSPELL = gmlvl;
if (command == "tele") sIRC.CTELE = gmlvl;
if (command == "top") sIRC.CTOP = gmlvl;
if (command == "who") sIRC.CWHO = gmlvl;
result->NextRow();
}
delete result;
}
else
{
sIRC.CACCT = 3;
sIRC.CBAN = 3;
sIRC.CCHAN = 3;
sIRC.CCHAR = 3;
sIRC.CFUN = 3;
sIRC.CHELP = 3;
sIRC.CINCHAN = 3;
sIRC.CINFO = 3;
sIRC.CITEM = 3;
sIRC.CJAIL = 3;
sIRC.CKICK = 3;
sIRC._KILL = 3;
sIRC.CLEVEL = 3;
sIRC.CLOOKUP = 3;
sIRC.CMONEY = 3;
sIRC.CMUTE = 3;
sIRC.CONLINE = 3;
sIRC.CPM = 3;
sIRC.CRESTART = 3;
sIRC.CREVIVE = 3;
sIRC.CSAVEALL = 3;
sIRC.CSHUTDOWN = 3;
sIRC.CSPELL = 3;
sIRC.CSYSMSG = 3;
sIRC.CTELE = 3;
sIRC.CTOP = 3;
sIRC.CWHO = 3;
}
return true;
}
void PoolManager::LoadFromDB()
{
QueryResult *result = WorldDatabase.Query("SELECT MAX(entry) FROM pool_template");
if (!result)
{
sLog.outString(">> Table pool_template is empty.");
sLog.outString();
return;
}
else
{
Field *fields = result->Fetch();
max_pool_id = fields[0].GetUInt16();
delete result;
}
mPoolTemplate.resize(max_pool_id + 1);
result = WorldDatabase.Query("SELECT entry,max_limit FROM pool_template");
if (!result)
{
mPoolTemplate.clear();
sLog.outString(">> Table pool_template is empty:");
sLog.outString();
return;
}
uint32 count = 0;
barGoLink bar(result->GetRowCount());
do
{
++count;
Field *fields = result->Fetch();
bar.step();
uint16 pool_id = fields[0].GetUInt16();
PoolTemplateData& pPoolTemplate = mPoolTemplate[pool_id];
pPoolTemplate.MaxLimit = fields[1].GetUInt32();
} while (result->NextRow());
sLog.outString();
sLog.outString( ">> Loaded %u objects pools", count );
delete result;
// Creatures
mPoolCreatureGroups.resize(max_pool_id + 1);
mCreatureSearchMap.clear();
// 1 2 3
result = WorldDatabase.Query("SELECT guid, pool_entry, chance FROM pool_creature");
count = 0;
if (!result)
{
barGoLink bar2(1);
bar2.step();
sLog.outString();
sLog.outString(">> Loaded %u creatures in pools", count );
}
else
{
barGoLink bar2(result->GetRowCount());
do
{
Field *fields = result->Fetch();
bar2.step();
uint32 guid = fields[0].GetUInt32();
uint16 pool_id = fields[1].GetUInt16();
float chance = fields[2].GetFloat();
CreatureData const* data = objmgr.GetCreatureData(guid);
if (!data)
{
sLog.outErrorDb("`pool_creature` has a non existing creature spawn (GUID: %u) defined for pool id (%u), skipped.", guid, pool_id );
continue;
}
if (pool_id > max_pool_id)
{
sLog.outErrorDb("`pool_creature` pool id (%i) is out of range compared to max pool id in `pool_template`, skipped.",pool_id);
continue;
}
if (chance < 0 || chance > 100)
{
sLog.outErrorDb("`pool_creature` has an invalid chance (%f) for creature guid (%u) in pool id (%i), skipped.", chance, guid, pool_id);
continue;
}
PoolTemplateData *pPoolTemplate = &mPoolTemplate[pool_id];
++count;
PoolObject plObject = PoolObject(guid, chance);
PoolGroup<Creature>& cregroup = mPoolCreatureGroups[pool_id];
cregroup.AddEntry(plObject, pPoolTemplate->MaxLimit);
SearchPair p(guid, pool_id);
mCreatureSearchMap.insert(p);
} while (result->NextRow());
sLog.outString();
sLog.outString( ">> Loaded %u creatures in pools", count );
delete result;
}
// Gameobjects
mPoolGameobjectGroups.resize(max_pool_id + 1);
mGameobjectSearchMap.clear();
// 1 2 3
result = WorldDatabase.Query("SELECT guid, pool_entry, chance FROM pool_gameobject");
count = 0;
if (!result)
{
barGoLink bar2(1);
bar2.step();
sLog.outString();
sLog.outString(">> Loaded %u gameobject in pools", count );
}
else
{
barGoLink bar2(result->GetRowCount());
do
{
Field *fields = result->Fetch();
bar2.step();
uint32 guid = fields[0].GetUInt32();
uint16 pool_id = fields[1].GetUInt16();
float chance = fields[2].GetFloat();
GameObjectData const* data = objmgr.GetGOData(guid);
if (!data)
{
sLog.outErrorDb("`pool_gameobject` has a non existing gameobject spawn (GUID: %u) defined for pool id (%u), skipped.", guid, pool_id );
continue;
}
GameObjectInfo const* goinfo = ObjectMgr::GetGameObjectInfo(data->id);
if (goinfo->type != GAMEOBJECT_TYPE_CHEST &&
goinfo->type != GAMEOBJECT_TYPE_GOOBER &&
goinfo->type != GAMEOBJECT_TYPE_FISHINGHOLE)
{
sLog.outErrorDb("`pool_gameobject` has a not lootable gameobject spawn (GUID: %u, type: %u) defined for pool id (%u), skipped.", guid, goinfo->type, pool_id );
continue;
}
if (pool_id > max_pool_id)
{
sLog.outErrorDb("`pool_gameobject` pool id (%i) is out of range compared to max pool id in `pool_template`, skipped.",pool_id);
continue;
}
if (chance < 0 || chance > 100)
{
sLog.outErrorDb("`pool_gameobject` has an invalid chance (%f) for gameobject guid (%u) in pool id (%i), skipped.", chance, guid, pool_id);
continue;
}
PoolTemplateData *pPoolTemplate = &mPoolTemplate[pool_id];
++count;
PoolObject plObject = PoolObject(guid, chance);
PoolGroup<GameObject>& gogroup = mPoolGameobjectGroups[pool_id];
gogroup.AddEntry(plObject, pPoolTemplate->MaxLimit);
SearchPair p(guid, pool_id);
mGameobjectSearchMap.insert(p);
} while( result->NextRow() );
sLog.outString();
sLog.outString( ">> Loaded %u gameobject in pools", count );
delete result;
}
// Pool of pools
mPoolPoolGroups.resize(max_pool_id + 1);
// 1 2 3
result = WorldDatabase.Query("SELECT pool_id, mother_pool, chance FROM pool_pool");
count = 0;
if( !result )
{
barGoLink bar2(1);
bar2.step();
sLog.outString();
sLog.outString(">> Loaded %u pools in pools", count );
}
else
{
barGoLink bar2( result->GetRowCount() );
do
{
Field *fields = result->Fetch();
bar2.step();
uint16 child_pool_id = fields[0].GetUInt16();
uint16 mother_pool_id = fields[1].GetUInt16();
float chance = fields[2].GetFloat();
if (mother_pool_id > max_pool_id)
{
sLog.outErrorDb("`pool_pool` mother_pool id (%i) is out of range compared to max pool id in `pool_template`, skipped.",mother_pool_id);
continue;
}
if (child_pool_id > max_pool_id)
{
sLog.outErrorDb("`pool_pool` included pool_id (%i) is out of range compared to max pool id in `pool_template`, skipped.",child_pool_id);
continue;
}
if (mother_pool_id == child_pool_id)
{
sLog.outErrorDb("`pool_pool` pool_id (%i) includes itself, dead-lock detected, skipped.",child_pool_id);
continue;
}
if (chance < 0 || chance > 100)
{
sLog.outErrorDb("`pool_pool` has an invalid chance (%f) for pool id (%u) in mother pool id (%i), skipped.", chance, child_pool_id, mother_pool_id);
continue;
}
PoolTemplateData *pPoolTemplateMother = &mPoolTemplate[mother_pool_id];
++count;
PoolObject plObject = PoolObject(child_pool_id, chance);
PoolGroup<Pool>& plgroup = mPoolPoolGroups[mother_pool_id];
plgroup.AddEntry(plObject, pPoolTemplateMother->MaxLimit);
SearchPair p(child_pool_id, mother_pool_id);
mPoolSearchMap.insert(p);
} while( result->NextRow() );
// Now check for circular reference
for(uint16 i=0; i<max_pool_id; ++i)
{
std::set<uint16> 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<uint16>::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;
sLog.outErrorDb(ss.str().c_str());
mPoolPoolGroups[poolItr->second].RemoveOneRelation(poolItr->first);
mPoolSearchMap.erase(poolItr);
--count;
break;
}
}
}
sLog.outString();
sLog.outString( ">> Loaded %u pools in mother pools", count );
delete result;
}
}
/// Load Weather chanced from table game_weather
void WeatherMgr::LoadWeatherZoneChances()
{
uint32 count = 0;
// 0 1 2 3 4 5 6 7 8 9 10 11 12
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 FROM game_weather");
if (!result)
{
BarGoLink bar(1);
bar.step();
sLog.outErrorDb(">> Loaded 0 weather definitions. DB table `game_weather` is empty.");
sLog.outString();
return;
}
BarGoLink bar(result->GetRowCount());
do
{
Field* fields = result->Fetch();
bar.step();
uint32 zone_id = fields[0].GetUInt32();
WeatherZoneChances& wzc = mWeatherZoneMap[zone_id];
for (int 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);
}
}
++count;
}
while (result->NextRow());
delete result;
sLog.outString(">> Loaded %u weather definitions", count);
sLog.outString();
}
void WaypointManager::Load()
{
Cleanup();
uint32 total_paths = 0;
uint32 total_nodes = 0;
uint32 total_behaviors = 0;
QueryResult *result = WorldDatabase.Query("SELECT id, COUNT(point) FROM creature_movement GROUP BY id");
if(!result)
{
barGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString( ">> Loaded 0 paths. DB table `creature_movement` is empty." );
return;
} else {
total_paths = result->GetRowCount();
barGoLink bar( total_paths );
do
{
bar.step();
Field *fields = result->Fetch();
uint32 id = fields[0].GetUInt32();
uint32 count = fields[1].GetUInt32();
m_pathMap[id].resize(count);
total_nodes += count;
} while( result->NextRow() );
delete result;
sLog.outString();
sLog.outString( ">> Paths loaded" );
}
// 0 1 2 3 4 5
result = WorldDatabase.Query("SELECT position_x, position_y, position_z, orientation, model1, model2,"
// 6 7 8 9 10 11 12 13 14 15
"waittime, emote, spell, textid1, textid2, textid3, textid4, textid5, id, point FROM creature_movement");
barGoLink bar( result->GetRowCount() );
do
{
bar.step();
Field *fields = result->Fetch();
uint32 point = fields[15].GetUInt32();
uint32 id = fields[14].GetUInt32();
if (!sObjectMgr.GetCreatureData(id))
{
sLog.outErrorDb("Table creature_movement references unknown creature %u. Deleted.", id);
WorldDatabase.PExecute("DELETE FROM creature_movement where id=%u",id);
continue;
}
WaypointPath &path = m_pathMap[id];
// the cleanup queries make sure the following is true
ASSERT(point >= 1 && point <= path.size());
WaypointNode &node = path[point-1];
node.x = fields[0].GetFloat();
node.y = fields[1].GetFloat();
node.z = fields[2].GetFloat();
node.orientation = fields[3].GetFloat();
node.delay = fields[6].GetUInt32();
// prevent using invalid coordinates
if(!MaNGOS::IsValidMapCoord(node.x, node.y, node.z, node.orientation))
{
QueryResult *result1 = WorldDatabase.PQuery("SELECT id, map FROM creature WHERE guid = '%u'", id);
if(result1)
sLog.outErrorDb("Creature (guidlow %d, entry %d) have invalid coordinates in his waypoint %d (X: %f, Y: %f).",
id, result1->Fetch()[0].GetUInt32(), point, node.x, node.y);
else
sLog.outErrorDb("Waypoint path %d, have invalid coordinates in his waypoint %d (X: %f, Y: %f).",
id, point, node.x, node.y);
MaNGOS::NormalizeMapCoord(node.x);
MaNGOS::NormalizeMapCoord(node.y);
if(result1)
{
node.z = MapManager::Instance ().CreateBaseMap(result1->Fetch()[1].GetUInt32())->GetHeight(node.x, node.y, node.z);
delete result1;
}
WorldDatabase.PExecute("UPDATE creature_movement SET position_x = '%f', position_y = '%f', position_z = '%f' WHERE id = '%u' AND point = '%u'", node.x, node.y, node.z, id, point);
}
WaypointBehavior be;
be.model1 = fields[4].GetUInt32();
be.model2 = fields[5].GetUInt32();
be.emote = fields[7].GetUInt32();
be.spell = fields[8].GetUInt32();
for(int i = 0; i < MAX_WAYPOINT_TEXT; ++i)
{
be.textid[i] = fields[9+i].GetUInt32();
if(be.textid[i])
{
if (be.textid[i] < MIN_DB_SCRIPT_STRING_ID || be.textid[i] >= MAX_DB_SCRIPT_STRING_ID)
{
sLog.outErrorDb( "Table `db_script_string` not have string id %u", be.textid[i]);
continue;
}
}
}
if (be.spell && ! sSpellStore.LookupEntry(be.spell))
{
sLog.outErrorDb("Table creature_movement references unknown spellid %u. Skipping id %u with point %u.", be.spell, id, point);
be.spell = 0;
}
if (be.emote)
{
if (!sEmotesStore.LookupEntry(be.emote))
sLog.outErrorDb("Waypoint path %u (Point %u) are using emote %u, but emote does not exist.",id, point, be.emote);
}
// save memory by not storing empty behaviors
if(!be.isEmpty())
{
node.behavior = new WaypointBehavior(be);
++total_behaviors;
}
else
node.behavior = NULL;
} while( result->NextRow() );
delete result;
sLog.outString();
sLog.outString( ">> Waypoints and behaviors loaded" );
sLog.outString();
sLog.outString( ">>> Loaded %u paths, %u nodes and %u behaviors", total_paths, total_nodes, total_behaviors);
}
//-----------------------------------------------//
void
WaypointMovementGenerator<Creature>::LoadPath(Creature &c)
{
QueryResult *result = NULL;
sLog.outDebug("DEBUG: WaypointMovementGenerator::_load: GUID - %d", c.GetGUIDLow());
// Identify by GUID
result = sDatabase.PQuery("SELECT `position_x`, `position_y`, `position_z`, `orientation`, `model1`, `model2`, `waittime`, `emote`, `spell`, `text1`, `text2`, `text3`, `text4`, `text5`, `aiscript` FROM `creature_movement` WHERE `id` = '%u' ORDER BY `point`", c.GetDBTableGUIDLow());
/*
if( result ) {
sLog.outDebug("DEBUG: Number of hits: %d", result->GetRowCount());
} else {
sLog.outDebug("DEBUG: Nothing found");
}
*/
if( result )
{
unsigned int count = 0;
const unsigned int sz = result->GetRowCount();
i_path.Resize( sz );
i_delays.resize( sz );
i_wpBehaviour.resize( sz );
do
{
//sLog.outDebug("DEBUG: _load");
Field *fields = result->Fetch();
i_path[count].x = fields[0].GetFloat();
i_path[count].y = fields[1].GetFloat();
i_path[count].z = fields[2].GetFloat();
float orientation = fields[3].GetFloat();
uint32 model1 = fields[4].GetUInt32();
uint32 model2 = fields[5].GetUInt32();
i_delays[count] = fields[6].GetUInt16();
uint32 emote = fields[7].GetUInt32();
uint32 spell = fields[8].GetUInt32();
std::string text1 = fields[9].GetCppString();
std::string text2 = fields[10].GetCppString();
std::string text3 = fields[11].GetCppString();
std::string text4 = fields[12].GetCppString();
std::string text5 = fields[13].GetCppString();
std::string aiscript = fields[14].GetCppString();
if( (emote != 0) || (spell != 0)
|| (text1 != "") || (text2 != "") || (text3 != "") || (text4 != "") || (text5 != "")
|| (aiscript != "")
|| (model1 != 0) || (model2 != 0) || (orientation != 100))
{
WaypointBehavior *tmpWPB = new WaypointBehavior;
// sLog.outDebug("DEBUG: _load --- Adding WaypointBehavior");
tmpWPB->text[0] = text1;
tmpWPB->text[1] = text2;
tmpWPB->text[2] = text3;
tmpWPB->text[3] = text4;
tmpWPB->text[4] = text5;
tmpWPB->aiscript = aiscript;
tmpWPB->orientation = orientation;
tmpWPB->emote = emote;
tmpWPB->spell = spell;
tmpWPB->model1 = model1;
tmpWPB->model2 = model2;
tmpWPB->HasDone = false;
i_wpBehaviour[count] = tmpWPB;
}
else
{
i_wpBehaviour[count] = NULL;
}
if(!MaNGOS::IsValidMapCoord(i_path[count].x,i_path[count].y))
{
sLog.outErrorDb("ERROR: Creature (guidlow %d,entry %d) have invalid coordinates in his waypoint %d (X: %d, Y: %d).",
c.GetGUIDLow(),c.GetEntry(),count,i_path[count].x,i_path[count].y
);
// prevent invalid coordinates using
MaNGOS::NormalizeMapCoord(i_path[count].x);
MaNGOS::NormalizeMapCoord(i_path[count].y);
i_path[count].z = MapManager::Instance ().GetMap(c.GetMapId(), &c)->GetHeight(i_path[count].x,i_path[count].y, i_path[count].z);
}
// to prevent a misbehaviour inside "update"
// update is alway called with the next wp - but the wpSys needs the current
// so when the routine is called the first time, wpSys gets the last waypoint
// and this prevents the system from performing text/emote, etc
if( count == (sz-1) )
{
if( i_wpBehaviour[count] != NULL )
{
i_wpBehaviour[count]->HasDone = true;
}
}
//if( i_delays[count] < 30 /* millisecond */ )
// i_delays[count] = (rand() % 5000);
++count;
} while( result->NextRow() );
delete result;
assert( sz == count );
}
}
void CWardenDataStorage::LoadWardenDataResult()
{
QueryResult *result = LoginDatabase.Query("SELECT `check`, `data`, `result`, `address`, `length`, `str` FROM warden_data_result");
uint32 count = 0;
if (!result)
{
BarGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded %u warden data and results", count);
return;
}
BarGoLink bar((int)result->GetRowCount());
do
{
++count;
bar.step();
Field *fields = result->Fetch();
uint8 type = fields[0].GetUInt8();
uint32 id = GenerateInternalDataID();
WardenData *wd = new WardenData();
wd->Type = type;
if (type == PAGE_CHECK_A || type == PAGE_CHECK_B || type == DRIVER_CHECK)
{
std::string data = fields[1].GetCppString();
wd->i.SetHexStr(data.c_str());
int len = data.size() / 2;
if (wd->i.GetNumBytes() < len)
{
uint8 temp[24];
memset(temp, 0, len);
memcpy(temp, wd->i.AsByteArray(), wd->i.GetNumBytes());
std::reverse(temp, temp + len);
wd->i.SetBinary((uint8*)temp, len);
}
}
if (type == MEM_CHECK || type == MODULE_CHECK)
MemCheckIds.push_back(id);
if (type == MEM_CHECK || type == PAGE_CHECK_A || type == PAGE_CHECK_B || type == PROC_CHECK)
{
wd->Address = fields[3].GetUInt32();
wd->Length = fields[4].GetUInt8();
}
// PROC_CHECK support missing
if (type == MEM_CHECK || type == MPQ_CHECK || type == LUA_STR_CHECK || type == DRIVER_CHECK || type == MODULE_CHECK)
wd->str = fields[5].GetCppString();
_data_map[id] = wd;
if (type == MPQ_CHECK || type == MEM_CHECK)
{
std::string result = fields[2].GetCppString();
WardenDataResult *wr = new WardenDataResult();
wr->res.SetHexStr(result.c_str());
int len = result.size() / 2;
if (wr->res.GetNumBytes() < len)
{
uint8 *temp = new uint8[len];
memset(temp, 0, len);
memcpy(temp, wr->res.AsByteArray(), wr->res.GetNumBytes());
std::reverse(temp, temp + len);
wr->res.SetBinary((uint8*)temp, len);
delete [] temp;
}
_result_map[id] = wr;
}
} while (result->NextRow());
delete result;
sLog.outString();
sLog.outString(">> Loaded %u warden data and results", count);
}
void AchievementGlobalMgr::LoadRewards()
{
m_achievementRewards.clear(); // need for reload case
// 0 1 2 3 4 5 6
QueryResult *result = WorldDatabase.Query("SELECT entry, title_A, title_H, item, sender, subject, text FROM achievement_reward");
if(!result)
{
barGoLink bar(1);
bar.step();
sLog.outString("");
sLog.outErrorDb(">> Loaded 0 achievement rewards. DB table `achievement_reward` is empty.");
return;
}
barGoLink bar(result->GetRowCount());
do
{
bar.step();
Field *fields = result->Fetch();
uint32 entry = fields[0].GetUInt32();
if (!sAchievementStore.LookupEntry(entry))
{
sLog.outErrorDb( "Table `achievement_reward` has wrong achievement (Entry: %u), ignore", entry);
continue;
}
AchievementReward reward;
reward.titleId[0] = fields[1].GetUInt32();
reward.titleId[1] = fields[2].GetUInt32();
reward.itemId = fields[3].GetUInt32();
reward.sender = fields[4].GetUInt32();
reward.subject = fields[5].GetCppString();
reward.text = fields[6].GetCppString();
if ((reward.titleId[0]==0)!=(reward.titleId[1]==0))
sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) has title (A: %u H: %u) only for one from teams.", entry, reward.titleId[0], reward.titleId[1]);
// must be title or mail at least
if (!reward.titleId[0] && !reward.titleId[1] && !reward.sender)
{
sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) not have title or item reward data, ignore.", entry);
continue;
}
if (reward.titleId[0])
{
CharTitlesEntry const* titleEntry = sCharTitlesStore.LookupEntry(reward.titleId[0]);
if (!titleEntry)
{
sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) has invalid title id (%u) in `title_A`, set to 0", entry, reward.titleId[0]);
reward.titleId[0] = 0;
}
}
if (reward.titleId[1])
{
CharTitlesEntry const* titleEntry = sCharTitlesStore.LookupEntry(reward.titleId[1]);
if (!titleEntry)
{
sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) has invalid title id (%u) in `title_A`, set to 0", entry, reward.titleId[1]);
reward.titleId[1] = 0;
}
}
//check mail data before item for report including wrong item case
if (reward.sender)
{
if (!objmgr.GetCreatureTemplate(reward.sender))
{
sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) has invalid creature entry %u as sender, mail reward skipped.", entry, reward.sender);
reward.sender = 0;
}
}
else
{
if (reward.itemId)
sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) not have sender data but have item reward, item will not rewarded", entry);
if (!reward.subject.empty())
sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) not have sender data but have mail subject.", entry);
if (!reward.text.empty())
sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) not have sender data but have mail text.", entry);
}
if (reward.itemId)
{
if (!objmgr.GetItemPrototype(reward.itemId))
{
sLog.outErrorDb( "Table `achievement_reward` (Entry: %u) has invalid item id %u, reward mail will be without item.", entry, reward.itemId);
reward.itemId = 0;
}
}
m_achievementRewards[entry] = reward;
} while (result->NextRow());
delete result;
sLog.outString();
sLog.outString( ">> Loaded %u achievement reward locale strings", m_achievementRewardLocales.size() );
}
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( 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 = 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)
{
if(!sHolidaysStore.LookupEntry(pGameEvent.holiday_id))
{
sLog.outErrorDb("`game_event` game event id (%i) have not existed holiday id %u.",event_id,pGameEvent.holiday_id);
pGameEvent.holiday_id = 0;
}
}
pGameEvent.description = fields[6].GetCppString();
} while( result->NextRow() );
delete result;
sLog.outString();
sLog.outString( ">> Loaded %u game events", count );
}
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( result->GetRowCount() );
do
{
Field *fields = result->Fetch();
bar.step();
uint32 guid = fields[0].GetUInt32();
int16 event_id = fields[1].GetInt16();
int32 internal_event_id = mGameEvent.size() + event_id - 1;
if(internal_event_id < 0 || 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;
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( result->GetRowCount() );
do
{
Field *fields = result->Fetch();
bar.step();
uint32 guid = fields[0].GetUInt32();
int16 event_id = fields[1].GetInt16();
int32 internal_event_id = mGameEvent.size() + event_id - 1;
if(internal_event_id < 0 || 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;
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 );
}
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( 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(!objmgr.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());
// 0 1 2
result = WorldDatabase.Query("SELECT id, quest, event FROM game_event_creature_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( result->GetRowCount() );
do
{
Field *fields = result->Fetch();
bar.step();
uint32 id = fields[0].GetUInt32();
uint32 quest = fields[1].GetUInt32();
uint16 event_id = fields[2].GetUInt16();
if(event_id >= mGameEventQuests.size())
{
sLog.outErrorDb("`game_event_creature_quest` game event id (%u) is out of range compared to max event id in `game_event`",event_id);
continue;
}
++count;
QuestRelList& questlist = mGameEventQuests[event_id];
questlist.push_back(QuestRelation(id, quest));
} while( result->NextRow() );
delete result;
sLog.outString();
sLog.outString( ">> Loaded %u quests additions in game events", count );
}
mGameEventPoolIds.resize(mGameEvent.size()*2-1);
// 1 2
result = WorldDatabase.Query("SELECT pool_template.entry, game_event_pool.event "
"FROM pool_template JOIN game_event_pool ON pool_template.entry = game_event_pool.pool_entry");
count = 0;
if( !result )
{
barGoLink bar2(1);
bar2.step();
sLog.outString();
sLog.outString(">> Loaded %u pools in game events", count );
}
else
{
barGoLink bar2( result->GetRowCount() );
do
{
Field *fields = result->Fetch();
bar2.step();
uint32 entry = fields[0].GetUInt16();
int16 event_id = fields[1].GetInt16();
int32 internal_event_id = mGameEvent.size() + event_id - 1;
if(internal_event_id < 0 || internal_event_id >= mGameEventPoolIds.size())
{
sLog.outErrorDb("`game_event_pool` game event id (%i) is out of range compared to max event id in `game_event`",event_id);
continue;
}
if (!poolhandler.CheckPool(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.", entry);
continue;
}
++count;
IdList& poollist = mGameEventPoolIds[internal_event_id];
poollist.push_back(entry);
} while( result->NextRow() );
sLog.outString();
sLog.outString( ">> Loaded %u pools in game events", count );
delete result;
}
}
bool OnGossipSelect(Player* player, Creature* creature, uint32 /*uiSender*/, uint32 uiAction)
{
player->PlayerTalkClass->ClearMenus();
switch(uiAction)
{
case ARENA_GOODBYE:
{
player->PlayerTalkClass->SendCloseGossip();
break;
}
case ARENA_HELP:
{
ChatHandler(player->GetSession()).PSendSysMessage("|cffff6060[INFO]:|r Este npc crea una lista con los mejores players del server, un top 10 de ellos.");
break;
}
case ARENA_1V1_LADDER:
case ARENA_2V2_LADDER:
case ARENA_5V5_LADDER:
case ARENA_3V3_LADDER:
{
uint32 teamType = optionToTeamType(uiAction);
QueryResult result = CharacterDatabase.PQuery("SELECT arenaTeamId, name, rating FROM arena_team WHERE type = '%u' ORDER BY rating DESC LIMIT %u;", teamType, ARENA_MAX_RESULTS);
if(!result)
{
player->ADD_GOSSIP_ITEM(7, "No...", GOSSIP_SENDER_MAIN, ARENA_GOODBYE);
player->SEND_GOSSIP_MENU(1, creature->GetGUID());
}
else
{
std::string name;
uint32 teamId, rating, rank = 1;
player->ADD_GOSSIP_ITEM(0,"Top Arena Lista de Gladiadores:", GOSSIP_SENDER_MAIN, ARENA_GOODBYE);
do
{
Field *fields = result->Fetch();
teamId = fields[0].GetUInt32();
name = fields[1].GetString();
rating = fields[2].GetUInt32();
std::stringstream buffer;
buffer << rank << ". " << name;
buffer << ": " << "|cFF1E90FF" << rating << "|r" << " rating!";
player->ADD_GOSSIP_ITEM(4, buffer.str(), GOSSIP_SENDER_MAIN, ARENA_START_TEAM_LOOKUP + teamId);
rank++;
}
while(result->NextRow());
player->ADD_GOSSIP_ITEM(7, "Adios...", GOSSIP_SENDER_MAIN, ARENA_GOODBYE);
player->SEND_GOSSIP_MENU(90086, creature->GetGUID());
}
break;
}
default:
{
if (uiAction > ARENA_START_TEAM_LOOKUP)
{
uint32 teamId = uiAction - ARENA_START_TEAM_LOOKUP;
QueryResult result = CharacterDatabase.PQuery("SELECT name, rating, seasonWins, seasonGames - seasonWins, weekWins, weekGames - weekWins, rank, captainGuid , type FROM arena_team WHERE arenaTeamId = '%u'", teamId);
if(!result)
{
player->GetSession()->SendNotification("Team de arena no funciona!...");
player->PlayerTalkClass->SendCloseGossip();
return true;
}
Field *fields = result->Fetch();
std::string name = fields[0].GetString();
uint32 rating = fields[1].GetUInt32();
uint32 seasonWins = fields[2].GetUInt32();
uint32 seasonLosses = fields[3].GetUInt32();
uint32 weekWins = fields[4].GetUInt32();
uint32 weekLosses = fields[5].GetUInt32();
uint32 rank = fields[6].GetUInt32();
uint32 captainGuid = fields[7].GetUInt32();
uint32 type = fields[8].GetUInt32();
uint32 parentOption = teamTypeToOption(type);
std::string seasonWinPercentage = getWinPercent(seasonWins, seasonLosses);
std::string weekWinPercentage = getWinPercent(weekWins, weekLosses);
std::stringstream buf;
buf << "Team Name: " << "|cFF1E90FF" << name << "|r";
player->ADD_GOSSIP_ITEM(7, buf.str(), GOSSIP_SENDER_MAIN, parentOption);
buf.str("");
buf << "Rating: " << "|cFF1E90FF" << rating << "|r" << " (Rank: " << "|cFF1E90FF" << rank << "|r" << ", Type: " << "|cFF1E90FF" << type << "v" << type << "|r"")";
player->ADD_GOSSIP_ITEM(4, buf.str(), GOSSIP_SENDER_MAIN, parentOption);
buf.str("");
buf << "Total Week: " << "|cFF1E90FF" << weekWins << "-" << weekLosses << "|r"" (" << "|cFF1E90FF" << weekWinPercentage << "|r" << "win)";
player->ADD_GOSSIP_ITEM(4, buf.str(), GOSSIP_SENDER_MAIN, parentOption);
buf.str("");
buf << "Total Season: " << "|cFF1E90FF" << seasonWins << "-" << seasonLosses << "|r" << " (" << "|cFF1E90FF" << seasonWinPercentage << "|r" << " win)";
player->ADD_GOSSIP_ITEM(4, buf.str(), GOSSIP_SENDER_MAIN, parentOption);
QueryResult members = CharacterDatabase.PQuery("SELECT a.guid, a.personalRating, a.weekWins, a.weekGames - a.weekWins, a.seasonWins, a.seasonGames - a.seasonWins, c.name, c.race, c.class, c.level FROM arena_team_member a LEFT JOIN characters c ON c.guid = a.guid WHERE arenaTeamId = '%u' ORDER BY a.guid = '%u' DESC, a.seasonGames DESC, c.name ASC", teamId, captainGuid);
if(!members)
{
player->ADD_GOSSIP_ITEM(7, "No team members found...?", GOSSIP_SENDER_MAIN, parentOption);
}
else
{
uint32 memberPos = 1;
uint32 memberCount = members->GetRowCount();
uint32 guid, personalRating, level;
std::string name, race, Class;
buf.str("");
buf << " --- " << memberCount << " team" << ((memberCount == 1) ? " member" : " members") << " found" << " ---";
player->ADD_GOSSIP_ITEM(0, buf.str(), GOSSIP_SENDER_MAIN, parentOption);
do
{
fields = members->Fetch();
guid = fields[0].GetUInt32();
personalRating = fields[1].GetUInt32();
weekWins= fields[2].GetUInt32();
weekLosses = fields[3].GetUInt32();
seasonWins = fields[4].GetUInt32();
seasonLosses = fields[5].GetUInt32();
name = fields[6].GetString();
race = raceToString(fields[7].GetUInt8());
Class = classToString(fields[8].GetUInt8());
level = fields[9].GetUInt32();
seasonWinPercentage = getWinPercent(seasonWins, seasonLosses);
weekWinPercentage = getWinPercent(weekWins, weekLosses);
buf.str("");
buf << memberPos << ". ";
if (guid == captainGuid)
buf << "Team Captain ";
buf << race << " " << Class << ", " << "|cFF1E90FF" << personalRating << "|r" << " personal rating!";
player->ADD_GOSSIP_ITEM(4, buf.str(), GOSSIP_SENDER_MAIN, parentOption);
buf.str("");
buf << "Week: " << "|cFF1E90FF" << weekWins << "-" << weekLosses << "|r" << " (" << "|cFF1E90FF" << weekWinPercentage << "|r" << " win), " << "|cFF1E90FF" << (weekWins + weekLosses) << "|r" << " played!";
player->ADD_GOSSIP_ITEM(4, buf.str(), GOSSIP_SENDER_MAIN, parentOption);
buf.str("");
buf << "Season: " << "|cFF1E90FF" << seasonWins << "-" << seasonLosses << "|r" << " (" << "|cFF1E90FF" << seasonWinPercentage << "|r" << " win), " << "|cFF1E90FF" << (seasonWins + seasonLosses) << "|r" << " played!";
player->ADD_GOSSIP_ITEM(4, buf.str(), GOSSIP_SENDER_MAIN, parentOption);
memberPos++;
}
while(members->NextRow());
}
player->SEND_GOSSIP_MENU(90087, creature->GetGUID());
}
}
}
return true;
}
void LootMgr::LoadLootTables(const char * szTableName,LootStore * LootTable)
{
/* DBCFile *dbc = new DBCFile();
dbc->open("DBC/ItemRandomProperties.dbc");
_propCount = dbc->getRecordCount();
delete dbc;*/
//HM_NAMESPACE::hash_map<uint32, std::vector<loot_tb> > loot_db;
//HM_NAMESPACE::hash_map<uint32, std::vector<loot_tb> >::iterator itr;
vector< pair< uint32, vector< tempy > > > db_cache;
vector< pair< uint32, vector< tempy > > >::iterator itr;
db_cache.reserve(10000);
LootStore::iterator tab;
QueryResult *result =WorldDatabase.Query("SELECT * FROM %s ORDER BY entryid ASC",szTableName);
if(!result)
{
Log.Error("LootMgr", "Loading loot from table %s failed.", szTableName);
return;
}
uint32 entry_id = 0;
uint32 last_entry = 0;
uint32 total =(uint32) result->GetRowCount();
int pos = 0;
vector< tempy > ttab;
tempy t;
do
{
Field *fields = result->Fetch();
entry_id = fields[1].GetUInt32();
if(entry_id < last_entry)
{
Log.Error("LootMgr", "WARNING: Out of order loot table being loaded.\n");
return;
}
if(entry_id != last_entry)
{
if(last_entry != 0)
db_cache.push_back( make_pair( last_entry, ttab) );
ttab.clear();
}
t.itemid = fields[2].GetUInt32();
t.chance = fields[3].GetFloat();
t.chance_2 = fields[4].GetFloat();
t.mincount = fields[5].GetUInt32();
t.maxcount = fields[6].GetUInt32();
t.ffa_loot = fields[7].GetUInt32();
ttab.push_back( t );
last_entry = entry_id;
} while( result->NextRow() );
//last list was not pushed in
if(last_entry != 0 && ttab.size())
db_cache.push_back( make_pair( last_entry, ttab) );
pos = 0;
total = (uint32)db_cache.size();
ItemPrototype* proto;
uint32 itemid;
//for(itr=loot_db.begin();itr!=loot_db.end();++itr)
for( itr = db_cache.begin(); itr != db_cache.end(); ++itr)
{
entry_id = (*itr).first;
if(LootTable->end()==LootTable->find(entry_id))
{
StoreLootList list;
//list.count = itr->second.size();
list.count = (uint32)(*itr).second.size();
list.items=new StoreLootItem[list.count];
uint32 ind=0;
//for(std::vector<loot_tb>::iterator itr2=itr->second.begin();itr2!=itr->second.end();++itr2)
for(vector< tempy >::iterator itr2 = (*itr).second.begin(); itr2 != (*itr).second.end(); ++itr2)
{
//Omit items that are not in db to prevent future bugs
//uint32 itemid=(*itr2).itemid;
itemid = itr2->itemid;
proto=ItemPrototypeStorage.LookupEntry(itemid);
if(!proto)
{
list.items[ind].item.itemproto=NULL;
Log.Warning("LootMgr", "Loot for %u contains non-existant item. (%s)",entry_id, szTableName);
}
else
{
list.items[ind].item.itemproto=proto;
list.items[ind].item.displayid=proto->DisplayInfoID;
//list.items[ind].chance=(*itr2).chance;
list.items[ind].chance= itr2->chance;
list.items[ind].chance2 = itr2->chance_2;
list.items[ind].mincount = itr2->mincount;
list.items[ind].maxcount = itr2->maxcount;
list.items[ind].ffa_loot = itr2->ffa_loot;
if(LootTable == &GOLoot)
{
if(proto->Class == ITEM_CLASS_QUEST)
{
//printf("Quest item \"%s\" allocated to quest ", proto->Name1.c_str());
sQuestMgr.SetGameObjectLootQuest(itr->first, itemid);
quest_loot_go[entry_id].insert(proto->ItemId);
}
}
}
ind++;
}
(*LootTable)[entry_id]=list;
}
}
//sLog.outString(" %d loot templates loaded from %s", db_cache.size(), szTableName);
// loot_db.clear();
delete result;
result = NULL;
}
//teleport to creature
static bool HandleGoCreatureCommand(ChatHandler* handler, char const* args)
{
if (!*args)
return false;
Player* player = handler->GetSession()->GetPlayer();
// "id" or number or [name] Shift-click form |color|Hcreature_entry:creature_id|h[name]|h|r
char* param1 = handler->extractKeyFromLink((char*)args, "Hcreature");
if (!param1)
return false;
std::ostringstream whereClause;
// User wants to teleport to the NPC's template entry
if (strcmp(param1, "id") == 0)
{
// Get the "creature_template.entry"
// number or [name] Shift-click form |color|Hcreature_entry:creature_id|h[name]|h|r
char* tail = strtok(NULL, "");
if (!tail)
return false;
char* id = handler->extractKeyFromLink(tail, "Hcreature_entry");
if (!id)
return false;
int32 entry = atoi(id);
if (!entry)
return false;
whereClause << "WHERE id = '" << entry << '\'';
}
else
{
int32 guid = atoi(param1);
// Number is invalid - maybe the user specified the mob's name
if (!guid)
{
std::string name = param1;
WorldDatabase.EscapeString(name);
whereClause << ", creature_template WHERE creature.id = creature_template.entry AND creature_template.name " _LIKE_" '" << name << '\'';
}
else
whereClause << "WHERE guid = '" << guid << '\'';
}
QueryResult result = WorldDatabase.PQuery("SELECT position_x, position_y, position_z, orientation, map FROM creature %s", whereClause.str().c_str());
if (!result)
{
handler->SendSysMessage(LANG_COMMAND_GOCREATNOTFOUND);
handler->SetSentErrorMessage(true);
return false;
}
if (result->GetRowCount() > 1)
handler->SendSysMessage(LANG_COMMAND_GOCREATMULTIPLE);
Field* fields = result->Fetch();
float x = fields[0].GetFloat();
float y = fields[1].GetFloat();
float z = fields[2].GetFloat();
float o = fields[3].GetFloat();
uint32 mapId = fields[4].GetUInt16();
if (!MapManager::IsValidMapCoord(mapId, x, y, z, o) || sObjectMgr->IsTransportMap(mapId))
{
handler->PSendSysMessage(LANG_INVALID_TARGET_COORD, x, y, mapId);
handler->SetSentErrorMessage(true);
return false;
}
// stop flight if need
if (player->IsInFlight())
{
player->GetMotionMaster()->MovementExpired();
player->CleanupAfterTaxiFlight();
}
// save only in non-flight case
else
player->SaveRecallPosition();
player->TeleportTo(mapId, x, y, z, o);
return true;
}
void WorldSession::HandleOfferPetitionOpcode(WorldPacket & recv_data)
{
sLog->outDebug(LOG_FILTER_NETWORKIO, "Received opcode CMSG_OFFER_PETITION"); // ok
uint8 signs = 0;
uint64 petitionguid, plguid;
uint32 type, junk;
Player* player;
recv_data >> junk; // this is not petition type!
recv_data >> petitionguid; // petition guid
recv_data >> plguid; // player guid
player = ObjectAccessor::FindPlayer(plguid);
if (!player)
return;
QueryResult result = CharacterDatabase.PQuery("SELECT type FROM petition WHERE petitionguid = '%u'", GUID_LOPART(petitionguid));
if (!result)
return;
Field* fields = result->Fetch();
type = fields[0].GetUInt8();
sLog->outDebug(LOG_FILTER_NETWORKIO, "OFFER PETITION: type %u, GUID1 %u, to player id: %u", type, GUID_LOPART(petitionguid), GUID_LOPART(plguid));
if (!sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD) && GetPlayer()->GetTeam() != player->GetTeam())
{
if (type != GUILD_CHARTER_TYPE)
SendArenaTeamCommandResult(ERR_ARENA_TEAM_INVITE_SS, "", "", ERR_ARENA_TEAM_NOT_ALLIED);
else
Guild::SendCommandResult(this, GUILD_CREATE_S, ERR_GUILD_NOT_ALLIED);
return;
}
if (type != GUILD_CHARTER_TYPE)
{
if (player->getLevel() < sWorld->getIntConfig(CONFIG_MAX_PLAYER_LEVEL))
{
// player is too low level to join an arena team
SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, player->GetName(), "", ERR_ARENA_TEAM_TARGET_TOO_LOW_S);
return;
}
uint8 slot = ArenaTeam::GetSlotByType(type);
if (slot >= MAX_ARENA_SLOT)
return;
if (player->GetArenaTeamId(slot))
{
// player is already in an arena team
SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, player->GetName(), "", ERR_ALREADY_IN_ARENA_TEAM_S);
return;
}
if (player->GetArenaTeamIdInvited())
{
SendArenaTeamCommandResult(ERR_ARENA_TEAM_INVITE_SS, "", _player->GetName(), ERR_ALREADY_INVITED_TO_ARENA_TEAM_S);
return;
}
}
else
{
if (player->GetGuildId())
{
Guild::SendCommandResult(this, GUILD_INVITE_S, ERR_ALREADY_IN_GUILD_S, _player->GetName());
return;
}
if (player->GetGuildIdInvited())
{
Guild::SendCommandResult(this, GUILD_INVITE_S, ERR_ALREADY_INVITED_TO_GUILD_S, _player->GetName());
return;
}
}
result = CharacterDatabase.PQuery("SELECT playerguid FROM petition_sign WHERE petitionguid = '%u'", GUID_LOPART(petitionguid));
// result == NULL also correct charter without signs
if (result)
signs = uint8(result->GetRowCount());
WorldPacket data(SMSG_PETITION_SHOW_SIGNATURES, (8+8+4+signs+signs*12));
data << uint64(petitionguid); // petition guid
data << uint64(_player->GetGUID()); // owner guid
data << uint32(GUID_LOPART(petitionguid)); // guild guid
data << uint8(signs); // sign's count
for (uint8 i = 1; i <= signs; ++i)
{
Field* fields2 = result->Fetch();
plguid = fields2[0].GetUInt64();
data << uint64(plguid); // Player GUID
data << uint32(0); // there 0 ...
result->NextRow();
}
player->GetSession()->SendPacket(&data);
}
// load all events and their related invites from invite
void CalendarMgr::LoadCalendarsFromDB()
{
// in case of reload (not yet implemented)
m_MaxInviteId = 0;
m_MaxEventId = 0;
m_EventStore.clear();
sLog.outString("Loading Calendar Events...");
// 0 1 2 3 4 5 6 7 8
QueryResult* eventsQuery = CharacterDatabase.Query("SELECT eventId, creatorGuid, guildId, type, flags, dungeonId, eventTime, title, description FROM calendar_events ORDER BY eventId");
if (!eventsQuery)
{
BarGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> calendar_events table is empty!");
}
else
{
BarGoLink bar(eventsQuery->GetRowCount());
do
{
Field* field = eventsQuery->Fetch();
bar.step();
uint64 eventId = field[0].GetUInt64();
CalendarEvent& newEvent = m_EventStore[eventId];
newEvent.EventId = eventId;
newEvent.CreatorGuid = ObjectGuid(HIGHGUID_PLAYER, field[1].GetUInt32());
newEvent.GuildId = field[2].GetUInt32();
newEvent.Type = CalendarEventType(field[3].GetUInt8());
newEvent.Flags = field[4].GetUInt32();
newEvent.DungeonId = field[5].GetInt32();
newEvent.EventTime = time_t(field[6].GetUInt32());
newEvent.Title = field[7].GetCppString();
newEvent.Description = field[8].GetCppString();
m_MaxEventId = std::max(eventId, m_MaxEventId);
}
while (eventsQuery->NextRow());
sLog.outString();
sLog.outString(">> Loaded %u events!", uint32(eventsQuery->GetRowCount()));
delete eventsQuery;
}
sLog.outString("Loading Calendar invites...");
// 0 1 2 3 4 5 6
QueryResult* invitesQuery = CharacterDatabase.Query("SELECT inviteId, eventId, inviteeGuid, senderGuid, status, lastUpdateTime, rank FROM calendar_invites ORDER BY inviteId");
if (!invitesQuery)
{
BarGoLink bar(1);
bar.step();
sLog.outString();
if (m_MaxEventId) // An Event was loaded before
{
// delete all events (no event exist without at least one invite)
m_EventStore.clear();
m_MaxEventId = 0;
CharacterDatabase.DirectExecute("TRUNCATE TABLE calendar_events");
sLog.outString(">> calendar_invites table is empty, cleared calendar_events table!");
}
else
sLog.outString(">> calendar_invite table is empty!");
}
else
{
if (m_MaxEventId)
{
uint64 totalInvites = 0;
uint32 deletedInvites = 0;
BarGoLink bar(invitesQuery->GetRowCount());
do
{
Field* field = invitesQuery->Fetch();
uint64 inviteId = field[0].GetUInt64();
uint64 eventId = field[1].GetUInt64();
ObjectGuid inviteeGuid = ObjectGuid(HIGHGUID_PLAYER, field[2].GetUInt32());
ObjectGuid senderGuid = ObjectGuid(HIGHGUID_PLAYER, field[3].GetUInt32());
CalendarInviteStatus status = CalendarInviteStatus(field[4].GetUInt8());
time_t lastUpdateTime = time_t(field[5].GetUInt32());
CalendarModerationRank rank = CalendarModerationRank(field[6].GetUInt8());
CalendarEvent* event = GetEventById(eventId);
if (!event)
{
// delete invite
CharacterDatabase.PExecute("DELETE FROM calendar_invites WHERE inviteId =" UI64FMTD, field[0].GetUInt64());
++deletedInvites;
continue;
}
CalendarInvite* invite = new CalendarInvite(event, inviteId, senderGuid, inviteeGuid, lastUpdateTime, status, rank, "");
event->AddInvite(invite);
++totalInvites;
m_MaxInviteId = std::max(inviteId, m_MaxInviteId);
}
while (invitesQuery->NextRow());
sLog.outString();
sLog.outString(">> Loaded " UI64FMTD " invites! %s", totalInvites, (deletedInvites != 0) ? "(deleted some invites without corresponding event!)" : "");
}
else
{
// delete all invites (no invites exist without events)
CharacterDatabase.DirectExecute("TRUNCATE TABLE calendar_invites");
sLog.outString(">> calendar_invites table is cleared! (invites without events found)");
}
delete invitesQuery;
}
sLog.outString();
}
void CreatureLinkingMgr::LoadFromDB()
{
// Clear maps
m_creatureLinkingMap.clear();
m_creatureLinkingGuidMap.clear();
m_eventTriggers.clear(); // master
m_eventGuidTriggers.clear();
QueryResult* result = WorldDatabase.Query("SELECT entry, map, master_entry, flag, search_range FROM creature_linking_template");
uint32 count = 0;
if (!result)
{
BarGoLink bar(1);
bar.step();
sLog.outString(">> Table creature_linking_template is empty.");
sLog.outString();
return;
}
BarGoLink bar((int)result->GetRowCount());
do
{
bar.step();
Field* fields = result->Fetch();
CreatureLinkingInfo tmp;
uint32 entry = fields[0].GetUInt32();
tmp.mapId = fields[1].GetUInt32();
tmp.masterId = fields[2].GetUInt32();
tmp.linkingFlag = fields[3].GetUInt16();
tmp.searchRange = fields[4].GetUInt16();
tmp.masterDBGuid = 0; // Will be initialized for unique mobs later (only for spawning dependend)
if (!IsLinkingEntryValid(entry, &tmp, true))
continue;
// Store db-guid for master of whom pTmp is spawn dependend (only non-local bosses)
if (tmp.searchRange == 0 && (tmp.linkingFlag & (FLAG_CANT_SPAWN_IF_BOSS_DEAD | FLAG_CANT_SPAWN_IF_BOSS_ALIVE)))
{
if (QueryResult* guid_result = WorldDatabase.PQuery("SELECT guid FROM creature WHERE id=%u AND map=%u LIMIT 1", tmp.masterId, tmp.mapId))
{
tmp.masterDBGuid = (*guid_result)[0].GetUInt32();
delete guid_result;
}
}
++count;
// Add it to the map
m_creatureLinkingMap.insert(CreatureLinkingMap::value_type(entry, tmp));
// Store master_entry
m_eventTriggers.insert(tmp.masterId);
}
while (result->NextRow());
sLog.outString();
sLog.outString(">> Loaded creature linking for %u creature-entries", count);
delete result;
result = WorldDatabase.Query("SELECT guid, master_guid, flag FROM creature_linking");
count = 0;
if (!result)
{
BarGoLink bar(1);
bar.step();
sLog.outString(">> Table creature_linking is empty.");
sLog.outString();
return;
}
BarGoLink guidBar((int)result->GetRowCount());
do
{
guidBar.step();
Field* fields = result->Fetch();
CreatureLinkingInfo tmp;
uint32 guid = fields[0].GetUInt32();
tmp.mapId = INVALID_MAP_ID; // some invalid value, this marks the guid-linking
tmp.masterId = fields[1].GetUInt32();
tmp.linkingFlag = fields[2].GetUInt16();
tmp.masterDBGuid = tmp.masterId;
tmp.searchRange = 0;
if (!IsLinkingEntryValid(guid, &tmp, false))
continue;
++count;
// Add it to the map
m_creatureLinkingGuidMap.insert(CreatureLinkingMap::value_type(guid, tmp));
// Store master_guid
m_eventGuidTriggers.insert(tmp.masterId);
}
while (result->NextRow());
sLog.outString();
sLog.outString(">> Loaded creature linking for %u creature-Guids", count);
delete result;
}
bool OnGossipSelect(Player* player, Creature* creature, uint32 /*uiSender*/, uint32 uiAction) {
player->PlayerTalkClass->ClearMenus();
switch(uiAction) {
case 0:
// Here should the magic happend
case ARENA_GOODBYE:
{
player->PlayerTalkClass->SendCloseGossip();
break;
}
case ARENA_2V2_LADDER:
case ARENA_5V5_LADDER: // 1v1
case ARENA_3V3_LADDER:
{
uint32 teamType = optionToTeamType(uiAction);
QueryResult result = CharacterDatabase.PQuery(
"SELECT arenaTeamid, name, rating, seasonWins, seasonGames - seasonWins "
"FROM `arena_team` WHERE `type` = '%u' ORDER BY rating DESC LIMIT %u;", teamType, ARENA_MAX_RESULTS
);
if(!result) {
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, "Goodbye", GOSSIP_SENDER_MAIN, ARENA_GOODBYE);
player->SEND_GOSSIP_MENU(ARENA_GOSSIP_NOTEAMS, creature->GetGUID());
} else {
//uint64 rowCount = result->GetRowCount();
std::string name;
uint32 teamId, rating, seasonWins, seasonLosses, rank = 1;
do {
Field *fields = result->Fetch();
teamId = fields[0].GetUInt32();
name = fields[1].GetString();
rating = fields[2].GetUInt32();
seasonWins = fields[3].GetUInt32();
seasonLosses = fields[4].GetUInt32();
std::stringstream buffer;
buffer << rank << ". [" << rating << "] " << name;
buffer << " (" << seasonWins << "-" << seasonLosses << ")";
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_BATTLE, buffer.str(), GOSSIP_SENDER_MAIN, ARENA_START_TEAM_LOOKUP + teamId);
rank++;
} while(result->NextRow());
player->SEND_GOSSIP_MENU(ARENA_GOSSIP_TEAMS, creature->GetGUID());
}
break;
}
default:
{
if (uiAction > ARENA_START_TEAM_LOOKUP)
{
uint32 teamId = uiAction - ARENA_START_TEAM_LOOKUP;
// lookup team
QueryResult result = CharacterDatabase.PQuery(
// 0 1 2 3
"SELECT name, rating, seasonWins, seasonGames - seasonWins, "
// 4 5 6 7 8
"weekWins, weekGames - weekWins, rank, captainGuid , type "
"FROM `arena_team` WHERE `arenaTeamId` = '%u'", teamId);
// no team found
if(!result) {
player->GetSession()->SendNotification("Arena team not found...");
player->PlayerTalkClass->SendCloseGossip();
return true;
}
// populate the results
Field *fields = result->Fetch();
std::string name = fields[0].GetString();
uint32 rating = fields[1].GetUInt32();
uint32 seasonWins = fields[2].GetUInt32();
uint32 seasonLosses = fields[3].GetUInt32();
uint32 weekWins = fields[4].GetUInt32();
uint32 weekLosses = fields[5].GetUInt32();
uint32 rank = fields[6].GetUInt32();
uint32 captainGuid = fields[7].GetUInt32();
uint32 type = fields[8].GetUInt32();
uint32 parentOption = teamTypeToOption(type);
std::string seasonWinPercentage = getWinPercent(seasonWins, seasonLosses);
std::string weekWinPercentage = getWinPercent(weekWins, weekLosses);
std::stringstream buf;
buf << "Team Name: " << name;
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_BATTLE, buf.str(), GOSSIP_SENDER_MAIN, parentOption);
buf.str("");
buf << "Rating: " << rating << " (rank " << rank << ", bracket " << type << "v" << type << ")";
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_DOT, buf.str(), GOSSIP_SENDER_MAIN, parentOption);
buf.str("");
buf << "Total Week: " << weekWins << "-" << weekLosses << " (" << weekWinPercentage << " win), " << (weekWins + weekLosses) << " played";
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_DOT, buf.str(), GOSSIP_SENDER_MAIN, parentOption);
buf.str("");
buf << "Total Season: " << seasonWins << "-" << seasonLosses << " (" << seasonWinPercentage << " win), " << (seasonWins + seasonLosses) << " played";
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_DOT, buf.str(), GOSSIP_SENDER_MAIN, parentOption);
QueryResult members = CharacterDatabase.PQuery(
"SELECT "
// 0 1 2 3
"a.guid, a.personalRating, a.weekWins, a.weekGames - a.weekWins, "
// 4 5
"a.seasonWins, a.seasonGames - seasonWins, "
// 6 7 8 9
"c.name, c.race, c.class, c.level "
"FROM arena_team_member a LEFT JOIN characters c ON a.guid = c.guid "
"WHERE arenaTeamId = '%u' "
"ORDER BY a.guid = '%u' DESC, a.seasonGames DESC, c.name ASC",
teamId, captainGuid);
if(!members) {
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, "No team members found...?", GOSSIP_SENDER_MAIN, parentOption);
} else {
uint32 memberPos = 1;
uint32 memberCount = members->GetRowCount();
uint32 guid, personalRating, level;
std::string name, race, Class;
buf.str("");
buf << memberCount << " team " << ((memberCount == 1) ? "member" : " members") << " found:";
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, buf.str(), GOSSIP_SENDER_MAIN, parentOption);
do {
// populate fields
fields = members->Fetch();
guid = fields[0].GetUInt32();
personalRating = fields[1].GetUInt32();
weekWins= fields[2].GetUInt32();
weekLosses = fields[3].GetUInt32();
seasonWins = fields[4].GetUInt32();
seasonLosses = fields[5].GetUInt32();
name = fields[6].GetString();
race = raceToString(fields[7].GetUInt8());
Class = classToString(fields[8].GetUInt8());
level = fields[9].GetUInt32();
seasonWinPercentage = getWinPercent(seasonWins, seasonLosses);
weekWinPercentage = getWinPercent(weekWins, weekLosses);
// TODO: add output
buf.str(""); // clear it
buf << memberPos << ". ";
if (guid == captainGuid)
buf << "Team Captain ";
buf << name << ", " << getPlayerStatus(guid);
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_INTERACT_1, buf.str(), GOSSIP_SENDER_MAIN, parentOption);
buf.str("");
buf << "Level " << level << " " << race << " " << Class << ", " << personalRating << " personal rating.";
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_DOT, buf.str(), GOSSIP_SENDER_MAIN, parentOption);
buf.str("");
buf << "Week: " << weekWins << "-" << weekLosses << " (" << weekWinPercentage << " win), " << (weekWins + weekLosses) << " played";
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_DOT, buf.str(), GOSSIP_SENDER_MAIN, parentOption);
buf.str("");
buf << "Season: " << seasonWins << "-" << seasonLosses << " (" << seasonWinPercentage << " win), " << (seasonWins + seasonLosses) << " played";
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_DOT, buf.str(), GOSSIP_SENDER_MAIN, parentOption);
memberPos++;
} while(members->NextRow());
}
buf.str("");
buf << "Return to " << type << "v" << type << " rankings!";
player->ADD_GOSSIP_ITEM(GOSSIP_ICON_CHAT, buf.str(), GOSSIP_SENDER_MAIN, parentOption);
player->SEND_GOSSIP_MENU(ARENA_GOSSIP_TEAM_LOOKUP, creature->GetGUID());
}
}
}
return true;
}
void WorldSession::SendAuthResponse(uint8 code, bool queued, uint32 queuePos)
{
QueryResult classResult = LoginDatabase.PQuery("SELECT class, expansion FROM realm_classes WHERE realmId = %u", realmID);
QueryResult raceResult = LoginDatabase.PQuery("SELECT race, expansion FROM realm_races WHERE realmId = %u", realmID);
if (!classResult || !raceResult)
{
TC_LOG_ERROR("network", "Unable to retrieve class or race data.");
return;
}
TC_LOG_ERROR("network", "SMSG_AUTH_RESPONSE");
WorldPacket packet(SMSG_AUTH_RESPONSE, 80);
packet << uint8(code); // Auth response ?
packet.WriteBit(code == AUTH_OK);
if (code == AUTH_OK)
{
packet.WriteBits(0, 21);
packet.WriteBit(0);
packet.WriteBit(0);
packet.WriteBit(0);
packet.WriteBits(classResult->GetRowCount(), 23);
packet.WriteBits(raceResult->GetRowCount(), 23);
packet.WriteBit(0);
packet.WriteBit(0);
packet.WriteBits(0, 21);
}
packet.WriteBit(queued);
if (queued)
packet.WriteBit(1); // Unknown
packet.FlushBits();
if (queued)
packet << uint32(0); // Unknown
if (code == AUTH_OK)
{
packet << uint32(0);
packet << uint8(Expansion());
packet << uint8(Expansion());
do
{
Field* fields = raceResult->Fetch();
packet << fields[0].GetUInt8();
packet << fields[1].GetUInt8();
}
while (raceResult->NextRow());
packet << uint32(0);
packet << uint32(0);
packet << uint32(0);
do
{
Field* fields = classResult->Fetch();
packet << fields[0].GetUInt8();
packet << fields[1].GetUInt8();
}
while (classResult->NextRow());
packet << uint32(0);
}
SendPacket(&packet);
}
void WaypointManager::Load()
{
Cleanup();
uint32 total_paths = 0;
uint32 total_nodes = 0;
uint32 total_behaviors = 0;
std::set<uint32> movementScriptSet;
for(ScriptMapMap::const_iterator itr = sCreatureMovementScripts.begin(); itr != sCreatureMovementScripts.end(); ++itr)
movementScriptSet.insert(itr->first);
// creature_movement
QueryResult *result = WorldDatabase.Query("SELECT id, COUNT(point) FROM creature_movement GROUP BY id");
if (!result)
{
BarGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString( ">> Loaded 0 paths. DB table `creature_movement` is empty." );
}
else
{
total_paths = (uint32)result->GetRowCount();
BarGoLink bar(total_paths);
do
{
bar.step();
Field *fields = result->Fetch();
uint32 id = fields[0].GetUInt32();
uint32 count = fields[1].GetUInt32();
m_pathMap[id].resize(count);
total_nodes += count;
}
while(result->NextRow());
sLog.outString();
sLog.outString( ">> Paths loaded" );
delete result;
// 0 1 2 3 4 5 6
result = WorldDatabase.Query("SELECT id, point, position_x, position_y, position_z, waittime, script_id,"
// 7 8 9 10 11 12 13 14 15 16
"textid1, textid2, textid3, textid4, textid5, emote, spell, orientation, model1, model2 FROM creature_movement");
BarGoLink barRow((int)result->GetRowCount());
// error after load, we check if creature guid corresponding to the path id has proper MovementType
std::set<uint32> creatureNoMoveType;
do
{
barRow.step();
Field *fields = result->Fetch();
uint32 id = fields[0].GetUInt32();
uint32 point = fields[1].GetUInt32();
const CreatureData* cData = sObjectMgr.GetCreatureData(id);
if (!cData)
{
sLog.outErrorDb("Table creature_movement contain path for creature guid %u, but this creature guid does not exist. Skipping.", id);
continue;
}
if (cData->movementType != WAYPOINT_MOTION_TYPE)
creatureNoMoveType.insert(id);
WaypointPath &path = m_pathMap[id];
// the cleanup queries make sure the following is true
MANGOS_ASSERT(point >= 1 && point <= path.size());
WaypointNode &node = path[point-1];
node.x = fields[2].GetFloat();
node.y = fields[3].GetFloat();
node.z = fields[4].GetFloat();
node.orientation = fields[14].GetFloat();
node.delay = fields[5].GetUInt32();
node.script_id = fields[6].GetUInt32();
// prevent using invalid coordinates
if (!MaNGOS::IsValidMapCoord(node.x, node.y, node.z, node.orientation))
{
QueryResult *result1 = WorldDatabase.PQuery("SELECT id, map FROM creature WHERE guid = '%u'", id);
if (result1)
sLog.outErrorDb("Creature (guidlow %d, entry %d) have invalid coordinates in his waypoint %d (X: %f, Y: %f).",
id, result1->Fetch()[0].GetUInt32(), point, node.x, node.y);
else
sLog.outErrorDb("Waypoint path %d, have invalid coordinates in his waypoint %d (X: %f, Y: %f).",
id, point, node.x, node.y);
MaNGOS::NormalizeMapCoord(node.x);
MaNGOS::NormalizeMapCoord(node.y);
if (result1)
{
node.z = sTerrainMgr.LoadTerrain(result1->Fetch()[1].GetUInt32())->GetHeight(node.x, node.y, node.z);
delete result1;
}
WorldDatabase.PExecute("UPDATE creature_movement SET position_x = '%f', position_y = '%f', position_z = '%f' WHERE id = '%u' AND point = '%u'", node.x, node.y, node.z, id, point);
}
if (node.script_id)
{
if (sCreatureMovementScripts.find(node.script_id) == sCreatureMovementScripts.end())
{
sLog.outErrorDb("Table creature_movement for id %u, point %u have script_id %u that does not exist in `creature_movement_scripts`, ignoring", id, point, node.script_id);
continue;
}
movementScriptSet.erase(node.script_id);
}
// WaypointBehavior can be dropped in time. Script_id added may 2010 and can handle all the below behavior.
WaypointBehavior be;
be.model1 = fields[15].GetUInt32();
be.model2 = fields[16].GetUInt32();
be.emote = fields[12].GetUInt32();
be.spell = fields[13].GetUInt32();
for(int i = 0; i < MAX_WAYPOINT_TEXT; ++i)
{
be.textid[i] = fields[7+i].GetUInt32();
if (be.textid[i])
{
if (be.textid[i] < MIN_DB_SCRIPT_STRING_ID || be.textid[i] >= MAX_DB_SCRIPT_STRING_ID)
{
sLog.outErrorDb( "Table `db_script_string` not have string id %u", be.textid[i]);
continue;
}
}
}
if (be.spell && ! sSpellStore.LookupEntry(be.spell))
{
sLog.outErrorDb("Table creature_movement references unknown spellid %u. Skipping id %u with point %u.", be.spell, id, point);
be.spell = 0;
}
if (be.emote)
{
if (!sEmotesStore.LookupEntry(be.emote))
sLog.outErrorDb("Waypoint path %u (Point %u) are using emote %u, but emote does not exist.",id, point, be.emote);
}
// save memory by not storing empty behaviors
if (!be.isEmpty())
{
node.behavior = new WaypointBehavior(be);
++total_behaviors;
}
else
node.behavior = NULL;
}
while(result->NextRow());
if (!creatureNoMoveType.empty())
{
for(std::set<uint32>::const_iterator itr = creatureNoMoveType.begin(); itr != creatureNoMoveType.end(); ++itr)
{
const CreatureData* cData = sObjectMgr.GetCreatureData(*itr);
const CreatureInfo* cInfo = ObjectMgr::GetCreatureTemplate(cData->id);
sLog.outErrorDb("Table creature_movement has waypoint for creature guid %u (entry %u), but MovementType is not WAYPOINT_MOTION_TYPE(2). Creature will not use this path.", *itr, cData->id);
if (cInfo->MovementType == WAYPOINT_MOTION_TYPE)
sLog.outErrorDb(" creature_template for this entry has MovementType WAYPOINT_MOTION_TYPE(2), did you intend to use creature_movement_template ?");
}
}
sLog.outString();
sLog.outString( ">> Waypoints and behaviors loaded" );
sLog.outString();
sLog.outString( ">>> Loaded %u paths, %u nodes and %u behaviors", total_paths, total_nodes, total_behaviors);
delete result;
}
// creature_movement_template
result = WorldDatabase.Query("SELECT entry, COUNT(point) FROM creature_movement_template GROUP BY entry");
if (!result)
{
BarGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString( ">> Loaded 0 path templates. DB table `creature_movement_template` is empty." );
}
else
{
total_nodes = 0;
total_behaviors = 0;
total_paths = (uint32)result->GetRowCount();
BarGoLink barRow(total_paths);
do
{
barRow.step();
Field *fields = result->Fetch();
uint32 entry = fields[0].GetUInt32();
uint32 count = fields[1].GetUInt32();
m_pathTemplateMap[entry].resize(count);
total_nodes += count;
}
while(result->NextRow());
delete result;
sLog.outString();
sLog.outString(">> Path templates loaded");
// 0 1 2 3 4 5 6
result = WorldDatabase.Query("SELECT entry, point, position_x, position_y, position_z, waittime, script_id,"
// 7 8 9 10 11 12 13 14 15 16
"textid1, textid2, textid3, textid4, textid5, emote, spell, orientation, model1, model2 FROM creature_movement_template");
BarGoLink bar(result->GetRowCount());
do
{
bar.step();
Field *fields = result->Fetch();
uint32 entry = fields[0].GetUInt32();
uint32 point = fields[1].GetUInt32();
const CreatureInfo* cInfo = ObjectMgr::GetCreatureTemplate(entry);
if (!cInfo)
{
sLog.outErrorDb("Table creature_movement_template references unknown creature template %u. Skipping.", entry);
continue;
}
WaypointPath &path = m_pathTemplateMap[entry];
// the cleanup queries make sure the following is true
MANGOS_ASSERT(point >= 1 && point <= path.size());
WaypointNode &node = path[point-1];
node.x = fields[2].GetFloat();
node.y = fields[3].GetFloat();
node.z = fields[4].GetFloat();
node.orientation = fields[14].GetFloat();
node.delay = fields[5].GetUInt32();
node.script_id = fields[6].GetUInt32();
// prevent using invalid coordinates
if (!MaNGOS::IsValidMapCoord(node.x, node.y, node.z, node.orientation))
{
sLog.outErrorDb("Table creature_movement_template for entry %u (point %u) are using invalid coordinates position_x: %f, position_y: %f)",
entry, point, node.x, node.y);
MaNGOS::NormalizeMapCoord(node.x);
MaNGOS::NormalizeMapCoord(node.y);
sLog.outErrorDb("Table creature_movement_template for entry %u (point %u) are auto corrected to normalized position_x=%f, position_y=%f",
entry, point, node.x, node.y);
WorldDatabase.PExecute("UPDATE creature_movement_template SET position_x = '%f', position_y = '%f' WHERE entry = %u AND point = %u", node.x, node.y, entry, point);
}
if (node.script_id)
{
if (sCreatureMovementScripts.find(node.script_id) == sCreatureMovementScripts.end())
{
sLog.outErrorDb("Table creature_movement_template for entry %u, point %u have script_id %u that does not exist in `creature_movement_scripts`, ignoring", entry, point, node.script_id);
continue;
}
movementScriptSet.erase(node.script_id);
}
WaypointBehavior be;
be.model1 = fields[15].GetUInt32();
be.model2 = fields[16].GetUInt32();
be.emote = fields[12].GetUInt32();
be.spell = fields[13].GetUInt32();
for(int i = 0; i < MAX_WAYPOINT_TEXT; ++i)
{
be.textid[i] = fields[7+i].GetUInt32();
if (be.textid[i])
{
if (be.textid[i] < MIN_DB_SCRIPT_STRING_ID || be.textid[i] >= MAX_DB_SCRIPT_STRING_ID)
{
sLog.outErrorDb( "Table `db_script_string` not have string id %u", be.textid[i]);
continue;
}
}
}
if (be.spell && ! sSpellStore.LookupEntry(be.spell))
{
sLog.outErrorDb("Table creature_movement_template references unknown spellid %u. Skipping id %u with point %u.", be.spell, entry, point);
be.spell = 0;
}
if (be.emote)
{
if (!sEmotesStore.LookupEntry(be.emote))
sLog.outErrorDb("Waypoint template path %u (point %u) are using emote %u, but emote does not exist.", entry, point, be.emote);
}
// save memory by not storing empty behaviors
if (!be.isEmpty())
{
node.behavior = new WaypointBehavior(be);
++total_behaviors;
}
else
node.behavior = NULL;
}
while(result->NextRow());
delete result;
sLog.outString();
sLog.outString( ">> Waypoint templates loaded" );
sLog.outString();
sLog.outString( ">>> Loaded %u path templates with %u nodes and %u behaviors", total_paths, total_nodes, total_behaviors);
}
if (!movementScriptSet.empty())
{
for(std::set<uint32>::const_iterator itr = movementScriptSet.begin(); itr != movementScriptSet.end(); ++itr)
sLog.outErrorDb("Table `creature_movement_scripts` contain unused script, id %u.", *itr);
}
}
void SystemMgr::LoadScriptWaypoints()
{
// Drop Existing Waypoint list
m_mPointMoveMap.clear();
uint64 uiCreatureCount = 0;
// Load Waypoints
QueryResult* pResult = SD2Database.PQuery("SELECT COUNT(entry) FROM script_waypoint GROUP BY entry");
if (pResult)
{
uiCreatureCount = pResult->GetRowCount();
delete pResult;
}
outstring_log("SD2: Loading Script Waypoints for " UI64FMTD " creature(s)...", uiCreatureCount);
pResult = SD2Database.PQuery("SELECT entry, pointid, location_x, location_y, location_z, waittime FROM script_waypoint ORDER BY pointid");
if (pResult)
{
BarGoLink bar(pResult->GetRowCount());
uint32 uiNodeCount = 0;
do
{
bar.step();
Field* pFields = pResult->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();
CreatureInfo const* pCInfo = GetCreatureTemplateStore(pTemp.uiCreatureEntry);
if (!pCInfo)
{
error_db_log("SD2: DB table script_waypoint has waypoint for nonexistent creature entry %u", pTemp.uiCreatureEntry);
continue;
}
if (!pCInfo->ScriptID)
error_db_log("SD2: 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 (pResult->NextRow());
delete pResult;
// outstring_log("");
outstring_log(">> Loaded %u Script Waypoint nodes.", uiNodeCount);
}
else
{
BarGoLink bar(1);
bar.step();
// outstring_log("");
outstring_log(">> Loaded 0 Script Waypoints. DB table `script_waypoint` is empty.");
}
}
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;
}
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::HandleOfferPetitionOpcode(WorldPacket& recv_data)
{
DEBUG_LOG("Received opcode CMSG_OFFER_PETITION"); // ok
// recv_data.hexlike();
ObjectGuid petitionGuid;
ObjectGuid playerGuid;
uint32 junk;
recv_data >> junk; // this is not petition type!
recv_data >> petitionGuid; // petition guid
recv_data >> playerGuid; // player guid
Player* player = ObjectAccessor::FindPlayer(playerGuid);
if (!player)
return;
/// Get petition type and check
QueryResult* result = CharacterDatabase.PQuery("SELECT type FROM petition WHERE petitionguid = '%u'", petitionGuid.GetCounter());
if (!result)
return;
Field* fields = result->Fetch();
uint32 type = fields[0].GetUInt32();
delete result;
DEBUG_LOG("OFFER PETITION: type %u petition %s to %s", type, petitionGuid.GetString().c_str(), playerGuid.GetString().c_str());
if (!sWorld.getConfig(CONFIG_BOOL_ALLOW_TWO_SIDE_INTERACTION_GUILD) && GetPlayer()->GetTeam() != player->GetTeam())
{
if (type != 9)
SendArenaTeamCommandResult(ERR_ARENA_TEAM_INVITE_SS, "", "", ERR_ARENA_TEAM_NOT_ALLIED);
else
SendGuildCommandResult(GUILD_CREATE_S, "", ERR_GUILD_NOT_ALLIED);
return;
}
if (type != 9)
{
if (player->getLevel() < sWorld.getConfig(CONFIG_UINT32_MAX_PLAYER_LEVEL))
{
// player is too low level to join an arena team
SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, "", player->GetName(), ERR_ARENA_TEAM_TARGET_TOO_LOW_S);
return;
}
if (!IsArenaTypeValid(ArenaType(type)))
return;
uint8 slot = ArenaTeam::GetSlotByType(ArenaType(type));
if (slot >= MAX_ARENA_SLOT)
return;
if (player->GetArenaTeamId(slot))
{
// player is already in an arena team
SendArenaTeamCommandResult(ERR_ARENA_TEAM_CREATE_S, "", player->GetName(), ERR_ALREADY_IN_ARENA_TEAM_S);
return;
}
if (player->GetArenaTeamIdInvited())
{
SendArenaTeamCommandResult(ERR_ARENA_TEAM_INVITE_SS, "", _player->GetName(), ERR_ALREADY_INVITED_TO_ARENA_TEAM_S);
return;
}
}
else
{
if (player->GetGuildId())
{
SendGuildCommandResult(GUILD_INVITE_S, _player->GetName(), ERR_ALREADY_IN_GUILD_S);
return;
}
if (player->GetGuildIdInvited())
{
SendGuildCommandResult(GUILD_INVITE_S, _player->GetName(), ERR_ALREADY_INVITED_TO_GUILD_S);
return;
}
}
/// Get petition signs count
uint8 signs = 0;
result = CharacterDatabase.PQuery("SELECT playerguid FROM petition_sign WHERE petitionguid = '%u'", petitionGuid.GetCounter());
// result==nullptr also correct charter without signs
if (result)
signs = (uint8)result->GetRowCount();
/// Send response
WorldPacket data(SMSG_PETITION_SHOW_SIGNATURES, (8 + 8 + 4 + signs + signs * 12));
data << ObjectGuid(petitionGuid); // petition guid
data << ObjectGuid(_player->GetObjectGuid()); // owner guid
data << uint32(petitionGuid.GetCounter()); // guild guid (in mangos always same as low part of petition guid)
data << uint8(signs); // sign's count
for (uint8 i = 1; i <= signs; ++i)
{
Field* fields2 = result->Fetch();
ObjectGuid signerGuid = ObjectGuid(HIGHGUID_PLAYER, fields2[0].GetUInt32());
data << ObjectGuid(signerGuid); // Player GUID
data << uint32(0); // there 0 ...
result->NextRow();
}
delete result;
player->GetSession()->SendPacket(data);
}
void WorldSession::HandleCharCreateOpcode( WorldPacket & recv_data )
{
std::string name;
WorldPacket data;
uint8 race_;
recv_data >> name;
recv_data >> race_;
recv_data.rpos(0);
QueryResult *result = sDatabase.PQuery("SELECT `guid` FROM `character` WHERE `name` = '%s'", name.c_str());
if ( result )
{
delete result;
data.Initialize(SMSG_CHAR_CREATE);
data << (uint8)0x31;
SendPacket( &data );
return;
}
result = sDatabase.PQuery("SELECT `guid` FROM `character` WHERE `account` = '%u'", GetAccountId());
if ( result )
{
if (result->GetRowCount() >= 10)
{
data.Initialize(SMSG_CHAR_CREATE);
data << (uint8)0x2F;
SendPacket( &data );
delete result;
return;
}
delete result;
}
uint32 GameType = sWorld.getConfig(CONFIG_GAME_TYPE);
bool AllowTwoSideAccounts = sWorld.getConfig(CONFIG_ALLOW_TWO_SIDE_ACCOUNTS);
if(GameType == 1 || GameType == 8)
{
QueryResult *result2 = sDatabase.PQuery("SELECT `race` FROM `character` WHERE `account` = '%u' LIMIT 1", GetAccountId());
if(result2)
{
Field * field = result2->Fetch();
uint8 race = field[0].GetUInt32();
delete result2;
uint32 team=0;
if(race > 0)
{
switch(race)
{
case HUMAN:
team = (uint32)ALLIANCE;
break;
case DWARF:
team = (uint32)ALLIANCE;
break;
case NIGHTELF:
team = (uint32)ALLIANCE;
break;
case GNOME:
team = (uint32)ALLIANCE;
break;
case ORC:
team = (uint32)HORDE;
break;
case UNDEAD_PLAYER:
team = (uint32)HORDE;
break;
case TAUREN:
team = (uint32)HORDE;
break;
case TROLL:
team = (uint32)HORDE;
break;
}
}
uint32 team_=0;
if(race_ > 0)
{
switch(race_)
{
case HUMAN:
team_ = (uint32)ALLIANCE;
break;
case DWARF:
team_ = (uint32)ALLIANCE;
break;
case NIGHTELF:
team_ = (uint32)ALLIANCE;
break;
case GNOME:
team_ = (uint32)ALLIANCE;
break;
case ORC:
team_ = (uint32)HORDE;
break;
case UNDEAD_PLAYER:
team_ = (uint32)HORDE;
break;
case TAUREN:
team_ = (uint32)HORDE;
break;
case TROLL:
team_ = (uint32)HORDE;
break;
}
}
if(team != team_ && GetSecurity() < 2 && !AllowTwoSideAccounts)
{
data.Initialize( SMSG_CHAR_CREATE );
data << (uint8)0x33;
SendPacket( &data );
return;
}
}
}
Player * pNewChar = new Player(this);
if(pNewChar->Create( objmgr.GenerateLowGuid(HIGHGUID_PLAYER), recv_data ))
{
// Player create
pNewChar->SaveToDB();
QueryResult *resultCount = sDatabase.PQuery("SELECT COUNT(guid) FROM `character` WHERE `account` = '%d'", GetAccountId());
uint32 charCount = 0;
if (resultCount)
{
Field *fields = resultCount->Fetch();
charCount = fields[0].GetUInt32();
delete resultCount;
loginDatabase.PExecute("INSERT INTO `realmcharacters` (`numchars`, `acctid`, `realmid`) VALUES (%d, %d, %d) ON DUPLICATE KEY UPDATE `numchars` = '%d'", charCount, GetAccountId(), realmID, charCount);
}
delete pNewChar;
}
else
{
// Player not create (race/class problem?)
delete pNewChar;
data.Initialize(SMSG_CHAR_CREATE);
data << (uint8)0x2F;
SendPacket( &data );
return;
}
// we have successfull creation
// note all error codes moved + 1
// 0x2E - Character created
// 0x30 - Char create failed
// 0x31 - Char name is in use
// 0x35 - Char delete Okay
// 0x36 - Char delete failed
data.Initialize( SMSG_CHAR_CREATE );
data << (uint8)0x2E;
SendPacket( &data );
}
// -------------------
void CreatureEventAIMgr::LoadCreatureEventAI_Scripts()
{
// Drop Existing EventAI List
m_CreatureEventAI_Event_Map.clear();
// Gather event data
QueryResult* result = WorldDatabase.Query("SELECT id, creature_id, event_type, event_inverse_phase_mask, event_chance, event_flags, "
"event_param1, event_param2, event_param3, event_param4, "
"action1_type, action1_param1, action1_param2, action1_param3, "
"action2_type, action2_param1, action2_param2, action2_param3, "
"action3_type, action3_param1, action3_param2, action3_param3 "
"FROM creature_ai_scripts");
if (result)
{
BarGoLink bar(result->GetRowCount());
uint32 Count = 0;
do
{
bar.step();
Field* fields = result->Fetch();
CreatureEventAI_Event temp;
temp.event_id = EventAI_Type(fields[0].GetUInt32());
uint32 i = temp.event_id;
temp.creature_id = fields[1].GetUInt32();
uint32 creature_id = temp.creature_id;
uint32 e_type = fields[2].GetUInt32();
// Report any errors in event
if (e_type >= EVENT_T_END)
{
sLog.outErrorEventAI("Event %u have wrong type (%u), skipping.", i, e_type);
continue;
}
temp.event_type = EventAI_Type(e_type);
temp.event_inverse_phase_mask = fields[3].GetUInt32();
temp.event_chance = fields[4].GetUInt8();
temp.event_flags = fields[5].GetUInt8();
temp.raw.param1 = fields[6].GetUInt32();
temp.raw.param2 = fields[7].GetUInt32();
temp.raw.param3 = fields[8].GetUInt32();
temp.raw.param4 = fields[9].GetUInt32();
// Creature does not exist in database
if (!sCreatureStorage.LookupEntry<CreatureInfo>(temp.creature_id))
{
sLog.outErrorEventAI("Event %u has script for non-existing creature entry (%u), skipping.", i, temp.creature_id);
continue;
}
// No chance of this event occuring
if (temp.event_chance == 0)
sLog.outErrorEventAI("Event %u has 0 percent chance. Event will never trigger!", i);
// Chance above 100, force it to be 100
else if (temp.event_chance > 100)
{
sLog.outErrorEventAI("Creature %u are using event %u with more than 100 percent chance. Adjusting to 100 percent.", temp.creature_id, i);
temp.event_chance = 100;
}
// Individual event checks
switch (temp.event_type)
{
case EVENT_T_TIMER_IN_COMBAT:
case EVENT_T_TIMER_OOC:
case EVENT_T_TIMER_GENERIC:
if (temp.timer.initialMax < temp.timer.initialMin)
sLog.outErrorEventAI("Creature %u are using timed event(%u) with param2 < param1 (InitialMax < InitialMin). Event will never repeat.", temp.creature_id, i);
if (temp.timer.repeatMax < temp.timer.repeatMin)
sLog.outErrorEventAI("Creature %u are using repeatable event(%u) with param4 < param3 (RepeatMax < RepeatMin). Event will never repeat.", temp.creature_id, i);
break;
case EVENT_T_HP:
case EVENT_T_MANA:
case EVENT_T_TARGET_HP:
case EVENT_T_TARGET_MANA:
if (temp.percent_range.percentMax > 100)
sLog.outErrorEventAI("Creature %u are using percentage event(%u) with param2 (MinPercent) > 100. Event will never trigger! ", temp.creature_id, i);
if (temp.percent_range.percentMax <= temp.percent_range.percentMin)
sLog.outErrorEventAI("Creature %u are using percentage event(%u) with param1 <= param2 (MaxPercent <= MinPercent). Event will never trigger! ", temp.creature_id, i);
if ((temp.event_flags & EFLAG_REPEATABLE) && !temp.percent_range.repeatMin && !temp.percent_range.repeatMax)
{
sLog.outErrorEventAI("Creature %u has param3 and param4=0 (RepeatMin/RepeatMax) but cannot be repeatable without timers. Removing EFLAG_REPEATABLE for event %u.", temp.creature_id, i);
temp.event_flags &= ~EFLAG_REPEATABLE;
}
break;
case EVENT_T_SPELLHIT:
if (temp.spell_hit.spellId)
{
SpellEntry const* pSpell = sSpellStore.LookupEntry(temp.spell_hit.spellId);
if (!pSpell)
{
sLog.outErrorEventAI("Creature %u has nonexistent SpellID(%u) defined in event %u.", temp.creature_id, temp.spell_hit.spellId, i);
continue;
}
if ((temp.spell_hit.schoolMask & pSpell->SchoolMask) != pSpell->SchoolMask)
sLog.outErrorEventAI("Creature %u has param1(spellId %u) but param2 is not -1 and not equal to spell's school mask. Event %u can never trigger.", temp.creature_id, temp.spell_hit.schoolMask, i);
}
if (!temp.spell_hit.schoolMask)
sLog.outErrorEventAI("Creature %u is using invalid SpellSchoolMask(%u) defined in event %u.", temp.creature_id, temp.spell_hit.schoolMask, i);
if (temp.spell_hit.repeatMax < temp.spell_hit.repeatMin)
sLog.outErrorEventAI("Creature %u are using repeatable event(%u) with param4 < param3 (RepeatMax < RepeatMin). Event will never repeat.", temp.creature_id, i);
break;
case EVENT_T_RANGE:
if (temp.range.maxDist < temp.range.minDist)
sLog.outErrorEventAI("Creature %u are using event(%u) with param2 < param1 (MaxDist < MinDist). Event will never repeat.", temp.creature_id, i);
if (temp.range.repeatMax < temp.range.repeatMin)
sLog.outErrorEventAI("Creature %u are using repeatable event(%u) with param4 < param3 (RepeatMax < RepeatMin). Event will never repeat.", temp.creature_id, i);
break;
case EVENT_T_OOC_LOS:
if (temp.ooc_los.repeatMax < temp.ooc_los.repeatMin)
sLog.outErrorEventAI("Creature %u are using repeatable event(%u) with param4 < param3 (RepeatMax < RepeatMin). Event will never repeat.", temp.creature_id, i);
break;
case EVENT_T_SPAWNED:
switch (temp.spawned.condition)
{
case SPAWNED_EVENT_ALWAY:
break;
case SPAWNED_EVENT_MAP:
if (!sMapStore.LookupEntry(temp.spawned.conditionValue1))
sLog.outErrorEventAI("Creature %u are using spawned event(%u) with param1 = %u 'map specific' but map (param2: %u) does not exist. Event will never repeat.", temp.creature_id, i, temp.spawned.condition, temp.spawned.conditionValue1);
break;
case SPAWNED_EVENT_ZONE:
if (!GetAreaEntryByAreaID(temp.spawned.conditionValue1))
sLog.outErrorEventAI("Creature %u are using spawned event(%u) with param1 = %u 'area specific' but area (param2: %u) does not exist. Event will never repeat.", temp.creature_id, i, temp.spawned.condition, temp.spawned.conditionValue1);
break;
default:
sLog.outErrorEventAI("Creature %u are using invalid spawned event %u mode (%u) in param1", temp.creature_id, i, temp.spawned.condition);
break;
}
break;
case EVENT_T_FRIENDLY_HP:
if (temp.friendly_hp.repeatMax < temp.friendly_hp.repeatMin)
sLog.outErrorEventAI("Creature %u are using repeatable event(%u) with param4 < param3 (RepeatMax < RepeatMin). Event will never repeat.", temp.creature_id, i);
break;
case EVENT_T_FRIENDLY_IS_CC:
if (temp.friendly_is_cc.repeatMax < temp.friendly_is_cc.repeatMin)
sLog.outErrorEventAI("Creature %u are using repeatable event(%u) with param4 < param3 (RepeatMax < RepeatMin). Event will never repeat.", temp.creature_id, i);
break;
case EVENT_T_FRIENDLY_MISSING_BUFF:
{
SpellEntry const* pSpell = sSpellStore.LookupEntry(temp.friendly_buff.spellId);
if (!pSpell)
{
sLog.outErrorEventAI("Creature %u has nonexistent SpellID(%u) defined in event %u.", temp.creature_id, temp.friendly_buff.spellId, i);
continue;
}
if (temp.friendly_buff.radius <= 0)
{
sLog.outErrorEventAI("Creature %u has wrong radius (%u) for EVENT_T_FRIENDLY_MISSING_BUFF defined in event %u.", temp.creature_id, temp.friendly_buff.radius, i);
continue;
}
if (temp.friendly_buff.repeatMax < temp.friendly_buff.repeatMin)
sLog.outErrorEventAI("Creature %u are using repeatable event(%u) with param4 < param3 (RepeatMax < RepeatMin). Event will never repeat.", temp.creature_id, i);
break;
}
case EVENT_T_KILL:
if (temp.kill.repeatMax < temp.kill.repeatMin)
sLog.outErrorEventAI("Creature %u are using event(%u) with param2 < param1 (RepeatMax < RepeatMin). Event will never repeat.", temp.creature_id, i);
break;
case EVENT_T_TARGET_CASTING:
if (temp.target_casting.repeatMax < temp.target_casting.repeatMin)
sLog.outErrorEventAI("Creature %u are using event(%u) with param2 < param1 (RepeatMax < RepeatMin). Event will never repeat.", temp.creature_id, i);
break;
case EVENT_T_SUMMONED_UNIT:
case EVENT_T_SUMMONED_JUST_DIED:
case EVENT_T_SUMMONED_JUST_DESPAWN:
if (!sCreatureStorage.LookupEntry<CreatureInfo>(temp.summoned.creatureId))
sLog.outErrorEventAI("Creature %u are using event(%u) with nonexistent creature template id (%u) in param1, skipped.", temp.creature_id, i, temp.summoned.creatureId);
if (temp.summoned.repeatMax < temp.summoned.repeatMin)
sLog.outErrorEventAI("Creature %u are using event(%u) with param2 < param1 (RepeatMax < RepeatMin). Event will never repeat.", temp.creature_id, i);
break;
case EVENT_T_QUEST_ACCEPT:
case EVENT_T_QUEST_COMPLETE:
if (!sObjectMgr.GetQuestTemplate(temp.quest.questId))
sLog.outErrorEventAI("Creature %u are using event(%u) with nonexistent quest id (%u) in param1, skipped.", temp.creature_id, i, temp.quest.questId);
sLog.outErrorEventAI("Creature %u using not implemented event (%u) in event %u.", temp.creature_id, temp.event_id, i);
continue;
case EVENT_T_AGGRO:
case EVENT_T_DEATH:
case EVENT_T_EVADE:
case EVENT_T_REACHED_HOME:
{
if (temp.event_flags & EFLAG_REPEATABLE)
{
sLog.outErrorEventAI("Creature %u has EFLAG_REPEATABLE set. Event can never be repeatable. Removing flag for event %u.", temp.creature_id, i);
temp.event_flags &= ~EFLAG_REPEATABLE;
}
break;
}
case EVENT_T_RECEIVE_EMOTE:
{
if (!sEmotesTextStore.LookupEntry(temp.receive_emote.emoteId))
{
sLog.outErrorEventAI("Creature %u using event %u: param1 (EmoteTextId: %u) are not valid.", temp.creature_id, i, temp.receive_emote.emoteId);
continue;
}
if (!PlayerCondition::IsValid(0, ConditionType(temp.receive_emote.condition), temp.receive_emote.conditionValue1, temp.receive_emote.conditionValue2))
{
sLog.outErrorEventAI("Creature %u using event %u: param2 (Condition: %u) are not valid.", temp.creature_id, i, temp.receive_emote.condition);
continue;
}
if (!(temp.event_flags & EFLAG_REPEATABLE))
{
sLog.outErrorEventAI("Creature %u using event %u: EFLAG_REPEATABLE not set. Event must always be repeatable. Flag applied.", temp.creature_id, i);
temp.event_flags |= EFLAG_REPEATABLE;
}
break;
}
case EVENT_T_AURA:
case EVENT_T_TARGET_AURA:
case EVENT_T_MISSING_AURA:
case EVENT_T_TARGET_MISSING_AURA:
{
SpellEntry const* pSpell = sSpellStore.LookupEntry(temp.buffed.spellId);
if (!pSpell)
{
sLog.outErrorEventAI("Creature %u has nonexistent SpellID(%u) defined in event %u.", temp.creature_id, temp.buffed.spellId, i);
continue;
}
if (temp.buffed.amount < 1)
{
sLog.outErrorEventAI("Creature %u has wrong spell stack size (%u) defined in event %u.", temp.creature_id, temp.buffed.amount, i);
continue;
}
if (temp.buffed.repeatMax < temp.buffed.repeatMin)
sLog.outErrorEventAI("Creature %u are using repeatable event(%u) with param4 < param3 (RepeatMax < RepeatMin). Event will never repeat.", temp.creature_id, i);
break;
}
default:
sLog.outErrorEventAI("Creature %u using not checked at load event (%u) in event %u. Need check code update?", temp.creature_id, temp.event_id, i);
break;
}
for (uint32 j = 0; j < MAX_ACTIONS; ++j)
{
uint16 action_type = fields[10 + (j * 4)].GetUInt16();
if (action_type >= ACTION_T_END)
{
sLog.outErrorEventAI("Event %u Action %u has incorrect action type (%u), replace by ACTION_T_NONE.", i, j + 1, action_type);
temp.action[j].type = ACTION_T_NONE;
continue;
}
CreatureEventAI_Action& action = temp.action[j];
action.type = EventAI_ActionType(action_type);
action.raw.param1 = fields[11 + (j * 4)].GetUInt32();
action.raw.param2 = fields[12 + (j * 4)].GetUInt32();
action.raw.param3 = fields[13 + (j * 4)].GetUInt32();
// Report any errors in actions
switch (action.type)
{
case ACTION_T_NONE:
break;
case ACTION_T_CHANCED_TEXT:
// Check first param as chance
if (!action.chanced_text.chance)
sLog.outErrorEventAI("Event %u Action %u has not set chance param1. Text will not be displayed", i, j + 1);
else if (action.chanced_text.chance >= 100)
sLog.outErrorEventAI("Event %u Action %u has set chance param1 >= 100. Text will always be displayed", i, j + 1);
// no break here to check texts
case ACTION_T_TEXT:
{
bool not_set = false;
int firstTextParam = action.type == ACTION_T_TEXT ? 0 : 1;
for (int k = firstTextParam; k < 3; ++k)
{
if (action.text.TextId[k])
{
if (k > firstTextParam && not_set)
sLog.outErrorEventAI("Event %u Action %u has param%d, but it follow after not set param. Required for randomized text.", i, j + 1, k + 1);
if (!action.text.TextId[k])
not_set = true;
// range negative
else if (action.text.TextId[k] > MIN_CREATURE_AI_TEXT_STRING_ID || action.text.TextId[k] <= MAX_CREATURE_AI_TEXT_STRING_ID)
{
sLog.outErrorEventAI("Event %u Action %u param%d references out-of-range entry (%i) in texts table.", i, j + 1, k + 1, action.text.TextId[k]);
action.text.TextId[k] = 0;
}
else if (m_CreatureEventAI_TextMap.find(action.text.TextId[k]) == m_CreatureEventAI_TextMap.end())
{
sLog.outErrorEventAI("Event %u Action %u param%d references non-existing entry (%i) in texts table.", i, j + 1, k + 1, action.text.TextId[k]);
action.text.TextId[k] = 0;
}
}
}
break;
}
case ACTION_T_SET_FACTION:
if (action.set_faction.factionId != 0 && !sFactionTemplateStore.LookupEntry(action.set_faction.factionId))
{
sLog.outErrorEventAI("Event %u Action %u uses nonexistent FactionId %u.", i, j + 1, action.set_faction.factionId);
action.set_faction.factionId = 0;
}
break;
case ACTION_T_MORPH_TO_ENTRY_OR_MODEL:
if (action.morph.creatureId != 0 || action.morph.modelId != 0)
{
if (action.morph.creatureId && !sCreatureStorage.LookupEntry<CreatureInfo>(action.morph.creatureId))
{
sLog.outErrorEventAI("Event %u Action %u uses nonexistent Creature entry %u.", i, j + 1, action.morph.creatureId);
action.morph.creatureId = 0;
}
if (action.morph.modelId)
{
if (action.morph.creatureId)
{
sLog.outErrorEventAI("Event %u Action %u have unused ModelId %u with also set creature id %u.", i, j + 1, action.morph.modelId, action.morph.creatureId);
action.morph.modelId = 0;
}
else if (!sCreatureDisplayInfoStore.LookupEntry(action.morph.modelId))
{
sLog.outErrorEventAI("Event %u Action %u uses nonexistent ModelId %u.", i, j + 1, action.morph.modelId);
action.morph.modelId = 0;
}
}
}
break;
case ACTION_T_SOUND:
if (!sSoundEntriesStore.LookupEntry(action.sound.soundId))
sLog.outErrorEventAI("Event %u Action %u uses nonexistent SoundID %u.", i, j + 1, action.sound.soundId);
break;
case ACTION_T_EMOTE:
if (!sEmotesStore.LookupEntry(action.emote.emoteId))
sLog.outErrorEventAI("Event %u Action %u param1 (EmoteId: %u) are not valid.", i, j + 1, action.emote.emoteId);
break;
case ACTION_T_RANDOM_SOUND:
if (!sSoundEntriesStore.LookupEntry(action.random_sound.soundId1))
sLog.outErrorEventAI("Event %u Action %u param1 uses nonexistent SoundID %u.", i, j + 1, action.random_sound.soundId1);
if (action.random_sound.soundId2 >= 0 && !sSoundEntriesStore.LookupEntry(action.random_sound.soundId2))
sLog.outErrorEventAI("Event %u Action %u param2 uses nonexistent SoundID %u.", i, j + 1, action.random_sound.soundId2);
if (action.random_sound.soundId3 >= 0 && !sSoundEntriesStore.LookupEntry(action.random_sound.soundId3))
sLog.outErrorEventAI("Event %u Action %u param3 uses nonexistent SoundID %u.", i, j + 1, action.random_sound.soundId3);
break;
case ACTION_T_RANDOM_EMOTE:
if (!sEmotesStore.LookupEntry(action.random_emote.emoteId1))
sLog.outErrorEventAI("Event %u Action %u param1 (EmoteId: %u) are not valid.", i, j + 1, action.random_emote.emoteId1);
if (action.random_emote.emoteId2 >= 0 && !sEmotesStore.LookupEntry(action.random_emote.emoteId2))
sLog.outErrorEventAI("Event %u Action %u param2 (EmoteId: %u) are not valid.", i, j + 1, action.random_emote.emoteId2);
if (action.random_emote.emoteId3 >= 0 && !sEmotesStore.LookupEntry(action.random_emote.emoteId3))
sLog.outErrorEventAI("Event %u Action %u param3 (EmoteId: %u) are not valid.", i, j + 1, action.random_emote.emoteId3);
break;
case ACTION_T_CAST:
{
const SpellEntry* spell = sSpellStore.LookupEntry(action.cast.spellId);
if (!spell)
sLog.outErrorEventAI("Event %u Action %u uses nonexistent SpellID %u.", i, j + 1, action.cast.spellId);
/* FIXME: temp.raw.param3 not have event tipes with recovery time in it....
else
{
if (spell->RecoveryTime > 0 && temp.event_flags & EFLAG_REPEATABLE)
{
// output as debug for now, also because there's no general rule all spells have RecoveryTime
if (temp.event_param3 < spell->RecoveryTime)
DEBUG_FILTER_LOG(LOG_FILTER_AI_AND_MOVEGENSS, "CreatureEventAI: Event %u Action %u uses SpellID %u but cooldown is longer(%u) than minumum defined in event param3(%u).", i, j+1,action.cast.spellId, spell->RecoveryTime, temp.event_param3);
}
}
*/
// Cast is always triggered if target is forced to cast on self
if (action.cast.castFlags & CAST_FORCE_TARGET_SELF)
action.cast.castFlags |= CAST_TRIGGERED;
if (action.cast.target >= TARGET_T_END)
sLog.outErrorEventAI("Event %u Action %u uses incorrect Target type", i, j + 1);
// Some Advanced target type checks - Can have false positives
if (!sLog.HasLogFilter(LOG_FILTER_EVENT_AI_DEV) && spell)
{
// used TARGET_T_ACTION_INVOKER, but likely should be _INVOKER_OWNER instead
if (action.cast.target == TARGET_T_ACTION_INVOKER &&
(IsSpellHaveEffect(spell, SPELL_EFFECT_QUEST_COMPLETE) || IsSpellHaveEffect(spell, SPELL_EFFECT_CREATE_RANDOM_ITEM) || IsSpellHaveEffect(spell, SPELL_EFFECT_DUMMY)
|| IsSpellHaveEffect(spell, SPELL_EFFECT_KILL_CREDIT_PERSONAL) || IsSpellHaveEffect(spell, SPELL_EFFECT_KILL_CREDIT_GROUP)))
sLog.outErrorEventAI("Event %u Action %u has TARGET_T_ACTION_INVOKER(%u) target type, but should have TARGET_T_ACTION_INVOKER_OWNER(%u).", i, j + 1, TARGET_T_ACTION_INVOKER, TARGET_T_ACTION_INVOKER_OWNER);
// Spell that should only target players, but could get any
if (spell->HasAttribute(SPELL_ATTR_EX3_TARGET_ONLY_PLAYER) &&
(action.cast.target == TARGET_T_ACTION_INVOKER || action.cast.target == TARGET_T_HOSTILE_RANDOM || action.cast.target == TARGET_T_HOSTILE_RANDOM_NOT_TOP))
sLog.outErrorEventAI("Event %u Action %u uses Target type %u for a spell (%u) that should only target players. This could be wrong.", i, j + 1, action.cast.target, action.cast.spellId);
}
break;
}
case ACTION_T_SUMMON:
if (!sCreatureStorage.LookupEntry<CreatureInfo>(action.summon.creatureId))
sLog.outErrorEventAI("Event %u Action %u uses nonexistent creature entry %u.", i, j + 1, action.summon.creatureId);
if (action.summon.target >= TARGET_T_END)
sLog.outErrorEventAI("Event %u Action %u uses incorrect Target type", i, j + 1);
break;
case ACTION_T_THREAT_SINGLE_PCT:
if (std::abs(action.threat_single_pct.percent) > 100)
sLog.outErrorEventAI("Event %u Action %u uses invalid percent value %u.", i, j + 1, action.threat_single_pct.percent);
if (action.threat_single_pct.target >= TARGET_T_END)
sLog.outErrorEventAI("Event %u Action %u uses incorrect Target type", i, j + 1);
break;
case ACTION_T_THREAT_ALL_PCT:
if (std::abs(action.threat_all_pct.percent) > 100)
sLog.outErrorEventAI("Event %u Action %u uses invalid percent value %u.", i, j + 1, action.threat_all_pct.percent);
break;
case ACTION_T_QUEST_EVENT:
if (Quest const* qid = sObjectMgr.GetQuestTemplate(action.quest_event.questId))
{
if (!qid->HasSpecialFlag(QUEST_SPECIAL_FLAG_EXPLORATION_OR_EVENT))
sLog.outErrorEventAI("Event %u Action %u. SpecialFlags for quest entry %u does not include |2, Action will not have any effect.", i, j + 1, action.quest_event.questId);
}
else
sLog.outErrorEventAI("Event %u Action %u uses nonexistent Quest entry %u.", i, j + 1, action.quest_event.questId);
if (action.quest_event.target >= TARGET_T_END)
sLog.outErrorEventAI("Event %u Action %u uses incorrect Target type", i, j + 1);
break;
case ACTION_T_CAST_EVENT:
if (!sCreatureStorage.LookupEntry<CreatureInfo>(action.cast_event.creatureId))
sLog.outErrorEventAI("Event %u Action %u uses nonexistent creature entry %u.", i, j + 1, action.cast_event.creatureId);
if (!sSpellStore.LookupEntry(action.cast_event.spellId))
sLog.outErrorEventAI("Event %u Action %u uses nonexistent SpellID %u.", i, j + 1, action.cast_event.spellId);
if (action.cast_event.target >= TARGET_T_END)
sLog.outErrorEventAI("Event %u Action %u uses incorrect Target type", i, j + 1);
break;
case ACTION_T_SET_UNIT_FIELD:
if (action.set_unit_field.field < OBJECT_END || action.set_unit_field.field >= UNIT_END)
sLog.outErrorEventAI("Event %u Action %u param1 (UNIT_FIELD*). Index out of range for intended use.", i, j + 1);
if (action.set_unit_field.target >= TARGET_T_END)
sLog.outErrorEventAI("Event %u Action %u uses incorrect Target type", i, j + 1);
break;
case ACTION_T_SET_UNIT_FLAG:
case ACTION_T_REMOVE_UNIT_FLAG:
if (action.unit_flag.target >= TARGET_T_END)
sLog.outErrorEventAI("Event %u Action %u uses incorrect Target type", i, j + 1);
break;
case ACTION_T_SET_PHASE:
if (action.set_phase.phase >= MAX_PHASE)
sLog.outErrorEventAI("Event %u Action %u attempts to set phase >= %u. Phase mask cannot be used past phase %u.", i, j + 1, MAX_PHASE, MAX_PHASE - 1);
break;
case ACTION_T_INC_PHASE:
if (action.set_inc_phase.step == 0)
sLog.outErrorEventAI("Event %u Action %u is incrementing phase by 0. Was this intended?", i, j + 1);
else if (std::abs(action.set_inc_phase.step) > MAX_PHASE - 1)
sLog.outErrorEventAI("Event %u Action %u is change phase by too large for any use %i.", i, j + 1, action.set_inc_phase.step);
break;
case ACTION_T_QUEST_EVENT_ALL:
if (Quest const* qid = sObjectMgr.GetQuestTemplate(action.quest_event_all.questId))
{
if (!qid->HasSpecialFlag(QUEST_SPECIAL_FLAG_EXPLORATION_OR_EVENT))
sLog.outErrorEventAI("Event %u Action %u. SpecialFlags for quest entry %u does not include |2, Action will not have any effect.", i, j + 1, action.quest_event_all.questId);
}
else
sLog.outErrorEventAI("Event %u Action %u uses nonexistent Quest entry %u.", i, j + 1, action.quest_event_all.questId);
break;
case ACTION_T_CAST_EVENT_ALL:
if (!sCreatureStorage.LookupEntry<CreatureInfo>(action.cast_event_all.creatureId))
sLog.outErrorEventAI("Event %u Action %u uses nonexistent creature entry %u.", i, j + 1, action.cast_event_all.creatureId);
if (!sSpellStore.LookupEntry(action.cast_event_all.spellId))
sLog.outErrorEventAI("Event %u Action %u uses nonexistent SpellID %u.", i, j + 1, action.cast_event_all.spellId);
break;
case ACTION_T_REMOVEAURASFROMSPELL:
if (!sSpellStore.LookupEntry(action.remove_aura.spellId))
sLog.outErrorEventAI("Event %u Action %u uses nonexistent SpellID %u.", i, j + 1, action.remove_aura.spellId);
if (action.remove_aura.target >= TARGET_T_END)
sLog.outErrorEventAI("Event %u Action %u uses incorrect Target type", i, j + 1);
break;
case ACTION_T_RANDOM_PHASE: // PhaseId1, PhaseId2, PhaseId3
if (action.random_phase.phase1 >= MAX_PHASE)
sLog.outErrorEventAI("Event %u Action %u attempts to set phase1 >= %u. Phase mask cannot be used past phase %u.", i, j + 1, MAX_PHASE, MAX_PHASE - 1);
if (action.random_phase.phase2 >= MAX_PHASE)
sLog.outErrorEventAI("Event %u Action %u attempts to set phase2 >= %u. Phase mask cannot be used past phase %u.", i, j + 1, MAX_PHASE, MAX_PHASE - 1);
if (action.random_phase.phase3 >= MAX_PHASE)
sLog.outErrorEventAI("Event %u Action %u attempts to set phase3 >= %u. Phase mask cannot be used past phase %u.", i, j + 1, MAX_PHASE, MAX_PHASE - 1);
break;
case ACTION_T_RANDOM_PHASE_RANGE: // PhaseMin, PhaseMax
if (action.random_phase_range.phaseMin >= MAX_PHASE)
sLog.outErrorEventAI("Event %u Action %u attempts to set phaseMin >= %u. Phase mask cannot be used past phase %u.", i, j + 1, MAX_PHASE, MAX_PHASE - 1);
if (action.random_phase_range.phaseMin >= MAX_PHASE)
sLog.outErrorEventAI("Event %u Action %u attempts to set phaseMax >= %u. Phase mask cannot be used past phase %u.", i, j + 1, MAX_PHASE, MAX_PHASE - 1);
if (action.random_phase_range.phaseMin >= action.random_phase_range.phaseMax)
{
sLog.outErrorEventAI("Event %u Action %u attempts to set phaseMax <= phaseMin.", i, j + 1);
std::swap(action.random_phase_range.phaseMin, action.random_phase_range.phaseMax);
// equal case processed at call
}
break;
case ACTION_T_SUMMON_ID:
if (!sCreatureStorage.LookupEntry<CreatureInfo>(action.summon_id.creatureId))
sLog.outErrorEventAI("Event %u Action %u uses nonexistent creature entry %u.", i, j + 1, action.summon_id.creatureId);
if (action.summon_id.target >= TARGET_T_END)
sLog.outErrorEventAI("Event %u Action %u uses incorrect Target type", i, j + 1);
if (m_CreatureEventAI_Summon_Map.find(action.summon_id.spawnId) == m_CreatureEventAI_Summon_Map.end())
sLog.outErrorEventAI("Event %u Action %u summons missing CreatureEventAI_Summon %u", i, j + 1, action.summon_id.spawnId);
break;
case ACTION_T_KILLED_MONSTER:
if (!sCreatureStorage.LookupEntry<CreatureInfo>(action.killed_monster.creatureId))
sLog.outErrorEventAI("Event %u Action %u uses nonexistent creature entry %u.", i, j + 1, action.killed_monster.creatureId);
if (action.killed_monster.target >= TARGET_T_END)
sLog.outErrorEventAI("Event %u Action %u uses incorrect Target type", i, j + 1);
break;
case ACTION_T_SET_INST_DATA:
if (!(temp.event_flags & EFLAG_DIFFICULTY_ALL))
sLog.outErrorEventAI("Event %u Action %u. Cannot set instance data without difficulty event flags.", i, j + 1);
if (action.set_inst_data.value > 4/*SPECIAL*/)
sLog.outErrorEventAI("Event %u Action %u attempts to set instance data above encounter state 4. Custom case?", i, j + 1);
break;
case ACTION_T_SET_INST_DATA64:
if (!(temp.event_flags & EFLAG_DIFFICULTY_ALL))
sLog.outErrorEventAI("Event %u Action %u. Cannot set instance data without difficulty event flags.", i, j + 1);
if (action.set_inst_data64.target >= TARGET_T_END)
sLog.outErrorEventAI("Event %u Action %u uses incorrect Target type", i, j + 1);
break;
case ACTION_T_UPDATE_TEMPLATE:
if (!sCreatureStorage.LookupEntry<CreatureInfo>(action.update_template.creatureId))
sLog.outErrorEventAI("Event %u Action %u uses nonexistent creature entry %u.", i, j + 1, action.update_template.creatureId);
break;
case ACTION_T_SET_SHEATH:
if (action.set_sheath.sheath >= MAX_SHEATH_STATE)
{
sLog.outErrorEventAI("Event %u Action %u uses wrong sheath state %u.", i, j + 1, action.set_sheath.sheath);
action.set_sheath.sheath = SHEATH_STATE_UNARMED;
}
break;
case ACTION_T_SET_INVINCIBILITY_HP_LEVEL:
if (action.invincibility_hp_level.is_percent)
{
if (action.invincibility_hp_level.hp_level > 100)
{
sLog.outErrorEventAI("Event %u Action %u uses wrong percent value %u.", i, j + 1, action.invincibility_hp_level.hp_level);
action.invincibility_hp_level.hp_level = 100;
}
}
break;
case ACTION_T_MOUNT_TO_ENTRY_OR_MODEL:
if (action.mount.creatureId != 0 || action.mount.modelId != 0)
{
if (action.mount.creatureId && !sCreatureStorage.LookupEntry<CreatureInfo>(action.mount.creatureId))
{
sLog.outErrorEventAI("Event %u Action %u uses nonexistent Creature entry %u.", i, j + 1, action.mount.creatureId);
action.morph.creatureId = 0;
}
if (action.mount.modelId)
{
if (action.mount.creatureId)
{
sLog.outErrorEventAI("Event %u Action %u have unused ModelId %u with also set creature id %u.", i, j + 1, action.mount.modelId, action.mount.creatureId);
action.mount.modelId = 0;
}
else if (!sCreatureDisplayInfoStore.LookupEntry(action.mount.modelId))
{
sLog.outErrorEventAI("Event %u Action %u uses nonexistent ModelId %u.", i, j + 1, action.mount.modelId);
action.mount.modelId = 0;
}
}
}
break;
case ACTION_T_EVADE: // No Params
case ACTION_T_FLEE_FOR_ASSIST: // No Params
case ACTION_T_DIE: // No Params
case ACTION_T_ZONE_COMBAT_PULSE: // No Params
case ACTION_T_FORCE_DESPAWN: // Delay
case ACTION_T_AUTO_ATTACK: // AllowAttackState (0 = stop attack, anything else means continue attacking)
case ACTION_T_COMBAT_MOVEMENT: // AllowCombatMovement (0 = stop combat based movement, anything else continue attacking)
case ACTION_T_RANGED_MOVEMENT: // Distance, Angle
case ACTION_T_CALL_FOR_HELP: // Distance
break;
case ACTION_T_RANDOM_SAY:
case ACTION_T_RANDOM_YELL:
case ACTION_T_RANDOM_TEXTEMOTE:
sLog.outErrorEventAI("Event %u Action %u currently unused ACTION type. Did you forget to update database?", i, j + 1);
break;
default:
sLog.outErrorEventAI("Event %u Action %u have currently not checked at load action type (%u). Need check code update?", i, j + 1, temp.action[j].type);
break;
}
}
// Add to list
m_CreatureEventAI_Event_Map[creature_id].push_back(temp);
++Count;
}
while (result->NextRow());
delete result;
// post check
for (uint32 i = 1; i < sCreatureStorage.GetMaxEntry(); ++i)
{
if (CreatureInfo const* cInfo = sCreatureStorage.LookupEntry<CreatureInfo>(i))
{
bool ainame = strcmp(cInfo->AIName, "EventAI") == 0;
bool hasevent = m_CreatureEventAI_Event_Map.find(i) != m_CreatureEventAI_Event_Map.end();
if (ainame && !hasevent)
sLog.outErrorEventAI("EventAI not has script for creature entry (%u), but AIName = '%s'.", i, cInfo->AIName);
else if (!ainame && hasevent)
sLog.outErrorEventAI("EventAI has script for creature entry (%u), but AIName = '%s' instead 'EventAI'.", i, cInfo->AIName);
}
}
CheckUnusedAITexts();
CheckUnusedAISummons();
sLog.outString();
sLog.outString(">> Loaded %u CreatureEventAI scripts", Count);
}
else
{
BarGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded 0 CreatureEventAI scripts. DB table `creature_ai_scripts` is empty.");
}
}
void GuildMgr::LoadGuilds()
{
uint32 count = 0;
// 0 1 2 3 4 5 6
QueryResult* result = CharacterDatabase.Query("SELECT guild.guildid,guild.name,leaderguid,EmblemStyle,EmblemColor,BorderStyle,BorderColor,"
// 7 8 9 10 11 12
"BackgroundColor,info,motd,createdate,BankMoney,(SELECT COUNT(guild_bank_tab.guildid) FROM guild_bank_tab WHERE guild_bank_tab.guildid = guild.guildid) "
"FROM guild ORDER BY guildid ASC");
if (!result)
{
BarGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded %u guild definitions", count);
return;
}
// load guild ranks
// 0 1 2 3 4
QueryResult* guildRanksResult = CharacterDatabase.Query("SELECT guildid,rid,rname,rights,BankMoneyPerDay FROM guild_rank ORDER BY guildid ASC, rid ASC");
// load guild members
// 0 1 2 3 4 5 6
QueryResult* guildMembersResult = CharacterDatabase.Query("SELECT guildid,guild_member.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 23 24
"characters.name, characters.level, characters.class, characters.zone, characters.logout_time, characters.account "
"FROM guild_member LEFT JOIN characters ON characters.guid = guild_member.guid ORDER BY guildid ASC");
// load guild bank tab rights
// 0 1 2 3 4
QueryResult* guildBankTabRightsResult = CharacterDatabase.Query("SELECT guildid,TabId,rid,gbright,SlotPerDay FROM guild_bank_right ORDER BY guildid ASC, TabId ASC");
BarGoLink bar(result->GetRowCount());
do
{
// Field *fields = result->Fetch();
bar.step();
++count;
Guild* newGuild = new Guild;
if (!newGuild->LoadGuildFromDB(result) ||
!newGuild->LoadRanksFromDB(guildRanksResult) ||
!newGuild->LoadMembersFromDB(guildMembersResult) ||
!newGuild->LoadBankRightsFromDB(guildBankTabRightsResult) ||
!newGuild->CheckGuildStructure()
)
{
newGuild->Disband();
delete newGuild;
continue;
}
newGuild->LoadGuildEventLogFromDB();
newGuild->LoadGuildBankEventLogFromDB();
newGuild->LoadGuildBankFromDB();
AddGuild(newGuild);
}
while (result->NextRow());
delete result;
delete guildRanksResult;
delete guildMembersResult;
delete guildBankTabRightsResult;
// delete unused LogGuid records in guild_eventlog and guild_bank_eventlog table
// you can comment these lines if you don't plan to change CONFIG_UINT32_GUILD_EVENT_LOG_COUNT and CONFIG_UINT32_GUILD_BANK_EVENT_LOG_COUNT
CharacterDatabase.PExecute("DELETE FROM guild_eventlog WHERE LogGuid > '%u'", sWorld.getConfig(CONFIG_UINT32_GUILD_EVENT_LOG_COUNT));
CharacterDatabase.PExecute("DELETE FROM guild_bank_eventlog WHERE LogGuid > '%u'", sWorld.getConfig(CONFIG_UINT32_GUILD_BANK_EVENT_LOG_COUNT));
sLog.outString();
sLog.outString(">> Loaded %u guild definitions", count);
}
