void UpdateTowerCount()
{
MapMgr* mgr = _gameobject->GetMapMgr();
mgr->GetWorldStatesHandler().SetWorldStateForZone(ZONE_TEROKKAR_FOREST, mgr->GetAreaID( _gameobject->GetPositionX(), _gameobject->GetPositionY() ),WORLDSTATE_TEROKKAR_ALLIANCE_TOWERS_CONTROLLED, TFg_allianceTowers);
mgr->GetWorldStatesHandler().SetWorldStateForZone(ZONE_TEROKKAR_FOREST, mgr->GetAreaID( _gameobject->GetPositionX(), _gameobject->GetPositionY() ),WORLDSTATE_TEROKKAR_HORDE_TOWERS_CONTROLLED, TFg_hordeTowers);
Player* plr = _gameobject->GetMapMgr()->GetInterface()->GetPlayerNearestCoords(_gameobject->GetPositionX(), _gameobject->GetPositionY(), _gameobject->GetPositionZ() - 34);
if(TFg_superiorTeam == 0 && TFg_allianceTowers != 5)
{
plr->RemoveAura(BLESSING_OF_AUCHINDOUND);
TFg_superiorTeam = -1;
}
if(TFg_superiorTeam == 1 && TFg_hordeTowers != 5)
{
plr->RemoveAura(BLESSING_OF_AUCHINDOUND);
TFg_superiorTeam = -1;
}
if(TFg_allianceTowers == 5 && TFg_superiorTeam != 0)
{
TFg_superiorTeam = 0;
plr->CastSpell(plr, BLESSING_OF_AUCHINDOUND, false);
}
if(TFg_hordeTowers == 5 && TFg_superiorTeam != 1)
{
TFg_superiorTeam = 1;
plr->CastSpell(plr, BLESSING_OF_AUCHINDOUND, false);
}
}
MapMgr* InstanceMgr::CreateInstance(uint32 instanceType, uint32 mapid)
{
// shouldn't happen
if(mapid >= NUM_MAPS)
return NULL;
if(!m_maps[mapid])
{
_CreateMap(mapid);
if(!m_maps[mapid])
return NULL;
}
MapMgr* ret = new MapMgr(m_maps[mapid], mapid, GenerateInstanceID());
Instance* pInstance = new Instance();
pInstance->m_creation = UNIXTIME;
pInstance->m_creatorGroup = 0;
pInstance->m_creatorGuid = 0;
pInstance->m_difficulty = 0;
pInstance->m_expiration = 0;
pInstance->m_instanceId = ret->GetInstanceID();
pInstance->m_persistent = false;
pInstance->m_mapId = mapid;
pInstance->m_mapInfo = WorldMapInfoStorage.LookupEntry(mapid);
pInstance->m_mapMgr = ret;
m_mapLock.Acquire();
if(m_instances[mapid] == NULL)
m_instances[mapid] = new InstanceMap;
m_instances[mapid]->insert(make_pair(pInstance->m_instanceId, pInstance));
m_mapLock.Release();
ThreadPool.ExecuteTask(ret);
return ret;
}
Unit* MoonScriptCreatureAI::ForceCreatureFind(uint32 pCreatureId, float pX, float pY, float pZ, bool pCurrentPosition)
{
Unit *pUnit = NULL;
MapMgr *pMapMgr = _unit->GetMapMgr();
if (pMapMgr == NULL)
return pUnit;
if (pCurrentPosition)
pUnit = pMapMgr->GetInterface()->GetCreatureNearestCoords(_unit->GetPositionX(), _unit->GetPositionY(), _unit->GetPositionZ(), pCreatureId);
else
pUnit = pMapMgr->GetInterface()->GetCreatureNearestCoords(pX, pY, pZ, pCreatureId);
if (pUnit == NULL)
{
for (int i = 0; i != pMapMgr->m_CreatureHighGuid; ++i)
{
if (pMapMgr->m_CreatureStorage[i] != NULL)
{
pUnit = pMapMgr->m_CreatureStorage[i];
if (pUnit->GetEntry() == pCreatureId)
return pUnit;
pUnit = NULL;
}
}
}
return pUnit;
}
uint32 Transporter::AddNPCPassenger(uint32 tguid, uint32 entry, float x, float y, float z, float o, uint32 anim)
{
MapMgr* map = GetMapMgr();
CreatureProperties const* creature_properties = sMySQLStore.getCreatureProperties(entry);
if (creature_properties == nullptr || map == nullptr)
return 0;
#if VERSION_STRING != Cata
float transporter_x = obj_movement_info.transport_data.relativePosition.x + x;
float transporter_y = obj_movement_info.transport_data.relativePosition.y + y;
float transporter_z = obj_movement_info.transport_data.relativePosition.z + z;
#else
float transporter_x = obj_movement_info.getTransportPosition()->x + x;
float transporter_y = obj_movement_info.getTransportPosition()->y + y;
float transporter_z = obj_movement_info.getTransportPosition()->z + z;
#endif
Creature* pCreature = map->CreateCreature(entry);
pCreature->Create(map->GetMapId(), transporter_x, transporter_y, transporter_z, (std::atan2(transporter_x, transporter_y) + float(M_PI)) + o);
pCreature->Load(creature_properties, transporter_x, transporter_y, transporter_z, (std::atan2(transporter_x, transporter_y) + float(M_PI)) + o);
pCreature->AddToWorld(map);
pCreature->SetUnitMovementFlags(MOVEFLAG_TRANSPORT);
#if VERSION_STRING != Cata
pCreature->obj_movement_info.transport_data.relativePosition.x = x;
pCreature->obj_movement_info.transport_data.relativePosition.y = y;
pCreature->obj_movement_info.transport_data.relativePosition.z = z;
pCreature->obj_movement_info.transport_data.relativePosition.o = o;
pCreature->obj_movement_info.transport_data.transportGuid = getGuid();
#else
pCreature->obj_movement_info.setTransportData(getGuid(), x, y, z, o, 0, 0);
#endif
pCreature->m_transportData.transportGuid = this->getGuid();
pCreature->m_transportData.relativePosition.x = x;
pCreature->m_transportData.relativePosition.y = y;
pCreature->m_transportData.relativePosition.z = z;
pCreature->m_transportData.relativePosition.o = o;
if (anim)
pCreature->setUInt32Value(UNIT_NPC_EMOTESTATE, anim);
if (creature_properties->NPCFLags)
pCreature->setUInt32Value(UNIT_NPC_FLAGS, creature_properties->NPCFLags);
m_creatureSetMutex.Acquire();
m_NPCPassengerSet.insert(pCreature);
m_creatureSetMutex.Release();
if (tguid == 0)
{
++currenttguid;
tguid = currenttguid;
}
else
currenttguid = std::max(tguid, currenttguid);
return tguid;
}
MapMgr* InstanceMgr::ClusterCreateInstance( uint32 mapid, uint32 instanceid )
{
// shouldn't happen
if( mapid >= NUM_MAPS )
return NULLMAPMGR;
MapInfo * info = WorldMapInfoStorage.LookupEntry( mapid );
if( !info )
return NULLMAPMGR;
if( !m_maps[mapid] )
{
_CreateMap(mapid);
if(!m_maps[mapid])
return NULLMAPMGR;
}
MapMgr* mgr = new MapMgr(m_maps[mapid],mapid,instanceid);
if( !mgr )
return NULLMAPMGR;
mgr->Init(true);
Instance * pInstance = new Instance();
if( !pInstance )
{
delete mgr;
return NULLMAPMGR;
}
pInstance->m_creation = UNIXTIME;
pInstance->m_creatorGroup = 0;
pInstance->m_creatorGuid = 0;
pInstance->m_difficulty = 0;
pInstance->m_expiration = 0;
pInstance->m_instanceId = mgr->GetInstanceID();
pInstance->m_isBattleground = true;
pInstance->m_mapId = mapid;
pInstance->m_dbcMap = dbcMap.LookupEntry(mapid);
pInstance->m_mapInfo = info;
pInstance->m_mapMgr = mgr;
m_mapLock.Acquire();
InstanceMap * pInstanceMap = new InstanceMap;
if( !pInstanceMap )
{
m_mapLock.Release();
delete mgr;
delete pInstance;
return NULLMAPMGR;
}
if( m_instances[mapid] == NULL )
m_instances[mapid] = pInstanceMap;
m_instances[mapid]->insert( make_pair( pInstance->m_instanceId, pInstance ) );
m_mapLock.Release();
ThreadPool.ExecuteTask(format("Map mgr - M%u|I%u", mapid, pInstance->m_instanceId).c_str(), mgr);
return mgr;
}
void Object::PlaceOnMap()
{
ASSERT(!IsInWorld() && !m_mapMgr);
MapMgr* mapMgr = sWorld.GetMap(m_mapId);
ASSERT(mapMgr);
mapMgr->AddObject(this);
m_mapMgr = mapMgr;
mSemaphoreTeleport = false;
}
//////////////////////////////////////////////////////////////////////////
// WORLD PVP NOT SUPPORTED!
//////////////////////////////////////////////////////////////////////////
int LuaGlobalFunctions_SendPvPCaptureMessage(lua_State * L)
{
uint32 zoneid = luaL_checkint(L, 1);
const char* msg = luaL_checkstring(L, 2);
AreaTable * at = dbcArea.LookupEntry(zoneid);
if(!zoneid || !msg || !at)
return 1;
MapMgr* mapmgr = sInstanceMgr.GetMapMgr(at->mapId);
if (mapmgr != NULL)
mapmgr->SendPvPCaptureMessage(ZONE_MASK_ALL, zoneid, msg);
return 1;
}
void GameEventMgr::DespawnEvent(uint32 id)
{
Log.Success("GameEvent","Started despawning event %u", id);
// creatures
for(std::map<uint32, std::list<uint32>>::iterator mitr = m_creaturespawns[id].begin(); mitr != m_creaturespawns[id].end(); mitr++)
{
for(std::list<uint32>::iterator gitr = mitr->second.begin(); gitr != mitr->second.end(); gitr++)
{
// find creature with current guid(*gitr) and despawn it
MapMgr *mgr = sInstanceMgr.GetMapMgr(mitr->first);
Creature *crt = mgr->GetCreature(*gitr);
if(crt == NULL)
{
Log.Success("GameEvent","Failed to despawn creature with guid %u for event %u", *gitr, id);
}
else
{
// we don't need to delete waypoints as they are stored in m_custom_waypoint_map
// and they are deleted automatically when creature is deleted
crt->Despawn(0,0);
Log.Success("GameEvent","creature with guid %u despawned from map %u for event %u", *gitr, mitr->first, id);
}
}
mitr->second.clear();
}
// gameobjects
for(std::map<uint32, std::list<uint32>>::iterator mitr = m_gameobjectspawns[id].begin(); mitr != m_gameobjectspawns[id].end(); mitr++)
{
for(std::list<uint32>::iterator gitr = mitr->second.begin(); gitr != mitr->second.end(); gitr++)
{
// find gameobject with current guid(*gitr) and despawn it
MapMgr *mgr = sInstanceMgr.GetMapMgr(mitr->first);
GameObject *go = mgr->GetGameObject(*gitr);
if(go == NULL)
{
Log.Success("GameEvent","Failed to despawn gameobject with guid %u for event %u", *gitr, id);
}
else
{
go->Despawn(0,0);
Log.Success("GameEvent","gameobject with guid %u despawned from map %u for event %u", *gitr, mitr->first, id);
}
}
mitr->second.clear();
}
Log.Success("GameEvent","event %u despawned.", id);
}
Creature* Transporter::AddNPCPassengerInInstance(uint32 entry, float x, float y, float z, float o, uint32 /*anim*/)
{
MapMgr* map = GetMapMgr();
CreatureProperties const* creature_properties = sMySQLStore.getCreatureProperties(entry);
if (creature_properties == nullptr || map == nullptr)
return nullptr;
#if VERSION_STRING != Cata
float transporter_x = obj_movement_info.transport_data.relativePosition.x + x;
float transporter_y = obj_movement_info.transport_data.relativePosition.y + y;
float transporter_z = obj_movement_info.transport_data.relativePosition.z + z;
#else
float transporter_x = obj_movement_info.getTransportPosition()->x + x;
float transporter_y = obj_movement_info.getTransportPosition()->y + y;
float transporter_z = obj_movement_info.getTransportPosition()->z + z;
#endif
Creature* pCreature = map->CreateCreature(entry);
pCreature->Create(map->GetMapId(), transporter_x, transporter_y, transporter_z, (std::atan2(transporter_x, transporter_y) + float(M_PI)) + o);
pCreature->Load(creature_properties, transporter_x, transporter_y, transporter_z, (std::atan2(transporter_x, transporter_y) + float(M_PI)) + o);
pCreature->AddToWorld(map);
pCreature->SetUnitMovementFlags(MOVEFLAG_TRANSPORT);
#if VERSION_STRING != Cata
pCreature->obj_movement_info.transport_data.relativePosition.x = x;
pCreature->obj_movement_info.transport_data.relativePosition.y = y;
pCreature->obj_movement_info.transport_data.relativePosition.z = z;
pCreature->obj_movement_info.transport_data.relativePosition.o = o;
pCreature->obj_movement_info.transport_data.transportGuid = getGuid();
#else
pCreature->obj_movement_info.setTransportData(getGuid(), x, y, z, o, 0, 0);
#endif
pCreature->m_transportData.transportGuid = this->getGuid();
pCreature->m_transportData.relativePosition.x = x;
pCreature->m_transportData.relativePosition.y = y;
pCreature->m_transportData.relativePosition.z = z;
pCreature->m_transportData.relativePosition.o = o;
m_creatureSetMutex.Acquire();
m_NPCPassengerSet.insert(pCreature);
m_creatureSetMutex.Release();
return pCreature;
}
void WorldCreator::DeleteInstance(uint32 instanceid, uint32 mapid)
{
_busy.Acquire();
MapMgr * mapMgr = NULL;
mapMgr = GetMap(mapid)->GetRawInstance(instanceid);
if(mapMgr)
{
if(!mapMgr->HasPlayers())
{
GetMap(mapid)->DestroyMapMgrInstance(instanceid);
sLog.outDebug("Instance %i on map %i deleted with success\n", instanceid, mapid);
}
}
else
{
sLog.outDebug("Instance %i failed to be deleted, reason: Doesnt Exist\n", instanceid);
}
_busy.Release();
}
void OnSpawn()
{
MapMgr* mgr = _gameobject->GetMapMgr();
Player* plr = _gameobject->GetMapMgr()->GetInterface()->GetPlayerNearestCoords(_gameobject->GetPositionX(), _gameobject->GetPositionY(), _gameobject->GetPositionZ());
m_bannerStatus = BANNER_STATUS_NEUTRAL;
// preloaded data, do we have any?
if(TFg_towerOwners[towerid] == 1)
{
m_bannerStatus = BANNER_STATUS_HORDE;
Status = 0;
// state update
mgr->GetWorldStatesHandler().SetWorldStateForZone(ZONE_TEROKKAR_FOREST, mgr->GetAreaID( _gameobject->GetPositionX(), _gameobject->GetPositionY() ), g_hordeStateFields[towerid], 1);
mgr->GetWorldStatesHandler().SetWorldStateForZone(ZONE_TEROKKAR_FOREST, mgr->GetAreaID( _gameobject->GetPositionX(), _gameobject->GetPositionY() ), g_neutralStateFields[towerid], 0);
// countz
TFg_hordeTowers++;
UpdateTowerCount();
SetArtKit();
}
else if(TFg_towerOwners[towerid] == 0)
{
m_bannerStatus = BANNER_STATUS_ALLIANCE;
Status = 100;
// state update
mgr->GetWorldStatesHandler().SetWorldStateForZone(ZONE_TEROKKAR_FOREST, mgr->GetAreaID( _gameobject->GetPositionX(), _gameobject->GetPositionY() ), g_allianceStateFields[towerid], 1);
mgr->GetWorldStatesHandler().SetWorldStateForZone(ZONE_TEROKKAR_FOREST, mgr->GetAreaID( _gameobject->GetPositionX(), _gameobject->GetPositionY() ), g_neutralStateFields[towerid], 0);
// countz
TFg_allianceTowers++;
UpdateTowerCount();
SetArtKit();
}
// start the event timer
RegisterAIUpdateEvent(UPDATE_PERIOD);
}
Unit *MoonScriptCreatureAI::ForceCreatureFind( uint32 pCreatureId, float pX, float pY, float pZ )
{
Unit *UnitPtr = NULLUNIT;
MapMgr *Mgr = _unit->GetMapMgr();
if ( Mgr == NULL )
return UnitPtr;
UnitPtr = TO_UNIT(Mgr->GetObjectClosestToCoords(pCreatureId, pX, pY, pZ, 99999.0f, TYPEID_UNIT ));
if ( UnitPtr == NULL )
{
UnitArray Array;
for ( uint32 i = 0; i != Mgr->m_CreatureHighGuid; ++i )
{
UnitPtr = Mgr->m_CreatureStorage[ i ];
if ( UnitPtr != NULL )
{
if ( UnitPtr->GetEntry() == pCreatureId && UnitPtr != _unit )
Array.push_back( UnitPtr );
}
}
if ( Array.size() == 1 )
return Array[ 0 ];
UnitPtr = NULLUNIT;
float Distance, NearestDistance = 99999;
for ( UnitArray::iterator UnitIter = Array.begin(); UnitIter != Array.end(); ++UnitIter )
{
Distance = _unit->CalcDistance( pX, pY, pZ, ( *UnitIter )->GetPositionX(), ( *UnitIter )->GetPositionY(), ( *UnitIter )->GetPositionZ() );
if ( Distance < NearestDistance )
{
NearestDistance = Distance;
UnitPtr = ( *UnitIter );
}
}
}
return UnitPtr;
}
Unit* AscentScriptCreatureAI::ForceCreatureFind( uint32 pCreatureId, float pX, float pY, float pZ )
{
Unit* UnitPtr = NULL;
MapMgr* Mgr = _unit->GetMapMgr();
if ( Mgr == NULL )
return UnitPtr;
UnitPtr = Mgr->GetInterface()->GetCreatureNearestCoords( pX, pY, pZ, pCreatureId );
if ( UnitPtr == NULL )
{
UnitArray Array;
for ( uint32 i = 0; i != Mgr->m_CreatureHighGuid; ++i )
{
UnitPtr = Mgr->m_CreatureStorage[ i ];
if ( UnitPtr != NULL )
{
if ( UnitPtr->GetEntry() == pCreatureId && UnitPtr != _unit )
Array.push_back( UnitPtr );
};
};
if ( Array.size() == 1 )
return Array[ 0 ];
UnitPtr = NULL;
float Distance, NearestDistance = 99999;
for ( UnitArray::iterator UnitIter = Array.begin(); UnitIter != Array.end(); ++UnitIter )
{
Distance = _unit->CalcDistance( pX, pY, pZ, ( *UnitIter )->GetPositionX(), ( *UnitIter )->GetPositionY(), ( *UnitIter )->GetPositionZ() );
if ( Distance < NearestDistance )
{
NearestDistance = Distance;
UnitPtr = ( *UnitIter );
};
};
};
return UnitPtr;
};
MapMgr* InstanceMgr::CreateBattlegroundInstance(uint32 mapid)
{
// shouldn't happen
if( mapid >= NUM_MAPS )
return NULLMAPMGR;
if(dbcMap.LookupEntry(mapid) == NULL)
return NULLMAPMGR;
if(!m_maps[mapid])
{
_CreateMap(mapid);
if(!m_maps[mapid])
return NULLMAPMGR;
}
MapMgr* ret = (new MapMgr(m_maps[mapid], mapid, GenerateInstanceID()));
ret->Init(true);
Instance * pInstance = new Instance();
pInstance->m_creation = UNIXTIME;
pInstance->m_creatorGroup = 0;
pInstance->m_creatorGuid = 0;
pInstance->m_difficulty = MODE_5PLAYER_NORMAL;
pInstance->m_expiration = 0;
pInstance->m_instanceId = ret->GetInstanceID();
pInstance->m_isBattleground = true;
pInstance->m_mapId = mapid;
pInstance->m_dbcMap = dbcMap.LookupEntry(mapid);
pInstance->m_mapInfo = WorldMapInfoStorage.LookupEntry(mapid);
pInstance->m_mapMgr = ret;
m_mapLock.Acquire();
if( m_instances[mapid] == NULL )
m_instances[mapid] = new InstanceMap;
m_instances[mapid]->insert( make_pair( pInstance->m_instanceId, pInstance ) );
m_mapLock.Release();
ThreadPool.ExecuteTask(format("BattleGround Mgr - M%u|I%u", mapid, pInstance->m_instanceId).c_str(), ret);
return ret;
}
void InstanceMgr::Shutdown()
{
uint32 i;
InstanceMap::iterator itr;
for(i = 0; i < NUM_MAPS; i++)
{
if(m_instances[i] != NULL)
{
for(itr = m_instances[i]->begin(); itr != m_instances[i]->end(); itr++)
{
if(itr->second->m_mapMgr)
itr->second->m_mapMgr->KillThread();
delete itr->second;
}
delete m_instances[i];
m_instances[i] = NULL;
}
if(m_singleMaps[i] != NULL)
{
MapMgr* ptr = m_singleMaps[i];
ptr->KillThread();
delete ptr;
ptr = NULLMAPMGR;
m_singleMaps[i] = NULLMAPMGR;// and it dies :)
}
if(m_maps[i] != NULL)
{
delete m_maps[i];
m_maps[i] = NULL;
}
}
delete FormationMgr::getSingletonPtr();
}
uint32 WorldCreator::CreateInstance(Group *pGroup, Player *pPlayer, uint32 mapid, uint32 instanceid, uint32 creation, MapMgr ** destptr, uint32 difficulty)
{
if(pGroup == NULL && pPlayer == NULL && instanceid == 0)
{
return INSTANCE_ABORT_ERROR;
}
Map* instance_map = GetMap(mapid);
ASSERT(instance_map != NULL);
MapMgr * pInstance = instance_map->CreateMapMgrInstance(instanceid);
ASSERT(pInstance);
if(creation)
{
pInstance->SetNewExpireTime(creation);
}
if(pGroup)
{
pInstance->SetGroupSignature(pGroup->GetID());
pInstance->iInstanceMode = pGroup->GetLeader()->iInstanceType;
}
if(pPlayer)
{
pInstance->SetCreator(pPlayer);
pInstance->iInstanceMode = pPlayer->iInstanceType;
}
if(difficulty)
{
pInstance->iInstanceMode = difficulty;
}
//Capt: We do not realy need to store this one if we are not doing something with it.
sInstanceSavingManager.SaveInstance(pInstance); //first time instance saving holder
if(destptr)
*destptr = pInstance;
return pInstance->GetInstanceID();
}
bool ChatHandler::HandleDeleteCommand(const char* args, WorldSession *m_session)
{
Creature* unit = getSelectedCreature(m_session, false);
if(!unit)
{
SystemMessage(m_session, "You should select a creature.");
return true;
}
else if(unit->IsPet() || unit->IsSummon())
{
SystemMessage(m_session, "You can't delete playerpets.");
return true;
}
if( unit->m_spawn != NULL && !m_session->CanUseCommand('z') )
{
SystemMessage(m_session, "You do not have permission to do that. Please contact higher staff for removing of saved spawns.");
return true;
}
if(unit->IsVehicle())
{
Vehicle* veh = TO_VEHICLE(unit);
for(int i = 0; i < 8; i++)
{
if(!veh->GetPassenger(i))
continue;
// Remove any players
if(veh->GetPassenger(i)->IsPlayer())
veh->RemovePassenger(veh->GetPassenger(i));
else // Remove any units.
veh->GetPassenger(i)->RemoveFromWorld(true);
}
}
sWorld.LogGM(m_session, "used npc delete, sqlid %u, creature %s, pos %f %f %f",
unit->m_spawn ? unit->m_spawn->id : 0, unit->GetCreatureInfo() ? unit->GetCreatureInfo()->Name : "wtfbbqhax", unit->GetPositionX(), unit->GetPositionY(),
unit->GetPositionZ());
BlueSystemMessage(m_session, "Deleted creature ID %u", unit->spawnid);
unit->DeleteFromDB();
if(!unit->IsInWorld())
return true;
MapMgr* unitMgr = unit->GetMapMgr();
if(unit->m_spawn)
{
uint32 cellx = unitMgr->GetPosX(unit->m_spawn->x);
uint32 celly = unitMgr->GetPosX(unit->m_spawn->y);
if(cellx <= _sizeX && celly <= _sizeY )
{
CellSpawns *c = unitMgr->GetBaseMap()->GetSpawnsList(cellx, celly);
if( c != NULL )
{
CreatureSpawnList::iterator itr, itr2;
for(itr = c->CreatureSpawns.begin(); itr != c->CreatureSpawns.end();)
{
itr2 = itr++;
if((*itr2) == unit->m_spawn)
{
c->CreatureSpawns.erase(itr2);
delete unit->m_spawn;
break;
}
}
}
}
}
unit->RemoveFromWorld(false, true);
if(unit->IsVehicle())
TO_VEHICLE(unit)->Destruct();
else
unit->Destruct();
m_session->GetPlayer()->SetSelection(NULL);
return true;
}
void LuaEngineMgr::Restart(ScriptMgr* sMgr)
{
Log.Notice("LuaEngineMgr", "Restarting Engine.");
CREATE_L_PTR;
g_engine->getcoLock().Acquire();
Unload();
m_engine->LoadScripts();
for(UnitBindingMap::iterator itr = m_unitBinding.begin(); itr != m_unitBinding.end(); ++itr)
{
typedef multimap<uint32, LuaCreature*> CMAP;
CMAP & cMap = g_luaMgr.getLuCreatureMap();
CMAP::iterator it = cMap.find(itr->first);
CMAP::iterator itend = cMap.upper_bound(itr->first);
if(it == cMap.end())
{
sMgr->register_creature_script(itr->first, CreateLuaCreature);
cMap.insert(make_pair(itr->first, (LuaCreature*)NULL));
}
else
{
for(; it != itend; ++it)
{
if(it->second != NULL)
it->second->m_binding = &itr->second;
}
}
}
for(GameObjectBindingMap::iterator itr = m_gameobjectBinding.begin(); itr != m_gameobjectBinding.end(); ++itr)
{
typedef multimap<uint32, LuaGameObject*> GMAP;
GMAP & gMap = g_luaMgr.getLuGameObjectMap();
GMAP::iterator it = gMap.find(itr->first);
GMAP::iterator itend = gMap.upper_bound(itr->first);
if(it == gMap.end())
{
sMgr->register_gameobject_script(itr->first, CreateLuaGameObject);
gMap.insert(make_pair(itr->first, (LuaGameObject*)NULL));
}
else
{
for(; it != itend; ++it)
{
if(it->second != NULL)
it->second->m_binding = &itr->second;
}
}
}
for(QuestBindingMap::iterator itr = m_questBinding.begin(); itr != m_questBinding.end(); ++itr)
{
typedef HM_NAMESPACE::hash_map<uint32, LuaQuest*> QMAP;
QMAP & qMap = g_luaMgr.getLuQuestMap();
QMAP::iterator it = qMap.find(itr->first);
if(it == qMap.end())
{
sMgr->register_quest_script(itr->first, CreateLuaQuestScript(itr->first));
qMap.insert(make_pair(itr->first, (LuaQuest*)NULL));
}
else
{
LuaQuest* q_interface = it->second;
if(q_interface != NULL)
q_interface->m_binding = &itr->second;
}
}
for(InstanceBindingMap::iterator itr = m_instanceBinding.begin(); itr != m_instanceBinding.end(); ++itr)
{
typedef HM_NAMESPACE::hash_map<uint32, LuaInstance*> IMAP;
IMAP & iMap = g_luaMgr.getLuInstanceMap();
IMAP::iterator it = iMap.find(itr->first);
if(it == iMap.end())
{
sMgr->register_mapmanager_script(itr->first, CreateLuaInstance);
iMap.insert(make_pair(itr->first, (LuaInstance*)NULL));
}
else
{
if(it->second != NULL)
it->second->m_binding = &itr->second;
}
}
for(GossipUnitScriptsBindingMap::iterator itr = this->m_unit_gossipBinding.begin(); itr != m_unit_gossipBinding.end(); ++itr)
{
typedef HM_NAMESPACE::hash_map<uint32, LuaGossip*> GMAP;
GMAP & gMap = g_luaMgr.getUnitGossipInterfaceMap();
GMAP::iterator it = gMap.find(itr->first);
if(it == gMap.end())
{
GossipScript* gs = CreateLuaUnitGossipScript(itr->first);
if(gs != NULL)
{
sMgr->register_gossip_script(itr->first, gs);
gMap.insert(make_pair(itr->first, (LuaGossip*)NULL));
}
}
else
{
LuaGossip* u_gossip = it->second;
if(u_gossip != NULL)
u_gossip->m_unit_gossip_binding = &itr->second;
}
}
for(GossipItemScriptsBindingMap::iterator itr = this->m_item_gossipBinding.begin(); itr != m_item_gossipBinding.end(); ++itr)
{
typedef HM_NAMESPACE::hash_map<uint32, LuaGossip*> GMAP;
GMAP & gMap = g_luaMgr.getItemGossipInterfaceMap();
GMAP::iterator it = gMap.find(itr->first);
if(it == gMap.end())
{
GossipScript* gs = CreateLuaItemGossipScript(itr->first);
if(gs != NULL)
{
sMgr->register_item_gossip_script(itr->first, gs);
gMap.insert(make_pair(itr->first, (LuaGossip*)NULL));
}
}
else
{
LuaGossip* i_gossip = it->second;
if(i_gossip != NULL)
i_gossip->m_item_gossip_binding = &itr->second;
}
}
for(GossipGOScriptsBindingMap::iterator itr = this->m_go_gossipBinding.begin(); itr != m_go_gossipBinding.end(); ++itr)
{
typedef HM_NAMESPACE::hash_map<uint32, LuaGossip*> GMAP;
GMAP & gMap = g_luaMgr.getGameObjectGossipInterfaceMap();
GMAP::iterator it = gMap.find(itr->first);
if(it == gMap.end())
{
GossipScript* gs = CreateLuaGOGossipScript(itr->first);
if(gs != NULL)
{
sMgr->register_go_gossip_script(itr->first, gs);
gMap.insert(make_pair(itr->first, (LuaGossip*)NULL));
}
}
else
{
LuaGossip* g_gossip = it->second;
if(g_gossip != NULL)
g_gossip->m_go_gossip_binding = &itr->second;
}
}
/* BIG SERV HOOK CHUNK EEK */
RegisterHook(SERVER_HOOK_EVENT_ON_NEW_CHARACTER, Lua_HookOnNewCharacter);
RegisterHook(SERVER_HOOK_EVENT_ON_KILL_PLAYER, Lua_HookOnKillPlayer);
RegisterHook(SERVER_HOOK_EVENT_ON_FIRST_ENTER_WORLD, Lua_HookOnFirstEnterWorld);
RegisterHook(SERVER_HOOK_EVENT_ON_ENTER_WORLD, Lua_HookOnEnterWorld);
RegisterHook(SERVER_HOOK_EVENT_ON_GUILD_JOIN, Lua_HookOnGuildJoin);
RegisterHook(SERVER_HOOK_EVENT_ON_DEATH, Lua_HookOnDeath);
RegisterHook(SERVER_HOOK_EVENT_ON_REPOP, Lua_HookOnRepop);
RegisterHook(SERVER_HOOK_EVENT_ON_EMOTE, Lua_HookOnEmote);
RegisterHook(SERVER_HOOK_EVENT_ON_ENTER_COMBAT, Lua_HookOnEnterCombat);
RegisterHook(SERVER_HOOK_EVENT_ON_CAST_SPELL, Lua_HookOnCastSpell);
RegisterHook(SERVER_HOOK_EVENT_ON_TICK, Lua_HookOnTick);
RegisterHook(SERVER_HOOK_EVENT_ON_LOGOUT_REQUEST, Lua_HookOnLogoutRequest);
RegisterHook(SERVER_HOOK_EVENT_ON_LOGOUT, Lua_HookOnLogout);
RegisterHook(SERVER_HOOK_EVENT_ON_QUEST_ACCEPT, Lua_HookOnQuestAccept);
RegisterHook(SERVER_HOOK_EVENT_ON_ZONE, Lua_HookOnZone);
RegisterHook(SERVER_HOOK_EVENT_ON_CHAT, Lua_HookOnChat);
RegisterHook(SERVER_HOOK_EVENT_ON_LOOT, Lua_HookOnLoot);
RegisterHook(SERVER_HOOK_EVENT_ON_GUILD_CREATE, Lua_HookOnGuildCreate);
RegisterHook(SERVER_HOOK_EVENT_ON_FULL_LOGIN, Lua_HookOnEnterWorld2);
RegisterHook(SERVER_HOOK_EVENT_ON_CHARACTER_CREATE, Lua_HookOnCharacterCreate);
RegisterHook(SERVER_HOOK_EVENT_ON_QUEST_CANCELLED, Lua_HookOnQuestCancelled);
RegisterHook(SERVER_HOOK_EVENT_ON_QUEST_FINISHED, Lua_HookOnQuestFinished);
RegisterHook(SERVER_HOOK_EVENT_ON_HONORABLE_KILL, Lua_HookOnHonorableKill);
RegisterHook(SERVER_HOOK_EVENT_ON_ARENA_FINISH, Lua_HookOnArenaFinish);
RegisterHook(SERVER_HOOK_EVENT_ON_OBJECTLOOT, Lua_HookOnObjectLoot);
RegisterHook(SERVER_HOOK_EVENT_ON_AREATRIGGER, Lua_HookOnAreaTrigger);
RegisterHook(SERVER_HOOK_EVENT_ON_POST_LEVELUP, Lua_HookOnPostLevelUp);
RegisterHook(SERVER_HOOK_EVENT_ON_PRE_DIE, Lua_HookOnPreUnitDie);
RegisterHook(SERVER_HOOK_EVENT_ON_ADVANCE_SKILLLINE, Lua_HookOnAdvanceSkillLine);
RegisterHook(SERVER_HOOK_EVENT_ON_DUEL_FINISHED, Lua_HookOnDuelFinished);
RegisterHook(SERVER_HOOK_EVENT_ON_AURA_REMOVE, Lua_HookOnAuraRemove);
RegisterHook(SERVER_HOOK_EVENT_ON_RESURRECT, Lua_HookOnResurrect);
for(std::map<uint32, uint16>::iterator itr = m_luaDummySpells.begin(); itr != m_luaDummySpells.end(); ++itr)
{
if(find(g_luaMgr.HookInfo.dummyHooks.begin(), g_luaMgr.HookInfo.dummyHooks.end(), itr->first) == g_luaMgr.HookInfo.dummyHooks.end())
{
sMgr->register_dummy_spell(itr->first, &Lua_HookOnDummySpell);
g_luaMgr.HookInfo.dummyHooks.push_back(itr->first);
}
}
RELEASE_LOCK
g_engine->getcoLock().Release();
//hyper: do OnSpawns for spawned creatures.
vector<uint32> temp = OnLoadInfo;
OnLoadInfo.clear();
for(vector<uint32>::iterator itr = temp.begin(); itr != temp.end(); itr += 3)
{
//*itr = mapid; *(itr+1) = iid; *(itr+2) = lowguid
MapMgr* mgr = NULL;
if(*(itr + 1) == 0) //no instance
mgr = sInstanceMgr.GetMapMgr(*itr);
else
{
Instance* inst = sInstanceMgr.GetInstanceByIds(*itr, *(itr + 1));
if(inst != NULL)
mgr = inst->m_mapMgr;
}
if(mgr != NULL)
{
Creature* unit = mgr->GetCreature(*(itr + 2));
if(unit != NULL && unit->IsInWorld() && unit->GetScript() != NULL)
unit->GetScript()->OnLoad();
}
}
temp.clear();
Log.Notice("LuaEngineMgr", "Done restarting engine.");
}
void GameEventMgr::DoScript(uint32 event_id, uint32 sql_id, uint8 type, uint32 data1, uint32 data2, uint32 data3, char * say, uint32 mapid)
{
MapMgr * mapmgr = sInstanceMgr.GetMapMgr( mapid );
if( mapmgr == NULL )
return;
Creature *c;
GameObject *go;
if(type < GAMEOBJECT_CHANGE_STATE)
{
c = mapmgr->GetSqlIdCreature( sql_id );
if( c == NULL ) return;
}
else
{
go = mapmgr->GetSqlIdGameObject( sql_id );
if( go == NULL ) return;
}
// create backup for original values
EventScript * es = new EventScript();
es->sql_id = sql_id;
es->mapid = mapid;
es->type = type;
es->data_1 = 0; // null them out first!
es->data_2 = 0;
es->data_3 = 0;
if( c && strlen(say) )
{
c->SendChatMessage(CHAT_MSG_MONSTER_SAY, LANG_UNIVERSAL, say);
}
switch( type )
{
case CREATURE_CHANGE_SCRIPTED_CHANGE:
{
CALL_SCRIPT_EVENT(c, GameEventStart)(event_id);
} break;
case CREATURE_CHANGE_EMOTE:
{
// do not backup one-shoot emote
c->Emote(EmoteType(data1));
// backup emote state first
es->data_2 = c->GetEmoteState();
c->SetEmoteState(data2);
// backup stand state
es->data_3 = static_cast<uint32>(c->GetStandState());
c->SetStandState(static_cast<uint8>(data3));
} break;
case CREATURE_CHANGE_DISPLAYID:
{
es->data_1 = c->GetDisplayId();
c->SetDisplayId(data1);
es->data_2 = c->GetNativeDisplayId();
c->SetNativeDisplayId(data2);
es->data_3 = c->GetMount();
c->SetMount(data3);
c->EventModelChange();
} break;
case CREATURE_CHANGE_WEAPON:
{
es->data_1 = c->GetEquippedItem(MELEE);
es->data_2 = c->GetEquippedItem(OFFHAND);
es->data_3 = c->GetEquippedItem(RANGED);
c->SetEquippedItem(MELEE, data1);
c->SetEquippedItem(OFFHAND, data2);
c->SetEquippedItem(RANGED, data3);
} break;
case CREATURE_CHANGE_REACT:
{
es->data_1 = c->GetFaction();
c->SetFaction(data1);
es->data_2 = c->GetUInt32Value(UNIT_NPC_FLAGS);
c->SetUInt32Value(UNIT_NPC_FLAGS, data2);
es->data_3 = c->GetUInt32Value(UNIT_FIELD_FLAGS);
c->SetUInt32Value(UNIT_FIELD_FLAGS, data3);
} break;
case CREATURE_CAST_SPELL_ON_EVENT_START:
{
SpellEntry * sp = dbcSpell.LookupEntryForced( data1 );
if( sp == NULL )
return;
SpellCastTime * casttime = dbcSpellCastTime.LookupEntry(sp->CastingTimeIndex);
Spell * spell = sSpellFactoryMgr.NewSpell(c, sp, false, NULL);
SpellCastTargets t(0);
// force self casting
if( data2 )
{
t.m_unitTarget = c->GetGUID();
}
else
{
spell->GenerateTargets(&t);
spell->m_targets = t;
}
if (objmgr.IsSpellDisabled(spell->GetProto()->Id) || spell->CanCast(false) != SPELL_CANCAST_OK || !spell->HasPower() || c->m_silenced || c->IsStunned() || c->IsFeared() )
{
delete spell;
return;
}
if( casttime->CastTime > 0 )
c->GetAIInterface()->StopMovement(casttime->CastTime);
spell->prepare(&t);
} break;
case CREATURE_CAST_SPELL_ON_EVENT_STOP:
{
// this time just backup it, we will procez it on event end
es->data_1 = data1;
es->data_2 = data2;
} break;
case CREATURE_CHANGE_UPDATE_FIELD:
{
es->data_1 = data1;
es->data_2 = c->GetUInt32Value(data1);
c->SetUInt32Value(data1, data2);
} break;
case CREATURE_CHANGE_DESPAWN:
{
GameEventMap::iterator itr = CheckAndReturnEvent( event_id );
if( itr == m_GameEventMap.end() )
return;
uint32 current_time = mktime(&g_localTime);
// this is calculated in seconds and added 1 extra second as timer for spawn and despawn
uint32 respawntime = itr->second->end_time - current_time + 1;
// values here are in miliseconds
c->Despawn(0, respawntime*1000);
delete es;
return;
} break;
case GAMEOBJECT_CHANGE_STATE:
{
es->data_1 = (uint32)go->GetState();
go->SetState((uint8)data1);
} break;
}
// insert event into storage
GameEventScriptMap::iterator itr = m_GameEventScriptBackup.find(event_id);
if( itr == m_GameEventScriptBackup.end() )
{
set< EventScript* > s;
s.insert( es );
m_GameEventScriptBackup.insert(make_pair(event_id, s));
}
else
{
itr->second.insert( es );
}
}
void AIUpdate()
{
uint32 plrcounts[2] = { 0, 0 };
// details:
// loop through inrange players, for new ones, send the enable CP worldstate.
// the value of the map is a timestamp of the last update, to avoid cpu time wasted
// doing lookups of objects that have already been updated
itr = _gameobject->GetInRangePlayerSetBegin();
itrend = _gameobject->GetInRangePlayerSetEnd();
map<uint32, uint32>::iterator it2, it3;
uint32 timeptr = (uint32)UNIXTIME;
bool in_range;
bool is_valid;
Player* plr;
MapMgr* mgr = _gameobject->GetMapMgr();
for(; itr != itrend; ++itr)
{
plr = TO< Player* >(*itr);
if(!plr->IsPvPFlagged() || !(plr->isAlive()) && !(plr->IsStealth()) && !(plr->m_invisible) && !(plr->SchoolImmunityList[0]))
is_valid = false;
else
is_valid = true;
in_range = (_gameobject->GetDistance2dSq((*itr)) <= BANNER_RANGE);
it2 = StoredPlayers.find((*itr)->GetLowGUID());
if(it2 == StoredPlayers.end())
{
// new player :)
if(in_range)
{
plr->SendWorldStateUpdate(WORLDSTATE_TEROKKAR_PVP_CAPTURE_BAR_DISPLAY, 1);
plr->SendWorldStateUpdate(WORLDSTATE_TEROKKAR_PVP_CAPTURE_BAR_VALUE, Status);
StoredPlayers.insert(make_pair((*itr)->GetLowGUID(), timeptr));
if(is_valid)
plrcounts[(*itr)->GetTeam()]++;
}
}
else
{
// oldie
if(!in_range)
{
plr->SendWorldStateUpdate(WORLDSTATE_TEROKKAR_PVP_CAPTURE_BAR_DISPLAY, 0);
StoredPlayers.erase(it2);
}
else
{
plr->SendWorldStateUpdate(WORLDSTATE_TEROKKAR_PVP_CAPTURE_BAR_VALUE, Status);
it2->second = timeptr;
if(is_valid)
plrcounts[(*itr)->GetTeam()]++;
}
}
}
// handle stuff for the last tick
if(Status == 100 && m_bannerStatus != BANNER_STATUS_ALLIANCE)
{
m_bannerStatus = BANNER_STATUS_ALLIANCE;
SetArtKit();
// send message to everyone in the zone, has been captured by the Alliance
mgr->SendPvPCaptureMessage(ZONE_TEROKKAR_FOREST, ZONE_TEROKKAR_FOREST, "|cffffff00%s has been taken by the Alliance!|r", ControlPointName);
// tower update
TFg_allianceTowers++;
UpdateTowerCount();
// state update
mgr->GetWorldStatesHandler().SetWorldStateForZone(ZONE_TEROKKAR_FOREST, mgr->GetAreaID( _gameobject->GetPositionX(), _gameobject->GetPositionY() ), g_neutralStateFields[towerid], 0);
mgr->GetWorldStatesHandler().SetWorldStateForZone(ZONE_TEROKKAR_FOREST, mgr->GetAreaID( _gameobject->GetPositionX(), _gameobject->GetPositionY() ), g_allianceStateFields[towerid], 1);
// woot
TFg_towerOwners[towerid] = 1;
}
else if(Status == 0 && m_bannerStatus != BANNER_STATUS_HORDE)
{
m_bannerStatus = BANNER_STATUS_HORDE;
SetArtKit();
// send message to everyone in the zone, has been captured by the Horde
mgr->SendPvPCaptureMessage(ZONE_TEROKKAR_FOREST, ZONE_TEROKKAR_FOREST, "|cffffff00%s has been taken by the Horde!|r", ControlPointName);
// tower update
TFg_hordeTowers++;
UpdateTowerCount();
// state update
mgr->GetWorldStatesHandler().SetWorldStateForZone(ZONE_TEROKKAR_FOREST, mgr->GetAreaID( _gameobject->GetPositionX(), _gameobject->GetPositionY() ), g_neutralStateFields[towerid], 0);
mgr->GetWorldStatesHandler().SetWorldStateForZone(ZONE_TEROKKAR_FOREST, mgr->GetAreaID( _gameobject->GetPositionX(), _gameobject->GetPositionY() ), g_hordeStateFields[towerid], 1);
// woot
TFg_towerOwners[towerid] = 0;
}
else if(m_bannerStatus != BANNER_STATUS_NEUTRAL)
{
// if the difference for the faction is >50, change to neutral
if(m_bannerStatus == BANNER_STATUS_ALLIANCE && Status <= 50)
{
// send message: The Alliance has lost control of point xxx
m_bannerStatus = BANNER_STATUS_NEUTRAL;
SetArtKit();
TFg_allianceTowers--;
UpdateTowerCount();
mgr->SendPvPCaptureMessage(ZONE_TEROKKAR_FOREST, ZONE_TEROKKAR_FOREST, "|cffffff00The Alliance have lost control of %s!|r", ControlPointName);
// state update
mgr->GetWorldStatesHandler().SetWorldStateForZone(ZONE_TEROKKAR_FOREST, mgr->GetAreaID( _gameobject->GetPositionX(), _gameobject->GetPositionY() ), g_allianceStateFields[towerid], 0);
mgr->GetWorldStatesHandler().SetWorldStateForZone(ZONE_TEROKKAR_FOREST, mgr->GetAreaID( _gameobject->GetPositionX(), _gameobject->GetPositionY() ), g_neutralStateFields[towerid], 1);
// woot
TFg_towerOwners[towerid] = -1;
}
else if(m_bannerStatus == BANNER_STATUS_HORDE && Status >= 50)
{
// send message: The Alliance has lost control of point xxx
m_bannerStatus = BANNER_STATUS_NEUTRAL;
SetArtKit();
TFg_hordeTowers--;
UpdateTowerCount();
mgr->SendPvPCaptureMessage(ZONE_TEROKKAR_FOREST, ZONE_TEROKKAR_FOREST, "|cffffff00The Horde have lost control of %s!|r", ControlPointName);
// state update
mgr->GetWorldStatesHandler().SetWorldStateForZone(ZONE_TEROKKAR_FOREST, mgr->GetAreaID( _gameobject->GetPositionX(), _gameobject->GetPositionY() ), g_hordeStateFields[towerid], 0);
mgr->GetWorldStatesHandler().SetWorldStateForZone(ZONE_TEROKKAR_FOREST, mgr->GetAreaID( _gameobject->GetPositionX(), _gameobject->GetPositionY() ), g_neutralStateFields[towerid], 1);
// woot
TFg_towerOwners[towerid] = -1;
}
}
// send any out of range players the disable flag
for(it2 = StoredPlayers.begin(); it2 != StoredPlayers.end();)
{
it3 = it2;
++it2;
if(it3->second != timeptr)
{
plr = _gameobject->GetMapMgr()->GetPlayer(it3->first);
// they WILL be out of range at this point. this is guaranteed. means they left the set rly quickly.
if(plr)
plr->SendWorldStateUpdate(WORLDSTATE_TEROKKAR_PVP_CAPTURE_BAR_DISPLAY, 0);
StoredPlayers.erase(it3);
}
}
// work out current status for next tick
uint32 delta;
if(plrcounts[0] > plrcounts[1])
{
delta = plrcounts[0] - plrcounts[1];
delta *= CAPTURE_RATE;
// cap it at 25 so the banner always gets removed.
if(delta > 25)
delta = 25;
Status += delta;
if(Status >= 100)
Status = 100;
}
else if(plrcounts[1] > plrcounts[0])
{
delta = plrcounts[1] - plrcounts[0];
delta *= CAPTURE_RATE;
// cap it at 25 so the banner always gets removed.
if(delta > 25)
delta = 25;
if(delta > Status)
Status = 0;
else
Status -= delta;
}
}
bool WorldCreator::CheckInstanceForObject(Object *obj, MapInfo *pMapinfo)
{
WorldPacket data(4);
Player *_player = NULL;
if(obj->GetTypeId() == TYPEID_PLAYER)
{
_player = static_cast<Player*>(obj);
}
if(pMapinfo && _player)
{
switch(pMapinfo->type)
{
case INSTANCE_NONRAID:
case INSTANCE_RAID:
case INSTANCE_MULTIMODE:
{
//instance creation detection types
//case 1, player is inside a group aka not soloing
//onoes: leader can be inside a instance already and make a group or its a fresh group, noone inside
if(_player->InGroup()) //group created, join leader instance.
{
Group *pGroup = _player->GetGroup();
if(pGroup)
{
//check if instance already exists(player solo created instance and made group after)
MapMgr *pInstance = sWorldCreator.GetInstanceByGroup(pGroup, _player, pMapinfo);
if(pInstance)
{
//INSTANCE_OK
if(pInstance->IsCombatInProgress())
{
WorldPacket msg;
msg.Initialize(SMSG_AREA_TRIGGER_MESSAGE);
msg << uint32(0) << "Encounter in progress." << uint8(0) << uint8(0);
_player->GetSession()->SendPacket(&msg);
return false;
}
if(pInstance->GetPlayerCount() >= pMapinfo->playerlimit)
{
data.Initialize(SMSG_TRANSFER_ABORTED);
data << uint32(INSTANCE_ABORT_FULL);
_player->GetSession()->SendPacket(&data);
return false;
}
_player->SetInstanceID(pInstance->GetInstanceID());
}
else
{
//group leader didnt made any instance yet, create instance for this group.
uint32 id = sWorldCreator.CreateInstance(pGroup, pGroup->GetLeader(), pMapinfo->mapid);
// again, NULL might not be 0
//if(id != NULL)
if(id != 0)
{
//INSTANCE CREATED
_player->SetInstanceID(id);
}
else
{
data.Initialize(SMSG_TRANSFER_ABORTED);
data << uint32(INSTANCE_ABORT_ERROR);
_player->GetSession()->SendPacket(&data);
return false;
}
}
}
else
{
data.Initialize(SMSG_TRANSFER_ABORTED);
data << uint32(INSTANCE_ABORT_ERROR);
_player->GetSession()->SendPacket(&data);
return false;
}
}
else
{
MapMgr *pInstance = sWorldCreator.GetInstanceByCreator(_player, pMapinfo);
if(pInstance)
{
//INSTANCE_OK
if(pInstance->IsCombatInProgress())
{
WorldPacket msg;
msg.Initialize(SMSG_AREA_TRIGGER_MESSAGE);
msg << uint32(0) << "Encounter in progress." << uint8(0) << uint8(0);
_player->GetSession()->SendPacket(&msg);
return false;
}
if(pInstance->GetPlayerCount() >= pMapinfo->playerlimit)
{
data.Initialize(SMSG_TRANSFER_ABORTED);
data << uint32(INSTANCE_ABORT_FULL);
_player->GetSession()->SendPacket(&data);
return false;
}
_player->SetInstanceID(pInstance->GetInstanceID());
}
else
{
uint32 id2 = sWorldCreator.CreateInstance(NULL, _player, pMapinfo->mapid);
//if(id2 != NULL)
if(id2 != 0)
{
_player->SetInstanceID(id2);
}
else
{
data.Initialize(SMSG_TRANSFER_ABORTED);
data << uint32(INSTANCE_ABORT_ERROR);
_player->GetSession()->SendPacket(&data);
return false;
}
}
}
}break;
}
}
return true;
}
void
World::Update(time_t diff)
{
_UpdateGameTime();
for(int i = 0; i < WUPDATE_COUNT; ++i)
m_timers[i].Update(diff);
// TODO: make sure that all objects get their updates, not just characters and creatures
if (m_timers[WUPDATE_OBJECTS].Passed())
{
m_timers[WUPDATE_OBJECTS].Reset();
ObjectMgr::PlayerMap::iterator chriter;
for( chriter = objmgr.Begin<Player>(); chriter != objmgr.End<Player>( ); ++ chriter )
chriter->second->Update( (uint32)diff );
// Update creatures and gameobjects in active map cells
//
MapMgr *mapm;
for (int mapid = 0; mapid<=1; ++mapid)
{
if(isMapId(mapid))
{
mapm = sWorld.GetMap (mapid);
mapm->UpdateActiveObjects ((uint32)diff);
}
}
// Update dynamic objects (spell visual effects)
//
ObjectMgr::DynamicObjectMap::iterator diter;
for( diter = objmgr.Begin<DynamicObject>(); diter != objmgr.End<DynamicObject>( ); ++ diter )
diter->second->Update( (uint32)diff );
}
if (m_timers[WUPDATE_SESSIONS].Passed())
{
m_timers[WUPDATE_SESSIONS].Reset();
SessionMap::iterator itr, next;
for (itr = m_sessions.begin(); itr != m_sessions.end(); itr = next)
{
next = itr;
++next;
if(!itr->second->Update((uint32)diff))
{
ZThread::Guard<ZThread::Mutex> guard(m_sessions_lock);
delete itr->second;
m_sessions.erase(itr);
}
}
}
if (m_timers[WUPDATE_AUCTIONS].Passed())
{
m_timers[WUPDATE_AUCTIONS].Reset();
ObjectMgr::AuctionEntryMap::iterator itr,next;
for (itr = objmgr.GetAuctionsBegin(); itr != objmgr.GetAuctionsEnd();itr = next)
{
next = itr;
++next;
if (time(NULL) > (itr->second->time))
{
if (itr->second->bidder == 0)
{
Mail *m = new Mail;
m->reciever = itr->second->owner;
m->body = "";
m->sender = itr->second->owner;
m->checked = 0;
m->COD = 0;
m->messageID = objmgr.GenerateMailID();
m->money = 0;
m->time = time(NULL) + (29 * 3600);
m->subject = "Your item failed to sell";
m->item = itr->second->item;
Item *it = objmgr.GetAItem(m->item);
objmgr.AddMItem(it);
std::stringstream ss;
ss << "INSERT INTO mailed_items (guid, data) VALUES ("
<< it->GetGUIDLow() << ", '";
for(uint16 i = 0; i < it->GetValuesCount(); ++i )
{
ss << it->GetUInt32Value(i) << " ";
}
ss << "' )";
sDatabase.Execute( ss.str().c_str() );
std::stringstream md;
md << "DELETE FROM mail WHERE mailID = " << m->messageID;
sDatabase.Execute( md.str().c_str( ) );
std::stringstream mi;
mi << "INSERT INTO mail (mailId,sender,reciever,subject,body,item,"
"time,money,COD,checked) VALUES ( " << m->messageID << ", "
<< m->sender << ", " << m->reciever << ",' " << m->subject.c_str()
<< "' ,' " << m->body.c_str() << "', " << m->item << ", "
<< (uint32)m->time << ", " << m->money << ", " << 0 << ", "
<< m->checked << " )";
sDatabase.Execute( mi.str().c_str( ) );
uint64 rcpl;
GUID_LOPART(rcpl) = m->reciever;
GUID_HIPART(rcpl) = 0;
std::string pname;
objmgr.GetPlayerNameByGUID(rcpl,pname);
Player *rpl = objmgr.GetPlayer(pname.c_str());
if (rpl)
{
rpl->AddMail(m);
}
std::stringstream delinvq;
std::stringstream id;
std::stringstream bd;
delinvq << "DELETE FROM auctionhouse WHERE itemowner = " << m->reciever;
sDatabase.Execute( delinvq.str().c_str( ) );
id << "DELETE FROM auctioned_items WHERE guid = " << m->item;
sDatabase.Execute( id.str().c_str( ) );
bd << "DELETE FROM bids WHERE Id = " << itr->second->Id;
sDatabase.Execute( bd.str().c_str( ) );
objmgr.RemoveAuction(itr->second->Id);
}
else
{
Mail *m = new Mail;
m->reciever = itr->second->owner;
m->body = "";
m->sender = itr->second->bidder;
m->checked = 0;
m->COD = 0;
m->messageID = objmgr.GenerateMailID();
m->money = itr->second->bid;
m->time = time(NULL) + (29 * 3600);
m->subject = "Your item sold!";
m->item = 0;
std::stringstream md;
md << "DELETE FROM mail WHERE mailID = " << m->messageID;
sDatabase.Execute( md.str().c_str( ) );
std::stringstream mi;
mi << "INSERT INTO mail (mailId,sender,reciever,subject,body,item,"
"time,money,COD,checked) VALUES ( " << m->messageID << ", " << m->sender
<< ", " << m->reciever << ",' " << m->subject.c_str() << "' ,' "
<< m->body.c_str() << "', " << m->item << ", " << (uint32)m->time
<< ", " << m->money << ", " << 0 << ", " << m->checked << " )";
sDatabase.Execute( mi.str().c_str( ) );
uint64 rcpl;
GUID_LOPART(rcpl) = m->reciever;
GUID_HIPART(rcpl) = 0;
std::string pname;
objmgr.GetPlayerNameByGUID(rcpl,pname);
Player *rpl = objmgr.GetPlayer(pname.c_str());
if (rpl)
{
rpl->AddMail(m);
}
Mail *mn = new Mail;
mn->reciever = itr->second->bidder;
mn->body = "";
mn->sender = itr->second->owner;
mn->checked = 0;
mn->COD = 0;
mn->messageID = objmgr.GenerateMailID();
mn->money = 0;
mn->time = time(NULL) + (29 * 3600);
mn->subject = "Your won an item!";
mn->item = itr->second->item;
Item *it = objmgr.GetAItem(itr->second->item);
objmgr.AddMItem(it);
std::stringstream ss;
ss << "INSERT INTO mailed_items (guid, data) VALUES ("
<< it->GetGUIDLow() << ", '";
for(uint16 i = 0; i < it->GetValuesCount(); ++i )
{
ss << it->GetUInt32Value(i) << " ";
}
ss << "' )";
sDatabase.Execute( ss.str().c_str() );
std::stringstream mdn;
mdn << "DELETE FROM mail WHERE mailID = " << mn->messageID;
sDatabase.Execute( mdn.str().c_str( ) );
std::stringstream min;
min << "INSERT INTO mail (mailId,sender,reciever,subject,body,"
"item,time,money,COD,checked) VALUES ( "
<< mn->messageID << ", " << mn->sender << ", " << mn->reciever
<< ",' " << mn->subject.c_str() << "' ,' " << mn->body.c_str()
<< "', " << mn->item << ", " << (uint32)mn->time << ", "
<< mn->money << ", " << 0 << ", " << mn->checked << " )";
sDatabase.Execute( min.str().c_str( ) );
uint64 rcpl1;
GUID_LOPART(rcpl1) = mn->reciever;
GUID_HIPART(rcpl1) = 0;
std::string pname1;
objmgr.GetPlayerNameByGUID(rcpl1,pname1);
Player *rpl1 = objmgr.GetPlayer(pname1.c_str());
if (rpl1)
{
rpl1->AddMail(mn);
}
objmgr.RemoveAItem(itr->second->item);
objmgr.RemoveAuction(itr->second->Id);
}
}
}
}
if (m_Warden_Timer <= 0)
{
m_Warden_Timer = 720;
ZThread::Guard<ZThread::Mutex> guard(m_sessions_lock);
WorldPacket WardenPkt;
sLog.outDetail("Initializing Full Warden Scan");
WardenPkt.Initialize(SMSG_WARDEN_DATA);
SessionMap::iterator itr;
for (itr = m_sessions.begin(); itr != m_sessions.end(); ++itr)
{
itr->second->SendPacket(&WardenPkt);
}
}
for (MapMgrMap::iterator iter = m_maps.begin(); iter != m_maps.end(); ++iter)
{
iter->second->Update(diff);
}
// When everything is safe, wipe recycles
objmgr.WipeRecycles();
}
void GameEventMgr::ScriptedBackToOrig(uint32 event_id)
{
GameEventScriptMap::iterator event_backup = m_GameEventScriptBackup.find(event_id);
if( event_backup == m_GameEventScriptBackup.end() )
return;
set<EventScript*>::iterator itr = event_backup->second.begin();
for( itr; itr != event_backup->second.end(); itr++ )
{
uint32 mapid = (*itr)->mapid;
uint32 sql_id = (*itr)->sql_id;
uint8 type = (*itr)->type;
uint32 data1 = (*itr)->data_1;
uint32 data2 = (*itr)->data_2;
uint32 data3 = (*itr)->data_3;
MapMgr * mapmgr = sInstanceMgr.GetMapMgr( mapid );
if( mapmgr == NULL )
return;
Creature *c;
GameObject *go;
if(type < GAMEOBJECT_CHANGE_STATE)
{
c = mapmgr->GetSqlIdCreature( sql_id );
if( c == NULL ) return;
}
else
{
go = mapmgr->GetSqlIdGameObject( sql_id );
if( go == NULL ) return;
}
switch( type )
{
case CREATURE_CHANGE_SCRIPTED_CHANGE:
{
CALL_SCRIPT_EVENT(c, GameEventFinish)(event_id);
} break;
case CREATURE_CHANGE_EMOTE:
{
c->Emote(EmoteType(data1));
c->SetEmoteState(data2);
c->SetStandState(static_cast<uint8>(data3));
} break;
case CREATURE_CHANGE_DISPLAYID:
{
c->SetDisplayId(data1);
c->SetNativeDisplayId(data2);
c->SetMount(data3);
c->EventModelChange();
} break;
case CREATURE_CHANGE_WEAPON:
{
c->SetEquippedItem(MELEE, data1);
c->SetEquippedItem(OFFHAND, data2);
c->SetEquippedItem(RANGED, data3);
} break;
case CREATURE_CHANGE_REACT:
{
c->SetFaction(data1);
c->SetUInt32Value(UNIT_NPC_FLAGS, data2);
c->SetUInt32Value(UNIT_FIELD_FLAGS, data3);
} break;
case CREATURE_CAST_SPELL_ON_EVENT_STOP:
{
SpellEntry * sp = dbcSpell.LookupEntryForced( data1 );
if( sp == NULL )
return;
SpellCastTime * casttime = dbcSpellCastTime.LookupEntry(sp->CastingTimeIndex);
Spell * spell = sSpellFactoryMgr.NewSpell(c, sp, false, NULL);
SpellCastTargets t(0);
// force self casting
if( data2 )
{
t.m_unitTarget = c->GetGUID();
}
else
{
spell->GenerateTargets(&t);
spell->m_targets = t;
}
if (objmgr.IsSpellDisabled(spell->GetProto()->Id) || spell->CanCast(false) != SPELL_CANCAST_OK || !spell->HasPower() || c->m_silenced || c->IsStunned() || c->IsFeared() )
{
delete spell;
return;
}
if( casttime->CastTime > 0 )
c->GetAIInterface()->StopMovement(casttime->CastTime);
spell->prepare(&t);
} break;
case CREATURE_CHANGE_UPDATE_FIELD:
{
c->SetUInt32Value(data1, data2);
} break;
case GAMEOBJECT_CHANGE_STATE:
{
go->SetState((uint8)data1);
} break;
}
}
m_GameEventScriptBackup.erase(event_id);
}
bool ChatHandler::HandleDeleteCommand(const char* args, WorldSession *m_session)
{
uint64 guid = m_session->GetPlayer()->GetSelection();
if (guid == 0)
{
SystemMessage(m_session, "No selection.");
return true;
}
Creature* unit = NULL;
if(m_session->GetPlayer()->GetMapMgr()->GetVehicle(GET_LOWGUID_PART(guid)))
unit = m_session->GetPlayer()->GetMapMgr()->GetVehicle(GET_LOWGUID_PART(guid));
else
unit = m_session->GetPlayer()->GetMapMgr()->GetCreature(GET_LOWGUID_PART(guid));
if(!unit)
{
SystemMessage(m_session, "You should select a creature.");
return true;
}
if( unit->m_spawn != NULL && !m_session->CanUseCommand('z') )
{
SystemMessage(m_session, "You do not have permission to do that. Please contact higher staff for removing of saved spawns.");
return true;
}
if(unit->GetAIInterface())
unit->GetAIInterface()->StopMovement(10000);
if(unit->IsVehicle())
{
Vehicle* veh = TO_VEHICLE(unit);
for(int i = 0; i < 8; i++)
{
if(!veh->GetPassenger(i))
continue;
// Remove any players
if(veh->GetPassenger(i)->IsPlayer())
veh->RemovePassenger(veh->GetPassenger(i));
else // Remove any units.
veh->GetPassenger(i)->RemoveFromWorld(true);
}
}
sGMLog.writefromsession(m_session, "used npc delete, sqlid %u, creature %s, pos %f %f %f",
unit->m_spawn ? unit->m_spawn : 0, unit->GetCreatureInfo() ? unit->GetCreatureInfo()->Name : "wtfbbqhax", unit->GetPositionX(), unit->GetPositionY(),
unit->GetPositionZ());
BlueSystemMessage(m_session, "Deleted creature ID %u", unit->spawnid);
MapMgr* unitMgr = unit->GetMapMgr();
unit->DeleteFromDB();
if(!unit->IsInWorld())
return true;
if(unit->m_spawn)
{
uint32 cellx=float2int32(((_maxX-unit->m_spawn->x)/_cellSize));
uint32 celly=float2int32(((_maxY-unit->m_spawn->y)/_cellSize));
if(cellx <= _sizeX && celly <= _sizeY && unitMgr != NULL)
{
CellSpawns * c = unitMgr->GetBaseMap()->GetSpawnsList(cellx, celly);
if( c != NULL )
{
CreatureSpawnList::iterator itr, itr2;
for(itr = c->CreatureSpawns.begin(); itr != c->CreatureSpawns.end();)
{
itr2 = itr;
++itr;
if((*itr2) == unit->m_spawn)
{
c->CreatureSpawns.erase(itr2);
delete unit->m_spawn;
break;
}
}
}
}
}
unit->RemoveFromWorld(false,true);
if(unit->IsVehicle())
TO_VEHICLE(unit)->Destructor();
else
unit->Destructor();
return true;
}
void WorldSession::_HandleAreaTriggerOpcode(uint32 id)
{
sLog.outDebug("AreaTrigger: %u", id);
WorldPacket data(80);
AreaTrigger * pAreaTrigger = AreaTriggerStorage.LookupEntry(id);
// Search quest log, find any exploration quests
sQuestMgr.OnPlayerExploreArea(GetPlayer(),id);
// if in BG handle is triggers
if(GetPlayer()->m_bgInBattleground && GetPlayer()->GetCurrentBattleground() != NULL)
{
GetPlayer()->GetCurrentBattleground()->HandleBattlegroundAreaTrigger(GetPlayer(), id);
return;
}
if(GetPermissionCount())
{
sChatHandler.BlueSystemMessage(this, "[%sSystem%s] |rEntered areatrigger: %s%u.", MSG_COLOR_WHITE, MSG_COLOR_LIGHTBLUE,
MSG_COLOR_SUBWHITE, id);
}
/* if we don't have an areatrigger, create one on the stack to use for gm scripts :p */
if(!pAreaTrigger)
{
AreaTrigger tmpTrigger;
tmpTrigger.AreaTriggerID = id;
ScriptSystem->OnActivateAreaTrigger(&tmpTrigger, _player);
return;
}
/* script prerequsites */
if(ScriptSystem->OnActivateAreaTrigger(pAreaTrigger, _player) == false)
return;
if(pAreaTrigger->Type == ATTYPE_BATTLEGROUND)
{
if(pAreaTrigger->Mapid == 489) // hack fix
pAreaTrigger->Mapid = 2;
else if(pAreaTrigger->Mapid == 529)
pAreaTrigger->Mapid = 3;
else if(pAreaTrigger->Mapid == 30)
pAreaTrigger->Mapid = 1;
WorldPacket *pkt = sBattlegroundMgr.BuildBattlegroundListPacket(GetPlayer()->GetGUID(), _player,
pAreaTrigger->Mapid);
SendPacket(pkt);
delete pkt;
return;
}
bool bFailedPre = false;
std::string failed_reason;
if(pAreaTrigger->required_level)
{
if(GetPlayer()->getLevel() < pAreaTrigger->required_level)
{
bFailedPre = true;
if(failed_reason.size() > 0)
failed_reason += ", and ";
else
failed_reason = "You must be ";
// mm hacky
char lvltext[30];
snprintf(lvltext, 30, "at least level %d", (int)pAreaTrigger->required_level);
failed_reason += lvltext;
}
}
if(bFailedPre)
{
failed_reason += " before you're allowed through here.";
WorldPacket msg;
msg.Initialize(SMSG_AREA_TRIGGER_MESSAGE);
msg << uint32(0) << failed_reason << uint8(0);
SendPacket(&msg);
sLog.outDebug("Player %s failed areatrigger prereq - %s", GetPlayer()->GetName(), failed_reason.c_str());
return;
}
switch(pAreaTrigger->Type)
{
case ATTYPE_INSTANCE:
{
if(GetPlayer()->GetPlayerStatus() != TRANSFER_PENDING) //only ports if player is out of pendings
{
GetPlayer()->SaveEntryPoint(pAreaTrigger->Mapid);
//death system check.
Corpse *pCorpse = NULL;
// CorpseData *pCorpseData = NULL;
MapInfo *pMapinfo = NULL;
pMapinfo = WorldMapInfoStorage.LookupEntry(pAreaTrigger->Mapid);
if(pMapinfo && !pMapinfo->HasFlag(WMI_INSTANCE_ENABLED))
{
WorldPacket msg;
msg.Initialize(SMSG_AREA_TRIGGER_MESSAGE);
msg << uint32(0) << "This instance is currently unavailable." << uint8(0) << uint8(0);
SendPacket(&msg);
return;
}
if(pMapinfo && pMapinfo->HasFlag(WMI_INSTANCE_XPACK_01) && !HasFlag(ACCOUNT_FLAG_XPACK_01))
{
WorldPacket msg;
msg.Initialize(SMSG_BROADCAST_MSG);
msg << uint32(3) << "You must have The Burning Crusade Expansion to access this content." << uint8(0);
SendPacket(&msg);
return;
}
if(pMapinfo && pMapinfo->type != INSTANCE_MULTIMODE && GetPlayer()->iInstanceType == MODE_HEROIC && pMapinfo->type != INSTANCE_NULL)
{
WorldPacket msg;
msg.Initialize(SMSG_AREA_TRIGGER_MESSAGE);
msg << uint32(0) << "Heroic mode is not available for this instance." << uint8(0) << uint8(0);
SendPacket(&msg);
return;
}
if(pMapinfo && pMapinfo->type == INSTANCE_RAID && GetPlayer()->InGroup() && GetPlayer()->GetGroup()->GetGroupType() != GROUP_TYPE_RAID)
{
WorldPacket msg;
msg.Initialize(SMSG_AREA_TRIGGER_MESSAGE);
msg << uint32(0) << "You need to be in a raid group to be able to enter this instance." << uint8(0) << uint8(0);
SendPacket(&msg);
return;
}
if(pMapinfo && pMapinfo->type == INSTANCE_RAID && !GetPlayer()->InGroup())
{
WorldPacket msg;
msg.Initialize(SMSG_AREA_TRIGGER_MESSAGE);
msg << uint32(0) << "You need to be in a raid group to be able to enter this instance." << uint8(0) << uint8(0);
SendPacket(&msg);
return;
}
if(pMapinfo && pMapinfo->required_quest && !_player->HasFinishedQuest(pMapinfo->required_quest))
{
WorldPacket msg;
msg.Initialize(SMSG_AREA_TRIGGER_MESSAGE);
msg << uint32(0) << "You do not have the required attunement to enter this instance.";
SendPacket(&msg);
return;
}
if(pMapinfo && pMapinfo->required_item && !_player->GetItemInterface()->GetItemCount(pMapinfo->required_item, true))
{
WorldPacket msg;
msg.Initialize(SMSG_AREA_TRIGGER_MESSAGE);
msg << uint32(0) << "You do not have the required attunement to enter this instance.";
SendPacket(&msg);
return;
}
if(!GetPlayer()->isAlive())
{
pCorpse = objmgr.GetCorpseByOwner(GetPlayer()->GetGUIDLow());
if(pCorpse)
{
pMapinfo = WorldMapInfoStorage.LookupEntry(pCorpse->GetMapId());
if(pMapinfo)
{
if(GetPlayer()->InGroup())
{
MapMgr * groupinstance = sWorldCreator.GetInstanceByGroup(GetPlayer()->GetGroup(), GetPlayer(), pMapinfo);
if (groupinstance)
{
if(groupinstance->GetPlayerCount() >= pMapinfo->playerlimit)
{
data.Initialize(SMSG_TRANSFER_ABORTED);
data << uint32(INSTANCE_ABORT_FULL);
_player->GetSession()->SendPacket(&data);
GetPlayer()->RepopAtGraveyard(GetPlayer()->GetPositionX(),GetPlayer()->GetPositionY(),GetPlayer()->GetPositionZ(), GetPlayer()->GetMapId());
GetPlayer()->ResurrectPlayer();
return;
}
}
}
//if its a raid instance and corpse is inside and player is not in a group, ressurect
if(pMapinfo->type != INSTANCE_NULL && pMapinfo->type != INSTANCE_PVP && pMapinfo->type != INSTANCE_NONRAID && pMapinfo->type != INSTANCE_MULTIMODE && GetPlayer()->GetMapId() != pCorpse->GetMapId() && pCorpse->GetMapId() == pAreaTrigger->Mapid && !GetPlayer()->InGroup())
{
GetPlayer()->ResurrectPlayer();
return;
}
//if its a instance and player is trying to enter when corpse is on a diferent instance, repop back
else if(pMapinfo->type != INSTANCE_NULL && pMapinfo->type != INSTANCE_PVP && pCorpse->GetMapId() != pAreaTrigger->Mapid)
{
GetPlayer()->RepopAtGraveyard(GetPlayer()->GetPositionX(),GetPlayer()->GetPositionY(),GetPlayer()->GetPositionZ(), GetPlayer()->GetMapId());
return;
}
}
}
else
{
GetPlayer()->RepopAtGraveyard(GetPlayer()->GetPositionX(),GetPlayer()->GetPositionY(),GetPlayer()->GetPositionZ(),GetPlayer()->GetMapId());
return;
}
}
bool result = sWorldCreator.CheckInstanceForObject(static_cast<Object*>(GetPlayer()), pMapinfo);
if(result)
{
GetPlayer()->SaveEntryPoint(pAreaTrigger->Mapid);
GetPlayer()->SafeTeleport(pAreaTrigger->Mapid, 0, LocationVector(pAreaTrigger->x, pAreaTrigger->y, pAreaTrigger->z, pAreaTrigger->o));
}
}
}break;
case ATTYPE_QUESTTRIGGER:
{
}break;
case ATTYPE_INN:
{
// Inn
if (!GetPlayer()->m_isResting) GetPlayer()->ApplyPlayerRestState(true);
}break;
case ATTYPE_TELEPORT:
{
if(GetPlayer()->GetPlayerStatus() != TRANSFER_PENDING) //only ports if player is out of pendings
{
GetPlayer()->SaveEntryPoint(pAreaTrigger->Mapid);
GetPlayer()->SafeTeleport(pAreaTrigger->Mapid, 0, LocationVector(pAreaTrigger->x, pAreaTrigger->y, pAreaTrigger->z, pAreaTrigger->o));
}
}break;
case ATTYPE_NULL:
{
MapInfo *pMapinfo = NULL;
pMapinfo = WorldMapInfoStorage.LookupEntry(pAreaTrigger->Mapid);
if(pMapinfo && pMapinfo->HasFlag(WMI_INSTANCE_XPACK_01) && !HasFlag(ACCOUNT_FLAG_XPACK_01))
{
WorldPacket msg;
msg.Initialize(SMSG_BROADCAST_MSG);
msg << uint32(3) << "You must have The Burning Crusade Expansion to access this content." << uint8(0);
SendPacket(&msg);
return;
}
}
default:break;
}
}
void GameEventMgr::ProcessObjectsAndScriptsProc(QueryResultVector & results, uint32 id)
{
// process scripts
if(QueryResult *query = results[0].result)
{
do
{
Field * f = query->Fetch();
uint32 mapid = f[1].GetUInt32();
uint32 sql_id = f[2].GetUInt32();
uint8 type = f[3].GetUInt8();
uint32 data1 = f[4].GetUInt32();
uint32 data2 = f[5].GetUInt32();
uint32 data3 = f[6].GetUInt32();
char * say = strdup(f[7].GetString());
DoScript(id, sql_id, type, data1, data2, data3, say, mapid);
}
while(query->NextRow());
}
// waypoints -- the created objects will be deleted automatically by creature class on despawn
std::map<uint32, std::map<uint32, std::list<WayPoint *>>> waypoints;
if(QueryResult *query = results[1].result)
{
do
{
Field * f = query->Fetch();
WayPoint *wp = new WayPoint;
//uint32 event = f[0].GetUInt32();
uint32 spawnid = f[1].GetUInt32();
wp->id = f[2].GetUInt32();
wp->x = f[3].GetFloat();
wp->y = f[4].GetFloat();
wp->z = f[5].GetFloat();
wp->waittime = f[6].GetUInt32();
wp->flags = f[7].GetUInt32();
wp->forwardemoteoneshot = f[8].GetBool();
wp->forwardemoteid = f[9].GetUInt32();
wp->backwardemoteoneshot = f[10].GetBool();
wp->backwardemoteid = f[11].GetUInt32();
wp->forwardskinid = f[12].GetUInt32();
wp->backwardskinid = f[13].GetUInt32();
waypoints[id][spawnid].push_back(wp);
}
while(query->NextRow());
}
// creature spawns
if(QueryResult *query = results[2].result)
{
do
{
Field * f = query->Fetch();
CreatureSpawn spawn;
//uint32 event = f[0].GetUInt32();
uint32 spawn_id = f[1].GetUInt32();
spawn.id = 0;
spawn.entry = f[2].GetUInt32();
uint32 mapid = f[3].GetUInt32();
spawn.x = f[4].GetFloat();
spawn.y = f[5].GetFloat();
spawn.z = f[6].GetFloat();
spawn.o = f[7].GetFloat();
spawn.form = NULL;
spawn.movetype = f[8].GetUInt8();
spawn.displayid = f[9].GetUInt32();
spawn.factionid = f[10].GetUInt32();
spawn.flags = f[11].GetUInt32();
spawn.bytes0 = f[12].GetUInt32();
spawn.bytes1 = f[13].GetUInt32();
spawn.bytes2 = f[14].GetUInt32();
spawn.emote_state = f[15].GetUInt32();
//uint32 npc_respawn_link = f[17].GetUInt32();
spawn.channel_spell = f[17].GetUInt16();
spawn.channel_target_go = f[18].GetUInt32();
spawn.channel_target_creature = f[19].GetUInt32();
spawn.stand_state = f[20].GetUInt16();
spawn.death_state = f[21].GetUInt32();
spawn.MountedDisplayID = f[22].GetUInt32();
spawn.Item1SlotDisplay = f[23].GetUInt32();
spawn.Item2SlotDisplay = f[24].GetUInt32();
spawn.Item3SlotDisplay = f[25].GetUInt32();
spawn.CanFly = f[26].GetUInt32();
spawn.phase = f[27].GetUInt32();
if(spawn.phase == 0) spawn.phase = 0xFFFFFFFF;
CreatureProto* proto = CreatureProtoStorage.LookupEntry(spawn.entry);
CreatureInfo* info = CreatureNameStorage.LookupEntry(spawn.entry);
if(proto == NULL || info == NULL)
{
continue;
}
// get mapmgr for spawn
MapMgr * mgr = sInstanceMgr.GetMapMgr(mapid);
if(mgr == NULL)
{
// So this is a really interesting situation!
Log.Success("GameEvent","Failed to spawn creature spawn %u for event %u on nonexistant map %u", spawn.id, id, mapid);
continue;
}
// spawn the creature
//Creature * crt = mgr->GetInterface()->SpawnCreature(&spawn, true);
Creature * crt = mgr->CreateCreature(spawn.entry);
if(crt == NULL)
{
// we didnt succeed creating the creature! Print a warning and go on
Log.Success("GameEvent","Failed to spawn creature spawn %u for event %u", spawn.id, id);
continue;
}
crt->Load(&spawn, 0, mgr->GetMapInfo());
crt->spawnid = 0;
crt->m_spawn = NULL;
// add waypoints
crt->m_custom_waypoint_map = new WayPointMap();
for(std::list<WayPoint *>::iterator itr = waypoints[id][spawn_id].begin(); itr != waypoints[id][spawn_id].end(); itr++)
{
// use custom waypoint map, so we avoid saving it to database
crt->m_custom_waypoint_map->push_back(*itr);
}
crt->GetAIInterface()->SetWaypointMap(crt->m_custom_waypoint_map);
crt->AddToWorld(mgr);
m_creaturespawns[id][mapid].push_back(crt->GetUIdFromGUID());
}
while(query->NextRow());
}
// gameobject spawns
if(QueryResult *query = results[3].result)
{
do
{
Field * f = query->Fetch();
GOSpawn spawn;
//uint32 event = f[0].GetUInt32();
uint32 spawn_id = f[1].GetUInt32();
// generate new ingame sql id
spawn.id = /*objmgr.GenerateCreatureSpawnID()*/0;
spawn.entry = f[2].GetUInt32();
uint32 mapid = f[3].GetUInt32();
spawn.x = f[4].GetFloat();
spawn.y = f[5].GetFloat();
spawn.z = f[6].GetFloat();
spawn.facing = f[7].GetFloat();
spawn.o = f[8].GetFloat();
spawn.o1 = f[9].GetFloat();
spawn.o2 = f[10].GetFloat();
spawn.o3 = f[11].GetFloat();
spawn.state = f[12].GetUInt32();
spawn.flags = f[13].GetUInt32();
spawn.faction = f[14].GetUInt32();
spawn.scale = f[15].GetFloat();
//uint32 state_npc_link = fields[16].GetUInt32();
spawn.phase = f[17].GetUInt32();
if(spawn.phase == 0) spawn.phase = 0xFFFFFFFF;
spawn.overrides = f[18].GetUInt32();
// get mapmgr for spawn
MapMgr * mgr = sInstanceMgr.GetMapMgr(mapid);
if(mgr == NULL)
{
// So this is a really interesting situation!
Log.Success("GameEvent","Failed to spawn gameobject spawn %u for event %u on nonexistant map %u", spawn.id, id, mapid);
continue;
}
// spawn the creature
GameObject * go = mgr->CreateGameObject(spawn.entry);
if(go == NULL)
{
// we didnt succeed creating the creature! Print a warning and go on
Log.Success("GameEvent","Failed to spawn gameobject spawn %u for event %u", spawn.id, id);
continue;
}
go->Load(&spawn);
go->m_spawn = NULL;
go->AddToWorld(mgr);
m_gameobjectspawns[id][mapid].push_back(go->GetUIdFromGUID());
}
while(query->NextRow());
}
Log.Success("GameEvent","event %u spawned.", id);
}
void Vehicle::InstallAccessories()
{
CreatureProtoVehicle* acc = CreatureProtoVehicleStorage.LookupEntry(GetEntry());
if(acc == NULL)
{
sLog.outDetail("Vehicle %u has no accessories.", GetEntry());
return;
}
MapMgr* map = (GetMapMgr() ? GetMapMgr() : sInstanceMgr.GetMapMgr(GetMapId()));
if(map == NULL) // Shouldn't ever really happen.
return;
for(int i = 0; i < 8; i++)
{
SeatInfo seatinfo = acc->seats[i];
if(!seatinfo.accessoryentry || (seatinfo.accessoryentry == GetEntry()))
continue;
if(m_vehicleSeats[i] == NULL)
{
sLog.outDetail("No seatmap for selected seat.\n");
continue;
}
// Load the Proto
CreatureProto* proto = CreatureProtoStorage.LookupEntry(seatinfo.accessoryentry);
CreatureInfo* info = CreatureNameStorage.LookupEntry(seatinfo.accessoryentry);
if(!proto || !info)
{
sLog.outError("No proto/info for vehicle accessory %u in vehicle %u", seatinfo.accessoryentry, GetEntry());
continue;
}
// Remove any passengers.
if(m_passengers[i])
RemovePassenger(m_passengers[i]);
if(proto->vehicle_entry > 0)
{
// Create the Vehicle!
Vehicle* pass = map->CreateVehicle(seatinfo.accessoryentry);
if(pass != NULL && pass)
{
pass->Load(proto, (IsInInstance() ? map->iInstanceMode : MODE_5PLAYER_NORMAL),
GetPositionX()+m_vehicleSeats[i]->m_attachmentOffsetX,
GetPositionY()+m_vehicleSeats[i]->m_attachmentOffsetY,
GetPositionZ()+m_vehicleSeats[i]->m_attachmentOffsetZ);
pass->Init();
pass->m_TransporterGUID = GetGUID();
pass->InitSeats(proto->vehicle_entry);
if(pass->HasFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_SPELLCLICK))
pass->RemoveFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_SPELLCLICK); // Accessory
AddPassenger(pass, i, true);
pass->PushToWorld(map);
}
}
else
{
// Create the Unit!
Creature* pass = map->CreateCreature(seatinfo.accessoryentry);
if(pass != NULL)
{
pass->Load(proto, map->iInstanceMode,
GetPositionX()+m_vehicleSeats[i]->m_attachmentOffsetX,
GetPositionY()+m_vehicleSeats[i]->m_attachmentOffsetY,
GetPositionZ()+m_vehicleSeats[i]->m_attachmentOffsetZ);
pass->Init();
pass->m_TransporterGUID = GetGUID();
AddPassenger(pass, i, true);
pass->PushToWorld(map);
}
}
}
}
int LuaGlobalFunctions_PerformIngameSpawn(lua_State * L)
{
uint32 spawntype = luaL_checkint(L, 1);
uint32 entry = luaL_checkint(L, 2);
uint32 map = luaL_checkint(L, 3);
float x = CHECK_FLOAT(L, 4);
float y = CHECK_FLOAT(L, 5);
float z = CHECK_FLOAT(L, 6);
float o = CHECK_FLOAT(L, 7);
uint32 faction = luaL_checkint(L, 8); //also scale as percentage
uint32 duration = luaL_checkint(L, 9);
uint32 equip1 = luaL_optint(L, 10, 1);
uint32 equip2 = luaL_optint(L, 11, 1);
uint32 equip3 = luaL_optint(L, 12, 1);
//13: instance id
uint32 save = luaL_optint(L, 14, 0);
if(x && y && z && entry)
{
if (spawntype == 1) //Unit
{
CreatureProto *p = CreatureProtoStorage.LookupEntry(entry);
CreatureInfo *i = CreatureNameStorage.LookupEntry(entry);
if (p == NULL || i == NULL)
RET_NIL(true);
MapMgr *mapMgr = sInstanceMgr.GetMapMgr(map);
if (mapMgr == NULL)
RET_NIL(true);
int32 instanceid = luaL_optint(L, 13, mapMgr->GetInstanceID());
CreatureSpawn * sp = new CreatureSpawn();
sp->entry = entry;
sp->id = objmgr.GenerateCreatureSpawnID();
sp->x = x;
sp->y = y;
sp->z = z;
sp->o = o;
sp->emote_state = 0;
sp->flags = 0;
sp->factionid = faction;
sp->stand_state = 0;
sp->phase = 1;
sp->vehicle = p->vehicle_entry > 0 ? true : false;
sp->Bytes = NULL;
sp->ChannelData = NULL;
sp->MountedDisplay = NULL;
Creature * pCreature = NULL;
if(sp->vehicle)
{
pCreature = TO_CREATURE(mapMgr->CreateVehicle(entry));
TO_VEHICLE(pCreature)->Load(sp, mapMgr->iInstanceMode, NULL);
}
else
{
pCreature = mapMgr->CreateCreature(entry);
pCreature->Load(sp, mapMgr->iInstanceMode, NULL);
}
pCreature->m_loadedFromDB = true;
pCreature->SetFaction(faction);
pCreature->SetInstanceID(instanceid);
pCreature->SetMapId(map);
pCreature->m_noRespawn = true;
pCreature->PushToWorld(mapMgr);
if (duration>0)
pCreature->Despawn(duration,0);
if (save)
pCreature->SaveToDB();
Lunar<Unit>::push(L,TO_UNIT(pCreature));
}
else if (spawntype == 2) //GO
{
GameObjectInfo *n = GameObjectNameStorage.LookupEntry(entry);
if (n == NULL)
RET_NIL(true);
MapMgr *mapMgr = sInstanceMgr.GetMapMgr(map);
if (mapMgr == NULL)
RET_NIL(true);
int32 instanceid = luaL_optint(L, 13, mapMgr->GetInstanceID());
GameObject *go = mapMgr->CreateGameObject(entry);
go->SetInstanceID(instanceid);
go->CreateFromProto(entry,map,x,y,z,o);
// Create spawn instance
GOSpawn * gs = new GOSpawn;
gs->entry = go->GetEntry();
gs->facing = go->GetOrientation();
gs->faction = go->GetFaction();
gs->flags = go->GetUInt32Value(GAMEOBJECT_FLAGS);
gs->id = objmgr.GenerateGameObjectSpawnID();
gs->scale = go->GetUInt32Value(OBJECT_FIELD_SCALE_X);
gs->x = go->GetPositionX();
gs->y = go->GetPositionY();
gs->z = go->GetPositionZ();
gs->state = go->GetByte(GAMEOBJECT_BYTES_1, 0);
gs->phase = 0;
go->m_spawn = gs;
go->PushToWorld(mapMgr);
if (duration)
sEventMgr.AddEvent(go,&GameObject::ExpireAndDelete,EVENT_GAMEOBJECT_UPDATE,duration,1,EVENT_FLAG_DO_NOT_EXECUTE_IN_WORLD_CONTEXT);
if (save)
go->SaveToDB();
Lunar<GameObject>::push(L,go);
}
else
RET_NIL(true);
}
else
RET_NIL(true);
return 1;
}
