void GameEventMgr::LoadFromDB()
{
{
QueryResult *result = WorldDatabase.Query("SELECT MAX(entry) FROM game_event");
if( !result )
{
sLog.outString(">> Table game_event is empty.");
sLog.outString();
return;
}
Field *fields = result->Fetch();
uint32 max_event_id = fields[0].GetUInt16();
delete result;
mGameEvent.resize(max_event_id+1);
}
QueryResult *result = WorldDatabase.Query("SELECT entry,UNIX_TIMESTAMP(start_time),UNIX_TIMESTAMP(end_time),occurence,length,holiday,description FROM game_event");
if( !result )
{
mGameEvent.clear();
sLog.outString(">> Table game_event is empty!");
sLog.outString();
return;
}
uint32 count = 0;
{
barGoLink bar( (int)result->GetRowCount() );
do
{
++count;
Field *fields = result->Fetch();
bar.step();
uint16 event_id = fields[0].GetUInt16();
if(event_id==0)
{
sLog.outErrorDb("`game_event` game event id (%i) is reserved and can't be used.",event_id);
continue;
}
GameEventData& pGameEvent = mGameEvent[event_id];
uint64 starttime = fields[1].GetUInt64();
pGameEvent.start = time_t(starttime);
uint64 endtime = fields[2].GetUInt64();
pGameEvent.end = time_t(endtime);
pGameEvent.occurence = fields[3].GetUInt32();
pGameEvent.length = fields[4].GetUInt32();
pGameEvent.holiday_id = HolidayIds(fields[5].GetUInt32());
if(pGameEvent.length==0) // length>0 is validity check
{
sLog.outErrorDb("`game_event` game event id (%i) have length 0 and can't be used.",event_id);
continue;
}
if(pGameEvent.holiday_id != HOLIDAY_NONE)
{
if(!sHolidaysStore.LookupEntry(pGameEvent.holiday_id))
{
sLog.outErrorDb("`game_event` game event id (%i) have nonexistent holiday id %u.",event_id,pGameEvent.holiday_id);
pGameEvent.holiday_id = HOLIDAY_NONE;
}
}
pGameEvent.description = fields[6].GetCppString();
} while( result->NextRow() );
delete result;
sLog.outString();
sLog.outString( ">> Loaded %u game events", count );
}
std::map<uint16,int16> pool2event; // for check unique spawn event associated with pool
std::map<uint32,int16> creature2event; // for check unique spawn event associated with creature
std::map<uint32,int16> go2event; // for check unique spawn event associated with gameobject
// list only positive event top pools, filled at creature/gameobject loading
mGameEventSpawnPoolIds.resize(mGameEvent.size());
mGameEventCreatureGuids.resize(mGameEvent.size()*2-1);
// 1 2
result = WorldDatabase.Query("SELECT creature.guid, game_event_creature.event "
"FROM creature JOIN game_event_creature ON creature.guid = game_event_creature.guid");
count = 0;
if( !result )
{
barGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded %u creatures in game events", count );
}
else
{
barGoLink bar( (int)result->GetRowCount() );
do
{
Field *fields = result->Fetch();
bar.step();
uint32 guid = fields[0].GetUInt32();
int16 event_id = fields[1].GetInt16();
if (event_id == 0)
{
sLog.outErrorDb("`game_event_creature` game event id (%i) not allowed",event_id);
continue;
}
int32 internal_event_id = mGameEvent.size() + event_id - 1;
if(internal_event_id < 0 || (size_t)internal_event_id >= mGameEventCreatureGuids.size())
{
sLog.outErrorDb("`game_event_creature` game event id (%i) is out of range compared to max event id in `game_event`",event_id);
continue;
}
++count;
// spawn objects at event can be grouped in pools and then affected pools have stricter requirements for this case
if (event_id > 0)
{
creature2event[guid] = event_id;
// not list explicitly creatures from pools in event creature list
if (uint16 topPoolId = sPoolMgr.IsPartOfTopPool<Creature>(guid))
{
int16& eventRef = pool2event[topPoolId];
if (eventRef != 0)
{
if (eventRef != event_id)
sLog.outErrorDb("`game_event_creature` have creature (GUID: %u) for event %i from pool or subpool of pool (ID: %u) but pool have already content from event %i. Pool don't must have content for different events!", guid, event_id, topPoolId, eventRef);
}
else
{
eventRef = event_id;
mGameEventSpawnPoolIds[event_id].push_back(topPoolId);
sPoolMgr.RemoveAutoSpawnForPool(topPoolId);
}
continue;
}
}
GuidList& crelist = mGameEventCreatureGuids[internal_event_id];
crelist.push_back(guid);
} while( result->NextRow() );
delete result;
sLog.outString();
sLog.outString( ">> Loaded %u creatures in game events", count );
}
mGameEventGameobjectGuids.resize(mGameEvent.size()*2-1);
// 1 2
result = WorldDatabase.Query("SELECT gameobject.guid, game_event_gameobject.event "
"FROM gameobject JOIN game_event_gameobject ON gameobject.guid=game_event_gameobject.guid");
count = 0;
if( !result )
{
barGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded %u gameobjects in game events", count );
}
else
{
barGoLink bar( (int)result->GetRowCount() );
do
{
Field *fields = result->Fetch();
bar.step();
uint32 guid = fields[0].GetUInt32();
int16 event_id = fields[1].GetInt16();
if (event_id == 0)
{
sLog.outErrorDb("`game_event_gameobject` game event id (%i) not allowed",event_id);
continue;
}
int32 internal_event_id = mGameEvent.size() + event_id - 1;
if(internal_event_id < 0 || (size_t)internal_event_id >= mGameEventGameobjectGuids.size())
{
sLog.outErrorDb("`game_event_gameobject` game event id (%i) is out of range compared to max event id in `game_event`",event_id);
continue;
}
++count;
// spawn objects at event can be grouped in pools and then affected pools have stricter requirements for this case
if (event_id > 0)
{
go2event[guid] = event_id;
// not list explicitly gameobjects from pools in event gameobject list
if (uint16 topPoolId = sPoolMgr.IsPartOfTopPool<GameObject>(guid))
{
int16& eventRef = pool2event[topPoolId];
if (eventRef != 0)
{
if (eventRef != event_id)
sLog.outErrorDb("`game_event_gameobject` have gameobject (GUID: %u) for event %i from pool or subpool of pool (ID: %u) but pool have already content from event %i. Pool don't must have content for different events!", guid, event_id, topPoolId, eventRef);
}
else
{
eventRef = event_id;
mGameEventSpawnPoolIds[event_id].push_back(topPoolId);
sPoolMgr.RemoveAutoSpawnForPool(topPoolId);
}
continue;
}
}
GuidList& golist = mGameEventGameobjectGuids[internal_event_id];
golist.push_back(guid);
} while( result->NextRow() );
delete result;
sLog.outString();
sLog.outString( ">> Loaded %u gameobjects in game events", count );
}
// now recheck that all eventPools linked with events after our skip pools with parents
for(std::map<uint16,int16>::const_iterator itr = pool2event.begin(); itr != pool2event.end(); ++itr)
{
uint16 pool_id = itr->first;
int16 event_id = itr->second;
sPoolMgr.CheckEventLinkAndReport(pool_id, event_id, creature2event, go2event);
}
mGameEventModelEquip.resize(mGameEvent.size());
// 0 1 2
result = WorldDatabase.Query("SELECT creature.guid, game_event_model_equip.event, game_event_model_equip.modelid,"
// 3
"game_event_model_equip.equipment_id "
"FROM creature JOIN game_event_model_equip ON creature.guid=game_event_model_equip.guid");
count = 0;
if( !result )
{
barGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded %u model/equipment changes in game events", count );
}
else
{
barGoLink bar( (int)result->GetRowCount() );
do
{
Field *fields = result->Fetch();
bar.step();
uint32 guid = fields[0].GetUInt32();
uint16 event_id = fields[1].GetUInt16();
if(event_id >= mGameEventModelEquip.size())
{
sLog.outErrorDb("`game_event_model_equip` game event id (%u) is out of range compared to max event id in `game_event`",event_id);
continue;
}
++count;
ModelEquipList& equiplist = mGameEventModelEquip[event_id];
ModelEquip newModelEquipSet;
newModelEquipSet.modelid = fields[2].GetUInt32();
newModelEquipSet.equipment_id = fields[3].GetUInt32();
newModelEquipSet.equipement_id_prev = 0;
newModelEquipSet.modelid_prev = 0;
if(newModelEquipSet.equipment_id > 0)
{
if(!sObjectMgr.GetEquipmentInfo(newModelEquipSet.equipment_id))
{
sLog.outErrorDb("Table `game_event_model_equip` have creature (Guid: %u) with equipment_id %u not found in table `creature_equip_template`, set to no equipment.", guid, newModelEquipSet.equipment_id);
continue;
}
}
equiplist.push_back(std::pair<uint32, ModelEquip>(guid, newModelEquipSet));
} while( result->NextRow() );
delete result;
sLog.outString();
sLog.outString( ">> Loaded %u model/equipment changes in game events", count );
}
mGameEventQuests.resize(mGameEvent.size());
result = WorldDatabase.Query("SELECT quest, event FROM game_event_quest");
count = 0;
if( !result )
{
barGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded %u quests additions in game events", count );
}
else
{
barGoLink bar( (int)result->GetRowCount() );
do
{
Field *fields = result->Fetch();
bar.step();
uint32 quest = fields[0].GetUInt32();
uint16 event_id = fields[1].GetUInt16();
if(event_id >= mGameEventQuests.size())
{
sLog.outErrorDb("`game_event_quest` game event id (%u) is out of range compared to max event id in `game_event`",event_id);
continue;
}
const Quest* pQuest = sObjectMgr.GetQuestTemplate(quest);
if (!pQuest)
{
sLog.outErrorDb("Table `game_event_quest` contain entry for quest %u (event %u) but this quest does not exist. Skipping.", quest, event_id);
continue;
}
// disable any event specific quest (for cases where creature is spawned, but event not active).
const_cast<Quest*>(pQuest)->SetQuestActiveState(false);
++count;
QuestList& questlist = mGameEventQuests[event_id];
questlist.push_back(quest);
} while( result->NextRow() );
delete result;
sLog.outString();
sLog.outString( ">> Loaded %u quest additions in game events", count );
}
}
void
bar1 ()
{
bar ();
}
void test1(int x) {
switch (x) {
case 111111111111111111111111111111111111111:
bar();
}
}
static void *thread_first(void *arg)
{
foo();
return bar(arg);
}
static void *thread_third(void *arg)
{
foo();
return bar(arg);
}
~D() { bar(); }
int main(int argc, char **argv){
std::string filename("");
unsigned int scale = 5, dmst = 2, window = 3, detectorType = 0, descriptorType = 0, distanceType = 2, strategy = 0;
double baseSigma = 0.2, sigmaStep = 1.4, minPeak = 0.34, minPeakDistance = 0.001, success = 0.95, inlier = 0.4, matchingThreshold = 0.4;
bool useMaxRange = false;
int i = 1;
while(i < argc){
if(strncmp("-filename", argv[i], sizeof("-filename")) == 0 ){
filename = argv[++i];
i++;
} else if(strncmp("-detector", argv[i], sizeof("-detector")) == 0 ){
detectorType = atoi(argv[++i]);
i++;
} else if(strncmp("-descriptor", argv[i], sizeof("-descriptor")) == 0 ){
descriptorType = atoi(argv[++i]);
i++;
} else if(strncmp("-corresp", argv[i], sizeof("-corresp")) == 0 ){
corresp = atoi(argv[++i]);
i++;
} else if(strncmp("-distance", argv[i], sizeof("-distance")) == 0 ){
distanceType = atoi(argv[++i]);
i++;
} else if(strncmp("-baseSigma", argv[i], sizeof("-baseSigma")) == 0 ){
baseSigma = strtod(argv[++i], NULL);
i++;
} else if(strncmp("-sigmaStep", argv[i], sizeof("-sigmaStep")) == 0 ){
sigmaStep = strtod(argv[++i], NULL);
i++;
} else if(strncmp("-minPeak", argv[i], sizeof("-minPeak")) == 0 ){
minPeak = strtod(argv[++i], NULL);
i++;
} else if(strncmp("-minPeakDistance", argv[i], sizeof("-minPeakDistance")) == 0 ){
minPeakDistance = strtod(argv[++i], NULL);
i++;
} else if(strncmp("-scale", argv[i], sizeof("-scale")) == 0 ){
scale = atoi(argv[++i]);
i++;
} else if(strncmp("-dmst", argv[i], sizeof("-dmst")) == 0 ){
dmst = atoi(argv[++i]);
i++;
} else if(strncmp("-window", argv[i], sizeof("-window")) == 0 ){
scale = atoi(argv[++i]);
i++;
} else if(strncmp("-acceptanceSigma", argv[i], sizeof("-acceptanceSigma")) == 0 ){
acceptanceSigma = strtod(argv[++i], NULL);
i++;
} else if(strncmp("-success", argv[i], sizeof("-success")) == 0 ){
success = strtod(argv[++i], NULL);
i++;
} else if(strncmp("-inlier", argv[i], sizeof("-inlier")) == 0 ){
inlier = strtod(argv[++i], NULL);
i++;
} else if(strncmp("-matchingThreshold", argv[i], sizeof("-matchingThreshold")) == 0 ){
matchingThreshold = strtod(argv[++i], NULL);
i++;
} else {
i++;
}
}
if(!filename.size()){
help();
exit(-1);
}
CarmenLogWriter writer;
CarmenLogReader reader;
m_sensorReference = LogSensorStream(&reader, &writer);
m_sensorReference.load(filename);
SimpleMinMaxPeakFinder *m_peakMinMax = new SimpleMinMaxPeakFinder(minPeak, minPeakDistance);
std::string detector("");
switch(detectorType){
case 0:
m_detectorCurvature = new CurvatureDetector(m_peakMinMax, scale, baseSigma, sigmaStep, dmst);
m_detectorCurvature->setUseMaxRange(useMaxRange);
m_detector = m_detectorCurvature;
detector = "curvature";
break;
case 1:
m_detectorNormalEdge = new NormalEdgeDetector(m_peakMinMax, scale, baseSigma, sigmaStep, window);
m_detectorNormalEdge->setUseMaxRange(useMaxRange);
m_detector = m_detectorNormalEdge;
detector = "edge";
break;
case 2:
m_detectorNormalBlob = new NormalBlobDetector(m_peakMinMax, scale, baseSigma, sigmaStep, window);
m_detectorNormalBlob->setUseMaxRange(useMaxRange);
m_detector = m_detectorNormalBlob;
detector = "blob";
break;
case 3:
m_detectorRange = new RangeDetector(m_peakMinMax, scale, baseSigma, sigmaStep);
m_detectorRange->setUseMaxRange(useMaxRange);
m_detector = m_detectorRange;
detector = "range";
break;
default:
std::cerr << "Wrong detector type" << std::endl;
exit(-1);
}
HistogramDistance<double> *dist = NULL;
std::string distance("");
switch(distanceType){
case 0:
dist = new EuclideanDistance<double>();
distance = "euclid";
break;
case 1:
dist = new Chi2Distance<double>();
distance = "chi2";
break;
case 2:
dist = new SymmetricChi2Distance<double>();
distance = "symchi2";
break;
case 3:
dist = new BatthacharyyaDistance<double>();
distance = "batt";
break;
case 4:
dist = new KullbackLeiblerDistance<double>();
distance = "kld";
break;
case 5:
dist = new JensenShannonDistance<double>();
distance = "jsd";
break;
default:
std::cerr << "Wrong distance type" << std::endl;
exit(-1);
}
std::string descriptor("");
switch(descriptorType){
case 0:
m_betaGenerator = new BetaGridGenerator(0.02, 0.5, 4, 12);
m_betaGenerator->setDistanceFunction(dist);
m_descriptor = m_betaGenerator;
descriptor = "beta";
break;
case 1:
m_shapeGenerator = new ShapeContextGenerator(0.02, 0.5, 4, 12);
m_shapeGenerator->setDistanceFunction(dist);
m_descriptor = m_shapeGenerator;
descriptor = "shape";
break;
default:
std::cerr << "Wrong descriptor type" << std::endl;
exit(-1);
}
std::cerr << "Processing file:\t" << filename << "\nDetector:\t\t" << detector << "\nDescriptor:\t\t" << descriptor << "\nDistance:\t\t" << distance << std::endl;
switch(strategy){
case 0:
m_ransac = new RansacFeatureSetMatcher(acceptanceSigma * acceptanceSigma * 5.99, success, inlier, matchingThreshold, acceptanceSigma * acceptanceSigma * 3.84, false);
break;
case 1:
m_ransac = new RansacMultiFeatureSetMatcher(acceptanceSigma * acceptanceSigma * 5.99, success, inlier, matchingThreshold, acceptanceSigma * acceptanceSigma * 3.84, false);
break;
default:
std::cerr << "Wrong strategy type" << std::endl;
exit(-1);
}
m_sensorReference.seek(0,END);
unsigned int end = m_sensorReference.tell();
m_sensorReference.seek(0,BEGIN);
m_pointsReference.resize(end + 1);
m_posesReference.resize(end + 1);
computeBoundingBox();
detectLog();
describeLog();
std::stringstream mapFile;
mapFile << filename << "_map.png";
/* cairo_surface_t * cairoMapSurface = cairo_pdf_surface_create(mapFile.str().c_str(), sizeX, sizeY);
cairo_surface_t * cairoOutSurface = cairo_pdf_surface_create(outFile.str().c_str(), sizeX, sizeY);*/
cairo_surface_t * cairoMapSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, sizeX, sizeY);
// cairo_surface_t * cairoMapSurface = cairo_svg_surface_create(mapFile.str().c_str(), sizeX, sizeY);
cairoMap = cairo_create(cairoMapSurface);
std::stringstream outDir;
outDir << filename << "_" << detector << "_" << descriptor << "_" << distance << "/";
mkdir(outDir.str().c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
computeMap();
std::string bar(50,' ');
bar[0] = '#';
unsigned int progress = 0;
for(unsigned int i =0; i < m_pointsReference.size(); i++){
unsigned int currentProgress = (i*100)/(m_pointsReference.size() - 1);
if (progress < currentProgress){
progress = currentProgress;
bar[progress/2] = '#';
std::cout << "\rMatching [" << bar << "] " << progress << "%" << std::flush;
}
std::stringstream outFile;
outFile << outDir.str() << "frame_";
outFile.width(4);
outFile.fill('0');
outFile << std::right << i << ".png";
cairo_surface_t * cairoOutSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, sizeX, sizeY);
// cairo_surface_t * cairoOutSurface = cairo_svg_surface_create(outFile.str().c_str(), sizeX, sizeY);
cairoOut = cairo_create(cairoOutSurface);
cairo_translate(cairoOut, -offsetX, -offsetY);
cairo_scale(cairoOut, scaleFactor, scaleFactor);
cairo_set_line_width(cairoOut, 1./scaleFactor);
match(i);
cairo_surface_write_to_png(cairoOutSurface, outFile.str().c_str());
cairo_surface_destroy(cairoOutSurface);
cairo_destroy(cairoOut);
}
std::cout << " done." << std::endl;
cairo_surface_write_to_png(cairoMapSurface, mapFile.str().c_str());
cairo_surface_destroy(cairoMapSurface);
cairo_destroy(cairoMap);
// cairo_show_page(cairoOut);
}
void foo() {
// CHECK: private unnamed_addr constant
char Blah[] = "asdlfkajsdlfkajsd;lfkajds;lfkjasd;flkajsd;lkfja;sdlkfjasd";
bar(Blah);
}
void foo() { bar(ro); }
void LoadSkillDiscoveryTable()
{
SkillDiscoveryStore.clear(); // need for reload
uint32 count = 0;
// 0 1 2 3
QueryResult *result = WorldDatabase.Query("SELECT spellId, reqSpell, reqSkillValue, chance FROM skill_discovery_template");
if (!result)
{
sLog.outString();
sLog.outString( ">> Loaded 0 skill discovery definitions. DB table `skill_discovery_template` is empty." );
return;
}
barGoLink bar(result->GetRowCount());
std::ostringstream ssNonDiscoverableEntries;
std::set<uint32> reportedReqSpells;
do
{
Field *fields = result->Fetch();
bar.step();
uint32 spellId = fields[0].GetUInt32();
int32 reqSkillOrSpell = fields[1].GetInt32();
uint32 reqSkillValue = fields[2].GetInt32();
float chance = fields[3].GetFloat();
if (chance <= 0) // chance
{
ssNonDiscoverableEntries << "spellId = " << spellId << " reqSkillOrSpell = " << reqSkillOrSpell
<< " reqSkillValue = " << reqSkillValue << " chance = " << chance << "(chance problem)\n";
continue;
}
if (reqSkillOrSpell > 0) // spell case
{
SpellEntry const* reqSpellEntry = sSpellStore.LookupEntry(reqSkillOrSpell);
if (!reqSpellEntry)
{
if(reportedReqSpells.count(reqSkillOrSpell)==0)
{
sLog.outErrorDb("Spell (ID: %u) have not existed spell (ID: %i) in `reqSpell` field in `skill_discovery_template` table",spellId,reqSkillOrSpell);
reportedReqSpells.insert(reqSkillOrSpell);
}
continue;
}
// mechanic discovery
if (reqSpellEntry->Mechanic != MECHANIC_DISCOVERY &&
// explicit discovery ability
!IsExplicitDiscoverySpell(reqSpellEntry))
{
if (reportedReqSpells.count(reqSkillOrSpell)==0)
{
sLog.outErrorDb("Spell (ID: %u) not have MECHANIC_DISCOVERY (28) value in Mechanic field in spell.dbc"
" and not 100%% chance random discovery ability but listed for spellId %u (and maybe more) in `skill_discovery_template` table",
reqSkillOrSpell,spellId);
reportedReqSpells.insert(reqSkillOrSpell);
}
continue;
}
SkillDiscoveryStore[reqSkillOrSpell].push_back( SkillDiscoveryEntry(spellId, reqSkillValue, chance) );
}
else if (reqSkillOrSpell == 0) // skill case
{
SkillLineAbilityMapBounds bounds = sSpellMgr.GetSkillLineAbilityMapBounds(spellId);
if (bounds.first==bounds.second)
{
sLog.outErrorDb("Spell (ID: %u) not listed in `SkillLineAbility.dbc` but listed with `reqSpell`=0 in `skill_discovery_template` table",spellId);
continue;
}
for(SkillLineAbilityMap::const_iterator _spell_idx = bounds.first; _spell_idx != bounds.second; ++_spell_idx)
SkillDiscoveryStore[-int32(_spell_idx->second->skillId)].push_back( SkillDiscoveryEntry(spellId, reqSkillValue, chance) );
}
else
{
sLog.outErrorDb("Spell (ID: %u) have negative value in `reqSpell` field in `skill_discovery_template` table",spellId);
continue;
}
++count;
} while (result->NextRow());
delete result;
sLog.outString();
sLog.outString( ">> Loaded %u skill discovery definitions", count );
if (!ssNonDiscoverableEntries.str().empty())
sLog.outErrorDb("Some items can't be successfully discovered: have in chance field value < 0.000001 in `skill_discovery_template` DB table . List:\n%s",ssNonDiscoverableEntries.str().c_str());
// report about empty data for explicit discovery spells
for(uint32 spell_id = 1; spell_id < sSpellStore.GetNumRows(); ++spell_id)
{
SpellEntry const* spellEntry = sSpellStore.LookupEntry(spell_id);
if (!spellEntry)
continue;
// skip not explicit discovery spells
if (!IsExplicitDiscoverySpell(spellEntry))
continue;
if (SkillDiscoveryStore.find(spell_id)==SkillDiscoveryStore.end())
sLog.outErrorDb("Spell (ID: %u) is 100%% chance random discovery ability but not have data in `skill_discovery_template` table",spell_id);
}
}
void foo(void (*bar)(void))
{
bar();
}
int
main ()
{
return bar (0) + bar2 (0.0);
}
void foo( coro_t & c)
{
bar( count);
c();
}
void foo( boost::coroutines::coroutine< void >::pull_type & source)
{
bar( count);
source();
}
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.occurence < pGameEvent.length) // occurence < length is useless. This also asserts that occurence > 0!
{
sLog.outErrorDb("`game_event` game event id (%i) has occurence %u < length %u and can't be used.", event_id, pGameEvent.occurence, pGameEvent.length);
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(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) && !sObjectMgr.GetEquipmentInfoRaw(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` or `creature_equip_template_raw`, 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);
}
}
int main()
{
bar ();
return 0;
}
void
f (int i)
{
switch (i)
{
case 1:
if (i > 5) /* { dg-warning "statement may fall through" } */
bar (1);
else if (i > 10)
bar (2);
else if (i > 15)
bar (3);
case 2:
__builtin_abort ();
}
switch (i)
{
case 1:
if (i > 5) /* { dg-warning "statement may fall through" } */
bar (1);
else if (i > 10)
bar (2);
else if (i > 15)
bar (3);
else
bar (4);
case 2:
__builtin_abort ();
}
switch (i)
{
case 1:
if (i > 5)
return;
else if (i > 10) /* { dg-warning "statement may fall through" } */
bar (2);
else if (i > 15)
bar (3);
case 2:
__builtin_abort ();
}
switch (i)
{
case 1:
if (i > 5)
return;
else if (i > 10) /* { dg-warning "statement may fall through" } */
bar (2);
else if (i > 15)
bar (3);
else
bar (4);
case 2:
__builtin_abort ();
}
switch (i)
{
case 1:
if (i > 5) /* { dg-warning "statement may fall through" } */
bar (1);
else if (i > 10)
return;
else if (i > 15)
bar (3);
case 2:
__builtin_abort ();
}
switch (i)
{
case 1:
if (i > 5) /* { dg-warning "statement may fall through" } */
bar (1);
else if (i > 10)
return;
else if (i > 15)
bar (3);
else
bar (4);
case 2:
__builtin_abort ();
}
switch (i)
{
case 1:
if (i > 5) /* { dg-warning "statement may fall through" } */
bar (1);
else if (i > 10)
bar (4);
else if (i > 15)
return;
case 2:
__builtin_abort ();
}
switch (i)
{
case 1:
if (i > 5) /* { dg-warning "statement may fall through" } */
bar (1);
else if (i > 10)
bar (4);
else if (i > 15)
return;
else
bar (4);
case 2:
__builtin_abort ();
}
switch (i)
{
case 1:
if (i > 5)
return;
else if (i > 10)
return;
else if (i > 15) /* { dg-warning "statement may fall through" } */
bar (3);
case 2:
__builtin_abort ();
}
switch (i)
{
case 1:
if (i > 5)
return;
else if (i > 10)
return;
else if (i > 15) /* { dg-warning "statement may fall through" } */
bar (3);
else
bar (4);
case 2:
__builtin_abort ();
}
switch (i)
{
case 1:
if (i > 5)
return;
else if (i > 10) /* { dg-warning "statement may fall through" } */
bar (2);
else if (i > 15)
return;
case 2:
__builtin_abort ();
}
switch (i)
{
case 1:
if (i > 5)
return;
else if (i > 10) /* { dg-warning "statement may fall through" } */
bar (2);
else if (i > 15)
return;
else
bar (4);
case 2:
__builtin_abort ();
}
switch (i)
{
case 1:
if (i > 5) /* { dg-warning "statement may fall through" } */
bar (1);
else if (i > 10)
return;
else if (i > 15)
return;
case 2:
__builtin_abort ();
}
switch (i)
{
case 1:
if (i > 5) /* { dg-warning "statement may fall through" } */
bar (1);
else if (i > 10)
return;
else if (i > 15)
return;
else
bar (4);
case 2:
__builtin_abort ();
}
switch (i)
{
case 1:
if (i > 5)
return;
else if (i > 10)
return;
else if (i > 15) /* { dg-warning "statement may fall through" } */
return;
case 2:
__builtin_abort ();
}
switch (i)
{
case 1:
if (i > 5)
return;
else if (i > 10)
return;
else if (i > 15)
return;
else
bar (4); /* { dg-warning "statement may fall through" } */
case 2:
__builtin_abort ();
}
switch (i)
{
case 1:
if (i > 5)
return;
else if (i > 10)
return;
else if (i > 15)
return;
else
return;
case 2:
__builtin_abort ();
}
}
void AuctionHouseMgr::LoadAuctions()
{
QueryResult* result = CharacterDatabase.Query("SELECT COUNT(*) FROM auction");
if (!result)
{
BarGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded 0 auctions. DB table `auction` is empty.");
return;
}
Field* fields = result->Fetch();
uint32 AuctionCount = fields[0].GetUInt32();
delete result;
if (!AuctionCount)
{
BarGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded 0 auctions. DB table `auction` is empty.");
return;
}
result = CharacterDatabase.Query("SELECT id,houseid,itemguid,item_template,item_count,item_randompropertyid,itemowner,buyoutprice,time,moneyTime,buyguid,lastbid,startbid,deposit FROM auction");
if (!result)
{
BarGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded 0 auctions. DB table `auction` is empty.");
return;
}
BarGoLink bar(AuctionCount);
typedef UNORDERED_MAP<uint32, std::wstring> PlayerNames;
PlayerNames playerNames; // caching for load time
do
{
fields = result->Fetch();
bar.step();
AuctionEntry* auction = new AuctionEntry;
auction->Id = fields[0].GetUInt32();
uint32 houseid = fields[1].GetUInt32();
auction->itemGuidLow = fields[2].GetUInt32();
auction->itemTemplate = fields[3].GetUInt32();
auction->itemCount = fields[4].GetUInt32();
auction->itemRandomPropertyId = fields[5].GetUInt32();
auction->owner = fields[6].GetUInt32();
if (auction->owner)
{
std::wstring& plWName = playerNames[auction->owner];
if (plWName.empty())
{
std::string plName;
if (!sAccountMgr.GetPlayerNameByGUID(ObjectGuid(HIGHGUID_PLAYER, auction->owner), plName))
plName = sObjectMgr.GetMangosStringForDBCLocale(LANG_UNKNOWN);
Utf8toWStr(plName, plWName);
}
auction->ownerName = plWName;
}
auction->buyout = fields[7].GetUInt64();
auction->expireTime = time_t(fields[8].GetUInt64());
auction->moneyDeliveryTime = time_t(fields[9].GetUInt64());
auction->bidder = fields[10].GetUInt32();
auction->bid = fields[11].GetUInt64();
auction->startbid = fields[12].GetUInt64();
auction->deposit = fields[13].GetUInt64();
auction->auctionHouseEntry = NULL; // init later
if (auction->moneyDeliveryTime)
auction->itemGuidLow = 0; // must be 0 if auction delivery pending
else
{
// check if sold item exists for guid
// and item_template in fact (GetAItem will fail if problematic in result check in AuctionHouseMgr::LoadAuctionItems)
Item* pItem = GetAItem(auction->itemGuidLow);
if (!pItem)
{
auction->DeleteFromDB();
sLog.outError("Auction %u has not a existing item : %u, deleted", auction->Id, auction->itemGuidLow);
delete auction;
continue;
}
// overwrite by real item data
if ((auction->itemTemplate != pItem->GetEntry()) ||
(auction->itemCount != pItem->GetCount()) ||
(auction->itemRandomPropertyId != pItem->GetItemRandomPropertyId()))
{
auction->itemTemplate = pItem->GetEntry();
auction->itemCount = pItem->GetCount();
auction->itemRandomPropertyId = pItem->GetItemRandomPropertyId();
// No SQL injection (no strings)
CharacterDatabase.PExecute("UPDATE auction SET item_template = %u, item_count = %u, item_randompropertyid = %i WHERE itemguid = %u",
auction->itemTemplate, auction->itemCount, auction->itemRandomPropertyId, auction->itemGuidLow);
}
}
auction->auctionHouseEntry = sAuctionHouseStore.LookupEntry(houseid);
if (!auction->auctionHouseEntry)
{
// need for send mail, use goblin auctionhouse
auction->auctionHouseEntry = sAuctionHouseStore.LookupEntry(7);
// Attempt send item back to owner
std::ostringstream msgAuctionCanceledOwner;
msgAuctionCanceledOwner << auction->itemTemplate << ":" << auction->itemRandomPropertyId << ":" << AUCTION_CANCELED << ":" << auction->Id << ":" << auction->itemCount;
if (auction->itemGuidLow)
{
Item* pItem = GetAItem(auction->itemGuidLow);
RemoveAItem(auction->itemGuidLow);
auction->itemGuidLow = 0;
// item will deleted or added to received mail list
MailDraft(msgAuctionCanceledOwner.str(), "")// TODO: fix body
.AddItem(pItem)
.SendMailTo(MailReceiver(ObjectGuid(HIGHGUID_PLAYER, auction->owner)), auction, MAIL_CHECK_MASK_COPIED);
}
auction->DeleteFromDB();
delete auction;
continue;
}
GetAuctionsMap(auction->auctionHouseEntry)->AddAuction(auction);
}
while (result->NextRow());
delete result;
sLog.outString();
sLog.outString(">> Loaded %u auctions", AuctionCount);
}
~E() { bar(); }
void clear_zone(int top, int left, int right, int bottom)
{
setfillstyle(EMPTY_FILL,BLACK);
bar(top,left,right,bottom);
}
void SD3::InitScriptLibrary()
{
// ScriptDev3 startup
outstring_log(" ___ _ _ ___ ____");
outstring_log(" / __| __ _ _(_)_ __| |_| \\ _____ __ |__ /");
outstring_log(" \\__ \\/ _| '_| | '_ \\ _| |) / -_) V / |_ \\");
outstring_log(" |___/\\__|_| |_| .__/\\__|___/\\___|\\_/ |___/");
outstring_log(" |_| ");
outstring_log(" https://getmangos.eu/\n");
// Get configuration file
bool configFailure = false;
if (!SD3Config.SetSource(MANGOSD_CONFIG_LOCATION))
{
configFailure = true;
}
else
{
outstring_log("sd3: Using configuration file %s", MANGOSD_CONFIG_LOCATION);
}
// Set SD3 Error Log File
std::string SD3LogFile = SD3Config.GetStringDefault("SD3ErrorLogFile", "scriptdev3-errors.log");
setScriptLibraryErrorFile(SD3LogFile.c_str(), "SD3");
if (configFailure)
{
script_error_log("Unable to open configuration file. Database will be unaccessible. Configuration values will use default.");
}
// Check config file version
if (SD3Config.GetIntDefault("ConfVersion", 0) != MANGOSD_CONFIG_VERSION)
{
script_error_log("Configuration file version doesn't match expected version. Some config variables may be wrong or missing.");
}
outstring_log("\n");
// Load database (must be called after SD3Config.SetSource).
LoadDatabase();
outstring_log("sd3: Loading C++ scripts");
BarGoLink bar(1);
bar.step();
// Resize script ids to needed ammount of assigned ScriptNames (from core)
m_scripts.resize(GetScriptIdsCount(), NULL);
FillSpellSummary();
AddScripts();
// Check existance scripts for all registered by core script names
for (uint32 i = 1; i < GetScriptIdsCount(); ++i)
{
if (!m_scripts[i])
{
script_error_log("No script found for ScriptName '%s'.", GetScriptName(i));
}
}
outstring_log(">> Loaded %i C++ Scripts.", num_sc_scripts);
}
void
foo (void)
{
bar ();
}
static void *thread_second(void *arg)
{
foo();
return bar(arg);
}
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, 0))
{
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;
}
}
static void *thread_fourth(void *arg)
{
foo();
return bar(arg);
}
/* silence `empty compilation unit' warnings */
static void bar(void); static void foo(void) { bar(); } static void bar(void) { foo(); }
void
bar2 ()
{
bar ();
}
int main()
{
return foo(0) + bar(0);
}
void AuctionHouseMgr::LoadAuctions()
{
QueryResult *result = CharacterDatabase.Query("SELECT COUNT(*) FROM auction");
if( !result )
{
barGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded 0 auctions. DB table `auction` is empty.");
return;
}
Field *fields = result->Fetch();
uint32 AuctionCount=fields[0].GetUInt32();
delete result;
if(!AuctionCount)
{
barGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded 0 auctions. DB table `auction` is empty.");
return;
}
result = CharacterDatabase.Query( "SELECT id,houseid,itemguid,item_template,itemowner,buyoutprice,time,buyguid,lastbid,startbid,deposit FROM auction" );
if( !result )
{
barGoLink bar(1);
bar.step();
sLog.outString();
sLog.outString(">> Loaded 0 auctions. DB table `auction` is empty.");
return;
}
barGoLink bar( AuctionCount );
AuctionEntry *auction;
do
{
fields = result->Fetch();
bar.step();
auction = new AuctionEntry;
auction->Id = fields[0].GetUInt32();
uint32 houseid = fields[1].GetUInt32();
auction->item_guidlow = fields[2].GetUInt32();
auction->item_template = fields[3].GetUInt32();
auction->owner = fields[4].GetUInt32();
auction->buyout = fields[5].GetUInt32();
auction->expire_time = fields[6].GetUInt32();
auction->bidder = fields[7].GetUInt32();
auction->bid = fields[8].GetUInt32();
auction->startbid = fields[9].GetUInt32();
auction->deposit = fields[10].GetUInt32();
auction->auctionHouseEntry = NULL; // init later
// check if sold item exists for guid
// and item_template in fact (GetAItem will fail if problematic in result check in AuctionHouseMgr::LoadAuctionItems)
Item* pItem = GetAItem(auction->item_guidlow);
if (!pItem)
{
auction->DeleteFromDB();
sLog.outError("Auction %u has not a existing item : %u, deleted", auction->Id, auction->item_guidlow);
delete auction;
continue;
}
auction->auctionHouseEntry = sAuctionHouseStore.LookupEntry(houseid);
if (!houseid)
{
// need for send mail, use goblin auctionhouse
auction->auctionHouseEntry = sAuctionHouseStore.LookupEntry(7);
// Attempt send item back to owner
std::ostringstream msgAuctionCanceledOwner;
msgAuctionCanceledOwner << auction->item_template << ":0:" << AUCTION_CANCELED << ":0:0";
// item will deleted or added to received mail list
MailDraft(msgAuctionCanceledOwner.str(), "") // TODO: fix body
.AddItem(pItem)
.SendMailTo(MailReceiver(auction->owner), auction, MAIL_CHECK_MASK_COPIED);
RemoveAItem(auction->item_guidlow);
auction->DeleteFromDB();
delete auction;
continue;
}
GetAuctionsMap(auction->auctionHouseEntry)->AddAuction(auction);
} while (result->NextRow());
delete result;
sLog.outString();
sLog.outString( ">> Loaded %u auctions", AuctionCount );
}
int foo ()
{
std::decimal::decimal64 x(0);
bar (x);
}