Mirror/TrinityCore
1
0
Fork 0
mirror of https://github.com/TrinityCore/TrinityCore.git synced 2026-01-21 09:44:45 +01:00
Code Issues Packages Projects Releases Wiki Activity

Core/Phasing: Rewrite GetTerrainMapId *updated phasing with latest changes

Browse Source
This commit is contained in:
Aokromes
2018-03-10 15:13:00 +00:00
parent aea3a38c2d 27652214b5
commit fcbd10062b
15 changed files with 82 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/common/Collision/Management/IVMapManager.h
View File

@@ -126,8 +126,6 @@ namespace VMAP
virtual bool GetLiquidLevel(uint32 pMapId, float x, float y, float z, uint8 ReqLiquidType, float &level, float &floor, uint32 &type) const=0;
// get both area + liquid data in a single vmap lookup
virtual void getAreaAndLiquidData(unsigned int mapId, float x, float y, float z, uint8 reqLiquidType, AreaAndLiquidData& data) const=0;
virtual int32 GetDistanceToClosestPrimaryTile(uint32 mapId, int32 x, int32 y) const = 0;
};
}

9
src/common/Collision/Management/VMapManager2.cpp
View File

@@ -345,15 +345,6 @@ namespace VMAP
}
}
int32 VMapManager2::GetDistanceToClosestPrimaryTile(uint32 mapId, int32 x, int32 y) const
{
auto instanceTree = GetMapTree(mapId);
if (instanceTree != iInstanceMapTrees.end())
return instanceTree->second->GetDistanceToClosestPrimaryTile(x, y);
return std::numeric_limits<int32>::max();
}
WorldModel* VMapManager2::acquireModelInstance(const std::string& basepath, const std::string& filename, uint32 flags/* Only used when creating the model */)
{
//! Critical section, thread safe access to iLoadedModelFiles

2
src/common/Collision/Management/VMapManager2.h
View File

@@ -124,8 +124,6 @@ namespace VMAP
bool GetLiquidLevel(uint32 pMapId, float x, float y, float z, uint8 reqLiquidType, float& level, float& floor, uint32& type) const override;
void getAreaAndLiquidData(unsigned int mapId, float x, float y, float z, uint8 reqLiquidType, AreaAndLiquidData& data) const override;
int32 GetDistanceToClosestPrimaryTile(uint32 mapId, int32 x, int32 y) const override;
WorldModel* acquireModelInstance(const std::string& basepath, const std::string& filename, uint32 flags = 0);
void releaseModelInstance(const std::string& filename);

16
src/common/Collision/Maps/MapTree.cpp
View File

@@ -241,7 +241,6 @@ namespace VMAP
TileFileOpenResult result;
result.Name = basePath + getTileFileName(mapID, tileX, tileY);
result.File = fopen(result.Name.c_str(), "rb");
result.IsPrimary = true;
if (!result.File)
{
int32 parentMapId = vm->getParentMapId(mapID);
@@ -249,7 +248,6 @@ namespace VMAP
{
result.Name = basePath + getTileFileName(parentMapId, tileX, tileY);
result.File = fopen(result.Name.c_str(), "rb");
result.IsPrimary = false;
}
}
@@ -372,7 +370,6 @@ namespace VMAP
}
iLoadedSpawns.clear();
iLoadedTiles.clear();
iLoadedPrimaryTiles.clear();
}
//=========================================================
@@ -449,8 +446,6 @@ namespace VMAP
}
}
iLoadedTiles[packTileID(tileX, tileY)] = true;
if (fileResult.IsPrimary)
iLoadedPrimaryTiles.emplace_back(tileX, tileY);
fclose(fileResult.File);
}
else
@@ -512,8 +507,6 @@ namespace VMAP
}
}
iLoadedTiles.erase(tile);
iLoadedPrimaryTiles.erase(std::remove_if(iLoadedPrimaryTiles.begin(), iLoadedPrimaryTiles.end(),
[tileX, tileY](std::pair<uint32, uint32> const& p) { return p.first == tileX && p.second == tileY; }), iLoadedPrimaryTiles.end());
TC_METRIC_EVENT("map_events", "UnloadMapTile",
"Map: " + std::to_string(iMapID) + " TileX: " + std::to_string(tileX) + " TileY: " + std::to_string(tileY));
}
@@ -523,13 +516,4 @@ namespace VMAP
models = iTreeValues;
count = iNTreeValues;
}
int32 StaticMapTree::GetDistanceToClosestPrimaryTile(int32 x, int32 y) const
{
int32 minDistance = std::numeric_limits<int32>::max();
for (std::pair<int32, int32> const& primaryTile : iLoadedPrimaryTiles)
minDistance = std::min(minDistance, (primaryTile.first - x) * (primaryTile.first - x) + (primaryTile.second - y) * (primaryTile.second - y));
return minDistance;
}
}

3
src/common/Collision/Maps/MapTree.h
View File

@@ -66,7 +66,6 @@ namespace VMAP
{
FILE* File;
std::string Name;
bool IsPrimary;
};
private:
@@ -96,8 +95,6 @@ namespace VMAP
uint32 numLoadedTiles() const { return uint32(iLoadedTiles.size()); }
void getModelInstances(ModelInstance* &models, uint32 &count);
int32 GetDistanceToClosestPrimaryTile(int32 x, int32 y) const;
private:
StaticMapTree(StaticMapTree const& right) = delete;
StaticMapTree& operator=(StaticMapTree const& right) = delete;

3
src/server/game/Entities/Object/Object.cpp
View File

@@ -2504,7 +2504,8 @@ void WorldObject::MovePositionToFirstCollision(Position &pos, float dist, float
}
destz = NormalizeZforCollision(this, destx, desty, pos.GetPositionZ());
bool col = VMAP::VMapFactory::createOrGetVMapManager()->getObjectHitPos(GetPhaseShift().GetTerrainMapId(GetMapId(), pos.m_positionX, pos.m_positionY), pos.m_positionX, pos.m_positionY, pos.m_positionZ + 0.5f, destx, desty, destz + 0.5f, destx, desty, destz, -0.5f);
bool col = VMAP::VMapFactory::createOrGetVMapManager()->getObjectHitPos(PhasingHandler::GetTerrainMapId(GetPhaseShift(), GetMap(), pos.m_positionX, pos.m_positionY),
pos.m_positionX, pos.m_positionY, pos.m_positionZ + 0.5f, destx, desty, destz + 0.5f, destx, desty, destz, -0.5f);
// collision occured
if (col)

24
src/server/game/Maps/Map.cpp
View File

@@ -2323,7 +2323,7 @@ float Map::GetStaticHeight(PhaseShift const& phaseShift, float x, float y, float
{
// find raw .map surface under Z coordinates
float mapHeight = VMAP_INVALID_HEIGHT_VALUE;
uint32 terrainMapId = phaseShift.GetTerrainMapId(GetId(), x, y);
uint32 terrainMapId = PhasingHandler::GetTerrainMapId(phaseShift, this, x, y);
if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(terrainMapId, x, y))
{
float gridHeight = gmap->getHeight(x, y);
@@ -2408,7 +2408,7 @@ bool Map::IsOutdoors(PhaseShift const& phaseShift, float x, float y, float z) co
bool Map::GetAreaInfo(PhaseShift const& phaseShift, float x, float y, float z, uint32 &flags, int32 &adtId, int32 &rootId, int32 &groupId) const
{
float vmap_z = z;
uint32 terrainMapId = phaseShift.GetTerrainMapId(GetId(), x, y);
uint32 terrainMapId = PhasingHandler::GetTerrainMapId(phaseShift, this, x, y);
VMAP::IVMapManager* vmgr = VMAP::VMapFactory::createOrGetVMapManager();
if (vmgr->getAreaInfo(terrainMapId, x, y, vmap_z, flags, adtId, rootId, groupId))
{
@@ -2432,22 +2432,24 @@ uint32 Map::GetAreaId(PhaseShift const& phaseShift, float x, float y, float z, b
WMOAreaTableEntry const* wmoEntry = nullptr;
AreaTableEntry const* atEntry = nullptr;
bool haveAreaInfo = false;
uint32 areaId = 0;
if (GetAreaInfo(phaseShift, x, y, z, mogpFlags, adtId, rootId, groupId))
{
haveAreaInfo = true;
wmoEntry = GetWMOAreaTableEntryByTripple(rootId, adtId, groupId);
if (wmoEntry)
{
areaId = wmoEntry->areaId;
atEntry = sAreaTableStore.LookupEntry(wmoEntry->areaId);
}
}
uint32 areaId = 0;
if (atEntry)
areaId = atEntry->ID;
else
if (!areaId)
{
if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(phaseShift.GetTerrainMapId(GetId(), x, y), x, y))
if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(PhasingHandler::GetTerrainMapId(phaseShift, this, x, y), x, y))
areaId = gmap->getArea(x, y);
// this used while not all *.map files generated (instances)
@@ -2485,7 +2487,7 @@ void Map::GetZoneAndAreaId(PhaseShift const& phaseShift, uint32& zoneid, uint32&
uint8 Map::GetTerrainType(PhaseShift const& phaseShift, float x, float y) const
{
if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(phaseShift.GetTerrainMapId(GetId(), x, y), x, y))
if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(PhasingHandler::GetTerrainMapId(phaseShift, this, x, y), x, y))
return gmap->getTerrainType(x, y);
else
return 0;
@@ -2498,7 +2500,7 @@ ZLiquidStatus Map::GetLiquidStatus(PhaseShift const& phaseShift, float x, float
float liquid_level = INVALID_HEIGHT;
float ground_level = INVALID_HEIGHT;
uint32 liquid_type = 0;
uint32 terrainMapId = phaseShift.GetTerrainMapId(GetId(), x, y);
uint32 terrainMapId = PhasingHandler::GetTerrainMapId(phaseShift, this, x, y);
if (vmgr->GetLiquidLevel(terrainMapId, x, y, z, ReqLiquidType, liquid_level, ground_level, liquid_type))
{
TC_LOG_DEBUG("maps", "GetLiquidStatus(): vmap liquid level: %f ground: %f type: %u", liquid_level, ground_level, liquid_type);
@@ -2680,7 +2682,7 @@ void Map::GetFullTerrainStatusForPosition(float x, float y, float z, PositionFul
float Map::GetWaterLevel(PhaseShift const& phaseShift, float x, float y) const
{
if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(phaseShift.GetTerrainMapId(GetId(), x, y), x, y))
if (GridMap* gmap = const_cast<Map*>(this)->GetGrid(PhasingHandler::GetTerrainMapId(phaseShift, this, x, y), x, y))
return gmap->getLiquidLevel(x, y);
else
return 0;
@@ -2689,7 +2691,7 @@ float Map::GetWaterLevel(PhaseShift const& phaseShift, float x, float y) const
bool Map::isInLineOfSight(PhaseShift const& phaseShift, float x1, float y1, float z1, float x2, float y2, float z2, LineOfSightChecks checks, VMAP::ModelIgnoreFlags ignoreFlags) const
{
if ((checks & LINEOFSIGHT_CHECK_VMAP)
&& !VMAP::VMapFactory::createOrGetVMapManager()->isInLineOfSight(phaseShift.GetTerrainMapId(GetId(), x1, x2), x1, y1, z1, x2, y2, z2, ignoreFlags))
&& !VMAP::VMapFactory::createOrGetVMapManager()->isInLineOfSight(PhasingHandler::GetTerrainMapId(phaseShift, this, x1, y1), x1, y1, z1, x2, y2, z2, ignoreFlags))
return false;
if (sWorld->getBoolConfig(CONFIG_CHECK_GOBJECT_LOS) && (checks & LINEOFSIGHT_CHECK_GOBJECT)
&& !_dynamicTree.isInLineOfSight({x1, y1, z1}, {x2, y2, z2}, phaseShift))

3
src/server/game/Maps/Map.h
View File

@@ -350,6 +350,7 @@ class TC_GAME_API Map : public GridRefManager<NGridType>
time_t GetGridExpiry(void) const { return i_gridExpiry; }
uint32 GetId(void) const { return i_mapEntry->MapID; }
bool HasGrid(int32 gx, int32 gy) const { return GridMaps[gx][gy] && GridMaps[gx][gy]->fileExists(); }
static bool ExistMap(uint32 mapid, int gx, int gy);
static bool ExistVMap(uint32 mapid, int gx, int gy);
@@ -661,8 +662,6 @@ class TC_GAME_API Map : public GridRefManager<NGridType>
void setNGrid(NGridType* grid, uint32 x, uint32 y);
void ScriptsProcess();
void UpdateActiveCells(const float &x, const float &y, const uint32 t_diff);
void SendObjectUpdates();
protected:

10
src/server/game/Movement/MovementGenerators/FleeingMovementGenerator.cpp
View File

@@ -24,6 +24,7 @@
#include "PathGenerator.h"
#include "MoveSplineInit.h"
#include "MoveSpline.h"
#include "PhasingHandler.h"
#include "FleeingMovementGenerator.h"
#define MIN_QUIET_DISTANCE 28.0f
@@ -115,8 +116,13 @@ void FleeingMovementGenerator<T>::SetTargetLocation(T* owner)
GetPoint(owner, destination);
// Add LOS check for target point
Position currentPosition = owner->GetPosition();
if (!VMAP::VMapFactory::createOrGetVMapManager()->isInLineOfSight(owner->GetPhaseShift().GetTerrainMapId(owner->GetMapId(), currentPosition.m_positionX, currentPosition.m_positionY), currentPosition.m_positionX, currentPosition.m_positionY, currentPosition.m_positionZ + 1.0f, destination.GetPositionX(), destination.GetPositionY(), destination.GetPositionZ() + 1.0f, VMAP::ModelIgnoreFlags::Nothing))
Position mypos = owner->GetPosition();
bool isInLOS = VMAP::VMapFactory::createOrGetVMapManager()->isInLineOfSight(
PhasingHandler::GetTerrainMapId(owner->GetPhaseShift(), owner->GetMap(), mypos.m_positionX, mypos.m_positionY),
mypos.m_positionX, mypos.m_positionY, mypos.m_positionZ + 2.0f, destination.m_positionX, destination.m_positionY,
destination.m_positionZ + 2.0f, VMAP::ModelIgnoreFlags::Nothing);
if (!isInLOS)
{
_timer.Reset(200);
return;

3
src/server/game/Movement/PathGenerator.cpp
View File

@@ -27,6 +27,7 @@
#include "DetourCommon.h"
#include "DetourNavMeshQuery.h"
#include "Metric.h"
#include "PhasingHandler.h"
////////////////// PathGenerator //////////////////
PathGenerator::PathGenerator(const Unit* owner) :
@@ -39,7 +40,7 @@ PathGenerator::PathGenerator(const Unit* owner) :
TC_LOG_DEBUG("maps", "++ PathGenerator::PathGenerator for %u \n", _sourceUnit->GetGUID().GetCounter());
uint32 mapId = _sourceUnit->GetMapId();
uint32 mapId = PhasingHandler::GetTerrainMapId(_sourceUnit->GetPhaseShift(), _sourceUnit->GetMap(), _sourceUnit->GetPositionX(), _sourceUnit->GetPositionY());
if (DisableMgr::IsPathfindingEnabled(mapId))
{
MMAP::MMapManager* mmap = MMAP::MMapFactory::createOrGetMMapManager();

35
src/server/game/Phasing/PhaseShift.cpp
View File

@@ -17,12 +17,10 @@
#include "PhaseShift.h"
#include "Containers.h"
#include "GridDefines.h"
#include "VMapFactory.h"
bool PhaseShift::AddPhase(uint32 phaseId, PhaseFlags flags, PhaseInfoStruct const* phase, std::vector<Condition*> const* areaConditions, int32 references /*= 1*/)
bool PhaseShift::AddPhase(uint32 phaseId, PhaseFlags flags, std::vector<Condition*> const* areaConditions, int32 references /*= 1*/)
{
auto insertResult = Phases.emplace(phaseId, flags, phase, nullptr);
auto insertResult = Phases.emplace(phaseId, flags, nullptr);
ModifyPhasesReferences(insertResult.first, references);
if (areaConditions)
insertResult.first->AreaConditions = areaConditions;
@@ -32,7 +30,7 @@ bool PhaseShift::AddPhase(uint32 phaseId, PhaseFlags flags, PhaseInfoStruct cons
PhaseShift::EraseResult<PhaseShift::PhaseContainer> PhaseShift::RemovePhase(uint32 phaseId)
{
auto itr = Phases.find(PhaseRef(phaseId, PhaseFlags::None, nullptr, nullptr));
auto itr = Phases.find(PhaseRef(phaseId, PhaseFlags::None, nullptr));
if (itr != Phases.end())
{
ModifyPhasesReferences(itr, -1);
@@ -147,33 +145,6 @@ bool PhaseShift::CanSee(PhaseShift const& other) const
return checkInversePhaseShift(other, *this);
}
uint32 PhaseShift::GetTerrainMapId(uint32 realMapId, float x, float y) const
{
if (VisibleMapIds.empty())
return realMapId;
if (VisibleMapIds.size() == 1)
return VisibleMapIds.begin()->first;
GridCoord gridCoord = Trinity::ComputeGridCoord(x, y);
int32 gx = (MAX_NUMBER_OF_GRIDS - 1) - gridCoord.x_coord;
int32 gy = (MAX_NUMBER_OF_GRIDS - 1) - gridCoord.y_coord;
int32 minDistance = std::numeric_limits<int32>::max();
uint32 terrainMapId;
for (auto itr = VisibleMapIds.begin(); itr != VisibleMapIds.end(); ++itr)
{
int32 dist = VMAP::VMapFactory::createOrGetVMapManager()->GetDistanceToClosestPrimaryTile(itr->first, gx, gy);
if (dist < minDistance)
{
minDistance = dist;
terrainMapId = itr->first;
}
}
return terrainMapId;
}
void PhaseShift::ModifyPhasesReferences(PhaseContainer::iterator itr, int32 references)
{
itr->References += references;

11
src/server/game/Phasing/PhaseShift.h
View File

@@ -26,7 +26,6 @@
class PhasingHandler;
struct Condition;
struct PhaseInfoStruct;
struct TerrainSwapInfo;
#define DEFAULT_PHASE 169
@@ -54,13 +53,12 @@ class TC_GAME_API PhaseShift
public:
struct PhaseRef
{
PhaseRef(uint32 id, PhaseFlags flags, PhaseInfoStruct const* phaseInfo, std::vector<Condition*> const* conditions)
: Id(id), Flags(flags), References(0), PhaseInfo(phaseInfo), AreaConditions(conditions) { }
PhaseRef(uint32 id, PhaseFlags flags, std::vector<Condition*> const* conditions)
: Id(id), Flags(flags), References(0), AreaConditions(conditions) { }
uint16 Id;
EnumClassFlag<PhaseFlags> Flags;
int32 References;
PhaseInfoStruct const* PhaseInfo;
std::vector<Condition*> const* AreaConditions;
bool operator<(PhaseRef const& right) const { return Id < right.Id; }
bool operator==(PhaseRef const& right) const { return Id == right.Id; }
@@ -84,9 +82,9 @@ public:
typedef std::map<uint32, VisibleMapIdRef> VisibleMapIdContainer;
typedef std::map<uint32, UiWorldMapAreaIdSwapRef> UiWorldMapAreaIdSwapContainer;
bool AddPhase(uint32 phaseId, PhaseFlags flags, PhaseInfoStruct const* phase, std::vector<Condition*> const* areaConditions, int32 references = 1);
bool AddPhase(uint32 phaseId, PhaseFlags flags, std::vector<Condition*> const* areaConditions, int32 references = 1);
EraseResult<PhaseContainer> RemovePhase(uint32 phaseId);
bool HasPhase(uint32 phaseId) const { return Phases.find(PhaseRef(phaseId, PhaseFlags::None, nullptr, nullptr)) != Phases.end(); }
bool HasPhase(uint32 phaseId) const { return Phases.find(PhaseRef(phaseId, PhaseFlags::None, nullptr)) != Phases.end(); }
PhaseContainer const& GetPhases() const { return Phases; }
bool AddVisibleMapId(uint32 visibleMapId, TerrainSwapInfo const* visibleMapInfo, int32 references = 1);
@@ -103,7 +101,6 @@ public:
void ClearPhases();
bool CanSee(PhaseShift const& other) const;
uint32 GetTerrainMapId(uint32 realMapId, float x, float y) const;
protected:
friend class PhasingHandler;

61
src/server/game/Phasing/PhasingHandler.cpp
View File

@@ -61,7 +61,7 @@ inline void ForAllControlled(Unit* unit, Func&& func)
void PhasingHandler::AddPhase(WorldObject* object, uint32 phaseId, bool updateVisibility)
{
bool changed = object->GetPhaseShift().AddPhase(phaseId, GetPhaseFlags(phaseId), sObjectMgr->GetPhaseInfo(phaseId), nullptr);
bool changed = object->GetPhaseShift().AddPhase(phaseId, GetPhaseFlags(phaseId), nullptr);
if (Unit* unit = object->ToUnit())
{
@@ -101,7 +101,7 @@ void PhasingHandler::AddPhaseGroup(WorldObject* object, uint32 phaseGroupId, boo
bool changed = false;
for (uint32 phaseId : *phasesInGroup)
changed = object->GetPhaseShift().AddPhase(phaseId, GetPhaseFlags(phaseId), sObjectMgr->GetPhaseInfo(phaseId), nullptr) || changed;
changed = object->GetPhaseShift().AddPhase(phaseId, GetPhaseFlags(phaseId), nullptr) || changed;
if (Unit* unit = object->ToUnit())
{
@@ -242,9 +242,9 @@ void PhasingHandler::OnAreaChange(WorldObject* object)
uint32 phaseId = phaseArea.PhaseInfo->Id;
if (sConditionMgr->IsObjectMeetToConditions(srcInfo, phaseArea.Conditions))
phaseShift.AddPhase(phaseArea.PhaseInfo->Id, GetPhaseFlags(phaseId), phaseArea.PhaseInfo, &phaseArea.Conditions);
phaseShift.AddPhase(phaseId, GetPhaseFlags(phaseId), &phaseArea.Conditions);
else
suppressedPhaseShift.AddPhase(phaseArea.PhaseInfo->Id, GetPhaseFlags(phaseId), phaseArea.PhaseInfo, &phaseArea.Conditions);
suppressedPhaseShift.AddPhase(phaseId, GetPhaseFlags(phaseId), &phaseArea.Conditions);
}
}
@@ -257,13 +257,13 @@ void PhasingHandler::OnAreaChange(WorldObject* object)
for (AuraEffect const* aurEff : unit->GetAuraEffectsByType(SPELL_AURA_PHASE))
{
uint32 phaseId = uint32(aurEff->GetMiscValueB());
changed = phaseShift.AddPhase(phaseId, GetPhaseFlags(phaseId), sObjectMgr->GetPhaseInfo(phaseId), nullptr) || changed;
changed = phaseShift.AddPhase(phaseId, GetPhaseFlags(phaseId), nullptr) || changed;
}
for (AuraEffect const* aurEff : unit->GetAuraEffectsByType(SPELL_AURA_PHASE_GROUP))
if (std::vector<uint32> const* phasesInGroup = GetPhasesForGroup(uint32(aurEff->GetMiscValueB())))
for (uint32 phaseId : *phasesInGroup)
changed = phaseShift.AddPhase(phaseId, GetPhaseFlags(phaseId), sObjectMgr->GetPhaseInfo(phaseId), nullptr) || changed;
changed = phaseShift.AddPhase(phaseId, GetPhaseFlags(phaseId), nullptr) || changed;
if (changed)
unit->OnPhaseChange();
@@ -292,7 +292,7 @@ void PhasingHandler::OnConditionChange(WorldObject* object)
{
if (itr->AreaConditions && !sConditionMgr->IsObjectMeetToConditions(srcInfo, *itr->AreaConditions))
{
newSuppressions.AddPhase(itr->Id, itr->Flags, itr->PhaseInfo, itr->AreaConditions, itr->References);
newSuppressions.AddPhase(itr->Id, itr->Flags, itr->AreaConditions, itr->References);
itr = phaseShift.Phases.erase(itr);
}
else
@@ -303,7 +303,7 @@ void PhasingHandler::OnConditionChange(WorldObject* object)
{
if (sConditionMgr->IsObjectMeetToConditions(srcInfo, *ASSERT_NOTNULL(itr->AreaConditions)))
{
changed = phaseShift.AddPhase(itr->Id, itr->Flags, itr->PhaseInfo, itr->AreaConditions, itr->References) || changed;
changed = phaseShift.AddPhase(itr->Id, itr->Flags, itr->AreaConditions, itr->References) || changed;
itr = suppressedPhaseShift.Phases.erase(itr);
}
else
@@ -344,8 +344,10 @@ void PhasingHandler::OnConditionChange(WorldObject* object)
for (AuraEffect const* aurEff : unit->GetAuraEffectsByType(SPELL_AURA_PHASE))
{
uint32 phaseId = uint32(aurEff->GetMiscValueB());
phaseShift.AddPhase(phaseId, GetPhaseFlags(phaseId), sObjectMgr->GetPhaseInfo(phaseId), nullptr);
newSuppressions.RemovePhase(phaseId);
auto eraseResult = newSuppressions.RemovePhase(phaseId);
// if condition was met previously there is nothing to erase
if (eraseResult.Iterator != newSuppressions.Phases.end() || eraseResult.Erased)
phaseShift.AddPhase(phaseId, GetPhaseFlags(phaseId), nullptr);
}
for (AuraEffect const* aurEff : unit->GetAuraEffectsByType(SPELL_AURA_PHASE_GROUP))
@@ -354,8 +356,10 @@ void PhasingHandler::OnConditionChange(WorldObject* object)
{
for (uint32 phaseId : *phasesInGroup)
{
phaseShift.AddPhase(phaseId, GetPhaseFlags(phaseId), sObjectMgr->GetPhaseInfo(phaseId), nullptr);
newSuppressions.RemovePhase(phaseId);
auto eraseResult = newSuppressions.RemovePhase(phaseId);
// if condition was met previously there is nothing to erase
if (eraseResult.Iterator != newSuppressions.Phases.end() || eraseResult.Erased)
phaseShift.AddPhase(phaseId, GetPhaseFlags(phaseId), nullptr);
}
}
}
@@ -363,7 +367,7 @@ void PhasingHandler::OnConditionChange(WorldObject* object)
changed = changed || !newSuppressions.Phases.empty() || !newSuppressions.VisibleMapIds.empty();
for (auto itr = newSuppressions.Phases.begin(); itr != newSuppressions.Phases.end(); ++itr)
suppressedPhaseShift.AddPhase(itr->Id, itr->Flags, itr->PhaseInfo, itr->AreaConditions, itr->References);
suppressedPhaseShift.AddPhase(itr->Id, itr->Flags, itr->AreaConditions, itr->References);
for (auto itr = newSuppressions.VisibleMapIds.begin(); itr != newSuppressions.VisibleMapIds.end(); ++itr)
suppressedPhaseShift.AddVisibleMapId(itr->first, itr->second.VisibleMapInfo, itr->second.References);
@@ -453,7 +457,6 @@ PhaseShift const& PhasingHandler::GetEmptyPhaseShift()
void PhasingHandler::InitDbPhaseShift(PhaseShift& phaseShift, uint8 phaseUseFlags, uint16 phaseId, uint32 phaseGroupId)
{
phaseShift.ClearPhases();
phaseShift.IsDbPhaseShift = true;
EnumClassFlag<PhaseShiftFlags> flags = PhaseShiftFlags::None;
@@ -463,10 +466,10 @@ void PhasingHandler::InitDbPhaseShift(PhaseShift& phaseShift, uint8 phaseUseFlag
flags |= PhaseShiftFlags::Inverse;
if (phaseId)
phaseShift.AddPhase(phaseId, GetPhaseFlags(phaseId), sObjectMgr->GetPhaseInfo(phaseId), nullptr);
phaseShift.AddPhase(phaseId, GetPhaseFlags(phaseId), nullptr);
else if (std::vector<uint32> const* phasesInGroup = GetPhasesForGroup(phaseGroupId))
for (uint32 phaseInGroup : *phasesInGroup)
phaseShift.AddPhase(phaseInGroup, GetPhaseFlags(phaseInGroup), sObjectMgr->GetPhaseInfo(phaseInGroup), nullptr);
phaseShift.AddPhase(phaseInGroup, GetPhaseFlags(phaseInGroup), nullptr);
if (phaseShift.Phases.empty() || phaseShift.HasPhase(DEFAULT_PHASE))
{
@@ -493,6 +496,32 @@ bool PhasingHandler::InDbPhaseShift(WorldObject const* object, uint8 phaseUseFla
return object->GetPhaseShift().CanSee(phaseShift);
}
uint32 PhasingHandler::GetTerrainMapId(PhaseShift const& phaseShift, Map const* map, float x, float y)
{
if (phaseShift.VisibleMapIds.empty())
return map->GetId();
if (phaseShift.VisibleMapIds.size() == 1)
return phaseShift.VisibleMapIds.begin()->first;
GridCoord gridCoord = Trinity::ComputeGridCoord(x, y);
int32 gx = (MAX_NUMBER_OF_GRIDS - 1) - gridCoord.x_coord;
int32 gy = (MAX_NUMBER_OF_GRIDS - 1) - gridCoord.y_coord;
int32 gxbegin = std::max(gx - 1, 0);
int32 gxend = std::min(gx + 1, MAX_NUMBER_OF_GRIDS);
int32 gybegin = std::max(gy - 1, 0);
int32 gyend = std::min(gy + 1, MAX_NUMBER_OF_GRIDS);
for (auto itr = phaseShift.VisibleMapIds.rbegin(); itr != phaseShift.VisibleMapIds.rend(); ++itr)
for (int32 gxi = gxbegin; gxi < gxend; ++gxi)
for (int32 gyi = gybegin; gyi < gyend; ++gyi)
if (map->HasGrid(gxi, gyi))
return itr->first;
return map->GetId();
}
void PhasingHandler::SetAlwaysVisible(PhaseShift& phaseShift, bool apply)
{
if (apply)

3
src/server/game/Phasing/PhasingHandler.h
View File

@@ -22,6 +22,7 @@
#include <string>
class ChatHandler;
class Map;
class PhaseShift;
class Player;
class WorldObject;
@@ -53,6 +54,8 @@ public:
static void InitDbVisibleMapId(PhaseShift& phaseShift, int32 visibleMapId);
static bool InDbPhaseShift(WorldObject const* object, uint8 phaseUseFlags, uint16 phaseId, uint32 phaseGroupId);
static uint32 GetTerrainMapId(PhaseShift const& phaseShift, Map const* map, float x, float y);
static void SetAlwaysVisible(PhaseShift& phaseShift, bool apply);
static void SetInversed(PhaseShift& phaseShift, bool apply);

2
src/server/scripts/Commands/cs_debug.cpp
View File

@@ -1016,7 +1016,7 @@ public:
if (p)
if (uint32 up = (uint32)atoi(p))
phaseShift.AddPhase(up, PhaseFlags::None, nullptr, nullptr);
phaseShift.AddPhase(up, PhaseFlags::None, nullptr);
if (m)
if (uint32 um = (uint32)atoi(m))