void LoadObjectData(ObjectData[] objectData, Dictionary <uint, uint> objectInfo)
{
foreach (var data in objectData)
{
Cypher.Assert(!objectInfo.ContainsKey(data.entry));
objectInfo[data.entry] = data.type;
}
}
public override void InitSummon()
{
base.InitSummon();
if (!SetCharmedBy(GetOwner(), CharmType.Possess))
{
Cypher.Assert(false);
}
}
void BindToCaster()
{
Cypher.Assert(_caster == null);
_caster = Global.ObjAccessor.GetUnit(this, GetCasterGUID());
Cypher.Assert(_caster != null);
Cypher.Assert(_caster.GetMap() == GetMap());
_caster._RegisterDynObject(this);
}
public void SetPartyType(GroupCategory category, GroupType type)
{
Cypher.Assert(category < GroupCategory.Max);
byte value = m_playerData.PartyType;
value &= (byte)~((byte)0xFF << ((byte)category * 4));
value |= (byte)((byte)type << ((byte)category * 4));
SetUpdateFieldValue(m_values.ModifyValue(m_playerData).ModifyValue(m_playerData.PartyType), value);
}
public void SetPartyType(GroupCategory category, GroupType type)
{
Cypher.Assert(category < GroupCategory.Max);
byte value = GetByteValue(PlayerFields.Bytes3, PlayerFieldOffsets.Bytes3OffsetPartyType);
value &= (byte)~((byte)0xFF << ((byte)category * 4));
value |= (byte)((byte)type << ((byte)category * 4));
SetByteValue(PlayerFields.Bytes3, PlayerFieldOffsets.Bytes3OffsetPartyType, value);
}
public void Dispose()
{
// @Uninstall must be called before this.
Cypher.Assert(_status == Status.UnInstalling);
foreach (var pair in Seats)
{
Cypher.Assert(pair.Value.IsEmpty());
}
}
Node GetGrid(int x, int y)
{
Cypher.Assert(x < CELL_NUMBER && y < CELL_NUMBER);
if (nodes[x][y] == null)
{
nodes[x][y] = new Node();
}
return(nodes[x][y]);
}
public virtual void InitStats(uint duration)
{
Cypher.Assert(!IsPet());
m_timer = duration;
m_lifetime = duration;
if (m_type == TempSummonType.ManualDespawn)
{
m_type = (duration == 0) ? TempSummonType.DeadDespawn : TempSummonType.TimedDespawn;
}
Unit owner = GetSummoner();
if (owner != null && IsTrigger() && m_spells[0] != 0)
{
SetFaction(owner.GetFaction());
SetLevel(owner.GetLevel());
if (owner.IsTypeId(TypeId.Player))
{
m_ControlledByPlayer = true;
}
}
if (m_Properties == null)
{
return;
}
if (owner != null)
{
int slot = m_Properties.Slot;
if (slot > 0)
{
if (!owner.m_SummonSlot[slot].IsEmpty() && owner.m_SummonSlot[slot] != GetGUID())
{
Creature oldSummon = GetMap().GetCreature(owner.m_SummonSlot[slot]);
if (oldSummon != null && oldSummon.IsSummon())
{
oldSummon.ToTempSummon().UnSummon();
}
}
owner.m_SummonSlot[slot] = GetGUID();
}
}
if (m_Properties.Faction != 0)
{
SetFaction(m_Properties.Faction);
}
else if (IsVehicle() && owner != null) // properties should be vehicle
{
SetFaction(owner.GetFaction());
}
}
public Vehicle RemovePassenger(Unit unit)
{
if (unit.GetVehicle() != this)
{
return(null);
}
var seat = GetSeatKeyValuePairForPassenger(unit);
Cypher.Assert(seat.Value != null);
Log.outDebug(LogFilter.Vehicle, "Unit {0} exit vehicle entry {1} id {2} dbguid {3} seat {4}",
unit.GetName(), _me.GetEntry(), _vehicleInfo.Id, _me.GetGUID().ToString(), seat.Key);
if (seat.Value.SeatInfo.CanEnterOrExit() && ++UsableSeatNum != 0)
{
_me.SetFlag64(UnitFields.NpcFlags, (_me.IsTypeId(TypeId.Player) ? NPCFlags.PlayerVehicle : NPCFlags.SpellClick));
}
// Remove UNIT_FLAG_NOT_SELECTABLE if passenger did not have it before entering vehicle
if (seat.Value.SeatInfo.Flags.HasAnyFlag(VehicleSeatFlags.PassengerNotSelectable) && !seat.Value.Passenger.IsUnselectable)
{
unit.RemoveFlag(UnitFields.Flags, UnitFlags.NotSelectable);
}
seat.Value.Passenger.Reset();
if (_me.IsTypeId(TypeId.Unit) && unit.IsTypeId(TypeId.Player) && seat.Value.SeatInfo.Flags.HasAnyFlag(VehicleSeatFlags.CanControl))
{
_me.RemoveCharmedBy(unit);
}
if (_me.IsInWorld)
{
unit.m_movementInfo.ResetTransport();
}
// only for flyable vehicles
if (unit.IsFlying())
{
_me.CastSpell(unit, SharedConst.VehicleSpellParachute, true);
}
if (_me.IsTypeId(TypeId.Unit) && _me.ToCreature().IsAIEnabled)
{
_me.ToCreature().GetAI().PassengerBoarded(unit, seat.Key, false);
}
if (GetBase().IsTypeId(TypeId.Unit))
{
Global.ScriptMgr.OnRemovePassenger(this, unit);
}
unit.SetVehicle(null);
return(this);
}
public override void Dispose()
{
// make sure all references were properly removed
Cypher.Assert(_aura == null);
Cypher.Assert(!_caster);
Cypher.Assert(!_isViewpoint);
_removedAura = null;
base.Dispose();
}
// Hack to store map because this code is just shit
public void SetMapFromZone(uint zone)
{
AreaTableRecord areaTable = CliDB.AreaTableStorage.LookupByKey(zone);
Cypher.Assert(areaTable != null);
Map map = Global.MapMgr.CreateBaseMap(areaTable.ContinentID);
Cypher.Assert(!map.Instanceable());
m_map = map;
}
public Minion(SummonPropertiesRecord properties, Unit owner, bool isWorldObject)
: base(properties, owner, isWorldObject)
{
m_owner = owner;
Cypher.Assert(m_owner);
UnitTypeMask |= UnitTypeMask.Minion;
m_followAngle = SharedConst.PetFollowAngle;
/// @todo: Find correct way
InitCharmInfo();
}
void RemoveAura()
{
Cypher.Assert(_aura != null && _removedAura == null);
_removedAura = _aura;
_aura = null;
if (!_removedAura.IsRemoved())
{
_removedAura._Remove(AuraRemoveMode.Default);
}
}
void LoadHelper <T>(SortedSet <ulong> guid_set, CellCoord cell, ref uint count, Map map) where T : WorldObject, new()
{
foreach (var guid in guid_set)
{
T obj = new();
// Don't spawn at all if there's a respawn time
if ((obj.IsTypeId(TypeId.Unit) && map.GetCreatureRespawnTime(guid) == 0) || (obj.IsTypeId(TypeId.GameObject) && map.GetGORespawnTime(guid) == 0) || obj.IsTypeId(TypeId.AreaTrigger))
{
//TC_LOG_INFO("misc", "DEBUG: LoadHelper from table: %s for (guid: %u) Loading", table, guid);
if (obj.IsTypeId(TypeId.Unit))
{
CreatureData cdata = Global.ObjectMgr.GetCreatureData(guid);
Cypher.Assert(cdata != null, $"Tried to load creature with spawnId {guid}, but no such creature exists.");
SpawnGroupTemplateData group = cdata.spawnGroupData;
// If creature in manual spawn group, don't spawn here, unless group is already active.
if (!group.flags.HasAnyFlag(SpawnGroupFlags.System))
{
if (!map.IsSpawnGroupActive(group.groupId))
{
obj.Dispose();
continue;
}
}
}
else if (obj.IsTypeId(TypeId.GameObject))
{
// If gameobject in manual spawn group, don't spawn here, unless group is already active.
GameObjectData godata = Global.ObjectMgr.GetGameObjectData(guid);
Cypher.Assert(godata != null, $"Tried to load gameobject with spawnId {guid}, but no such object exists.");
if (!godata.spawnGroupData.flags.HasAnyFlag(SpawnGroupFlags.System))
{
if (!map.IsSpawnGroupActive(godata.spawnGroupData.groupId))
{
obj.Dispose();
continue;
}
}
}
if (!obj.LoadFromDB(guid, map, false, false))
{
obj.Dispose();
continue;
}
AddObjectHelper(cell, ref count, map, obj);
}
else
{
obj.Dispose();
}
}
}
public void Insert(int index, int value)
{
Cypher.Assert(index < 0x20);
_mask |= 1u << index;
if (_contents.Length <= index)
{
Array.Resize(ref _contents, index + 1);
}
_contents[index] = value;
}
GarrisonMap CreateGarrison(uint instanceId, Player owner)
{
lock (_mapLock)
{
GarrisonMap map = new GarrisonMap(GetId(), GetGridExpiry(), instanceId, this, owner.GetGUID());
Cypher.Assert(map.IsGarrison());
m_InstancedMaps[instanceId] = map;
return(map);
}
}
public override bool DoUpdate(Player owner, uint diff)
{
if (owner == null)
{
return(false);
}
// skipping the first spline path point because it's our starting point and not a taxi path point
uint pointId = (uint)(owner.MoveSpline.CurrentPathIdx() <= 0 ? 0 : owner.MoveSpline.CurrentPathIdx() - 1);
if (pointId > _currentNode && _currentNode < _path.Count - 1)
{
bool departureEvent = true;
do
{
Cypher.Assert(_currentNode < _path.Count, $"Point Id: {pointId}\n{owner.GetDebugInfo()}");
DoEventIfAny(owner, _path[_currentNode], departureEvent);
while (!_pointsForPathSwitch.Empty() && _pointsForPathSwitch[0].PathIndex <= _currentNode)
{
_pointsForPathSwitch.RemoveAt(0);
owner.m_taxi.NextTaxiDestination();
if (!_pointsForPathSwitch.Empty())
{
owner.UpdateCriteria(CriteriaType.MoneySpentOnTaxis, (uint)_pointsForPathSwitch[0].Cost);
owner.ModifyMoney(-_pointsForPathSwitch[0].Cost);
}
}
if (pointId == _currentNode)
{
break;
}
if (_currentNode == _preloadTargetNode)
{
PreloadEndGrid();
}
_currentNode += (departureEvent ? 1 : 0);
departureEvent = !departureEvent;
}while (_currentNode < _path.Count - 1);
}
if (_currentNode >= (_path.Count - 1))
{
AddFlag(MovementGeneratorFlags.InformEnabled);
return(false);
}
return(true);
}
// Create new link
public void link(TO toObj, FROM fromObj)
{
Cypher.Assert(fromObj != null); // fromObj MUST not be NULL
if (isValid())
{
unlink();
}
if (toObj != null)
{
_RefTo = toObj;
_RefFrom = fromObj;
targetObjectBuildLink();
}
}
// Selects proper template overload to call based on passed type
public uint IsPartOfAPool(SpawnObjectType type, ulong spawnId)
{
switch (type)
{
case SpawnObjectType.Creature:
return(IsPartOfAPool <Creature>(spawnId));
case SpawnObjectType.GameObject:
return(IsPartOfAPool <GameObject>(spawnId));
default:
Cypher.Assert(false, $"Invalid spawn type {type} passed to PoolMgr.IsPartOfPool (with spawnId {spawnId})");
return(0);
}
}
BattlegroundMap CreateBattleground(uint InstanceId, Battleground bg)
{
lock (_mapLock)
{
Log.outDebug(LogFilter.Maps, "MapInstanced.CreateBattleground: map bg {0} for {1} created.", InstanceId, GetId());
BattlegroundMap map = new BattlegroundMap(GetId(), (uint)GetGridExpiry(), InstanceId, this, Difficulty.None);
Cypher.Assert(map.IsBattlegroundOrArena());
map.SetBG(bg);
bg.SetBgMap(map);
m_InstancedMaps[InstanceId] = map;
return(map);
}
}
public bool Initialize(ObjectGuid guid, Player player = null)
{
CharacterInfo characterInfo = Global.WorldMgr.GetCharacterInfo(guid);
if (characterInfo == null)
{
return(false);
}
if (player)
{
Cypher.Assert(player.GetGUID() == guid);
AccountID = player.GetSession().GetAccountGUID();
BnetAccountID = player.GetSession().GetBattlenetAccountGUID();
Name = player.GetName();
RaceID = player.GetRace();
Sex = (Gender)player.GetByteValue(PlayerFields.Bytes3, PlayerFieldOffsets.Bytes3OffsetGender);
ClassID = player.GetClass();
Level = (byte)player.getLevel();
DeclinedName names = player.GetDeclinedNames();
if (names != null)
{
DeclinedNames = names;
}
}
else
{
uint accountId = ObjectManager.GetPlayerAccountIdByGUID(guid);
uint bnetAccountId = Global.BNetAccountMgr.GetIdByGameAccount(accountId);
AccountID = ObjectGuid.Create(HighGuid.WowAccount, accountId);
BnetAccountID = ObjectGuid.Create(HighGuid.BNetAccount, bnetAccountId);
Name = characterInfo.Name;
RaceID = characterInfo.RaceID;
Sex = characterInfo.Sex;
ClassID = characterInfo.ClassID;
Level = characterInfo.Level;
}
IsDeleted = characterInfo.IsDeleted;
GuidActual = guid;
VirtualRealmAddress = Global.WorldMgr.GetVirtualRealmAddress();
return(true);
}
public bool Initialize(ObjectGuid guid, Player player = null)
{
CharacterCacheEntry characterInfo = Global.CharacterCacheStorage.GetCharacterCacheByGuid(guid);
if (characterInfo == null)
{
return(false);
}
if (player)
{
Cypher.Assert(player.GetGUID() == guid);
AccountID = player.GetSession().GetAccountGUID();
BnetAccountID = player.GetSession().GetBattlenetAccountGUID();
Name = player.GetName();
RaceID = player.GetRace();
Sex = player.GetNativeSex();
ClassID = player.GetClass();
Level = (byte)player.GetLevel();
DeclinedName names = player.GetDeclinedNames();
if (names != null)
{
DeclinedNames = names;
}
}
else
{
uint accountId = Global.CharacterCacheStorage.GetCharacterAccountIdByGuid(guid);
uint bnetAccountId = Global.BNetAccountMgr.GetIdByGameAccount(accountId);
AccountID = ObjectGuid.Create(HighGuid.WowAccount, accountId);
BnetAccountID = ObjectGuid.Create(HighGuid.BNetAccount, bnetAccountId);
Name = characterInfo.Name;
RaceID = characterInfo.RaceId;
Sex = characterInfo.Sex;
ClassID = characterInfo.ClassId;
Level = characterInfo.Level;
}
IsDeleted = characterInfo.IsDeleted;
GuidActual = guid;
VirtualRealmAddress = Global.WorldMgr.GetVirtualRealmAddress();
return(true);
}
InstanceMap CreateInstance(uint InstanceId, InstanceSave save, Difficulty difficulty, int teamId)
{
lock (_mapLock)
{
// make sure we have a valid map id
MapRecord entry = CliDB.MapStorage.LookupByKey(GetId());
if (entry == null)
{
Log.outError(LogFilter.Maps, "CreateInstance: no record for map {0}", GetId());
Cypher.Assert(false);
}
InstanceTemplate iTemplate = Global.ObjectMgr.GetInstanceTemplate(GetId());
if (iTemplate == null)
{
Log.outError(LogFilter.Maps, "CreateInstance: no instance template for map {0}", GetId());
Cypher.Assert(false);
}
// some instances only have one difficulty
Global.DB2Mgr.GetDownscaledMapDifficultyData(GetId(), ref difficulty);
Log.outDebug(LogFilter.Maps, "MapInstanced.CreateInstance: {0} map instance {1} for {2} created with difficulty {3}", save != null ? "" : "new ", InstanceId, GetId(), difficulty);
InstanceMap map = new InstanceMap(GetId(), GetGridExpiry(), InstanceId, difficulty, this);
Cypher.Assert(map.IsDungeon());
map.LoadRespawnTimes();
map.LoadCorpseData();
bool load_data = save != null;
map.CreateInstanceData(load_data);
InstanceScenario instanceScenario = Global.ScenarioMgr.CreateInstanceScenario(map, teamId);
if (instanceScenario != null)
{
map.SetInstanceScenario(instanceScenario);
}
if (WorldConfig.GetBoolValue(WorldCfg.InstancemapLoadGrids))
{
map.LoadAllCells();
}
m_InstancedMaps[InstanceId] = map;
return(map);
}
}
public static bool IsValidProcess(Unit hatedUnit, Unit hatingUnit, SpellInfo threatSpell = null)
{
//function deals with adding threat and adding players and pets into ThreatList
//mobs, NPCs, guards have ThreatList and HateOfflineList
//players and pets have only InHateListOf
//HateOfflineList is used co contain unattackable victims (in-flight, in-water, GM etc.)
if (hatedUnit == null || hatingUnit == null)
{
return(false);
}
// not to self
if (hatedUnit == hatingUnit)
{
return(false);
}
// not to GM
if (hatedUnit.IsTypeId(TypeId.Player) && hatedUnit.ToPlayer().IsGameMaster())
{
return(false);
}
// not to dead and not for dead
if (!hatedUnit.IsAlive() || !hatingUnit.IsAlive())
{
return(false);
}
// not in same map or phase
if (!hatedUnit.IsInMap(hatingUnit) || !hatedUnit.IsInPhase(hatingUnit))
{
return(false);
}
// spell not causing threat
if (threatSpell != null && threatSpell.HasAttribute(SpellAttr1.NoThreat))
{
return(false);
}
Cypher.Assert(hatingUnit.IsTypeId(TypeId.Unit));
return(true);
}
public bool getObjectHitPos(Vector3 startPos, Vector3 endPos, ref Vector3 resultHitPos, float modifyDist, PhaseShift phaseShift)
{
bool result = false;
float maxDist = (endPos - startPos).magnitude();
// valid map coords should *never ever* produce float overflow, but this would produce NaNs too
Cypher.Assert(maxDist < float.MaxValue);
// prevent NaN values which can cause BIH intersection to enter infinite loop
if (maxDist < 1e-10f)
{
resultHitPos = endPos;
return(false);
}
Vector3 dir = (endPos - startPos) / maxDist; // direction with length of 1
Ray ray = new Ray(startPos, dir);
float dist = maxDist;
if (getIntersectionTime(ray, endPos, phaseShift, dist))
{
resultHitPos = startPos + dir * dist;
if (modifyDist < 0)
{
if ((resultHitPos - startPos).magnitude() > -modifyDist)
{
resultHitPos += dir * modifyDist;
}
else
{
resultHitPos = startPos;
}
}
else
{
resultHitPos += dir * modifyDist;
}
result = true;
}
else
{
resultHitPos = endPos;
result = false;
}
return(result);
}
public override void MovementInform(MovementGeneratorType moveType, uint Id)
{
// no action allowed if there is no escort
if (!HasEscortState(EscortState.Escorting))
{
return;
}
//Combat start position reached, continue waypoint movement
if (moveType == MovementGeneratorType.Point)
{
if (_pauseTimer == 0)
{
_pauseTimer = 2000;
}
if (Id == EscortPointIds.LastPoint)
{
Log.outDebug(LogFilter.Scripts, "EscortAI.MovementInform has returned to original position before combat");
me.SetWalk(!_running);
RemoveEscortState(EscortState.Returning);
}
else if (Id == EscortPointIds.Home)
{
Log.outDebug(LogFilter.Scripts, "EscortAI.MovementInform: returned to home location and restarting waypoint path");
_started = false;
}
}
else if (moveType == MovementGeneratorType.Waypoint)
{
Cypher.Assert(Id < _path.nodes.Count, $"EscortAI.MovementInform: referenced movement id ({Id}) points to non-existing node in loaded path");
WaypointNode waypoint = _path.nodes[(int)Id];
Log.outDebug(LogFilter.Scripts, $"EscortAI.MovementInform: waypoint node {waypoint.id} reached");
// last point
if (Id == _path.nodes.Count - 1)
{
_started = false;
_ended = true;
_pauseTimer = 1000;
}
}
}
void SendSplineFor(Unit me, int index, uint toNext)
{
Cypher.Assert(index < _chainSize);
Log.outDebug(LogFilter.Movement, "{0}: Sending spline for {1}.", me.GetGUID().ToString(), index);
SplineChainLink thisLink = _chain[index];
uint actualDuration = SendPathSpline(me, new Span <Vector3>(thisLink.Points.ToArray()));
if (actualDuration != thisLink.ExpectedDuration)
{
Log.outDebug(LogFilter.Movement, "{0}: Sent spline for {1}, duration is {2} ms. Expected was {3} ms (delta {4} ms). Adjusting.", me.GetGUID().ToString(), index, actualDuration, thisLink.ExpectedDuration, actualDuration - thisLink.ExpectedDuration);
toNext = (uint)(actualDuration / thisLink.ExpectedDuration * toNext);
}
else
{
Log.outDebug(LogFilter.Movement, "{0}: Sent spline for {1}, duration is {2} ms.", me.GetGUID().ToString(), index, actualDuration);
}
}
uint SendPathSpline(Unit me, Span <Vector3> wp)
{
int numWp = wp.Length;
Cypher.Assert(numWp > 1, "Every path must have source & destination");
MoveSplineInit init = new MoveSplineInit(me);
if (numWp > 2)
{
init.MovebyPath(wp.ToArray());
}
else
{
init.MoveTo(wp[1], false, true);
}
init.SetWalk(_walk);
return((uint)init.Launch());
}
public override bool GetResetPosition(Unit owner, out float x, out float y, out float z)
{
x = y = z = 0;
// prevent a crash at empty waypoint path.
if (_path == null || _path.nodes.Empty())
{
return(false);
}
Cypher.Assert(_currentNode < _path.nodes.Count, $"WaypointMovementGenerator::GetResetPosition: tried to reference a node id ({_currentNode}) which is not included in path ({_path.id})");
WaypointNode waypoint = _path.nodes.ElementAt(_currentNode);
x = waypoint.x;
y = waypoint.y;
z = waypoint.z;
return(true);
}
public bool GetObjectHitPos(Vector3 pPos1, Vector3 pPos2, out Vector3 pResultHitPos, float pModifyDist)
{
bool result;
float maxDist = (pPos2 - pPos1).magnitude();
// valid map coords should *never ever* produce float overflow, but this would produce NaNs too
Cypher.Assert(maxDist < float.MaxValue);
// prevent NaN values which can cause BIH intersection to enter infinite loop
if (maxDist < 1e-10f)
{
pResultHitPos = pPos2;
return(false);
}
Vector3 dir = (pPos2 - pPos1) / maxDist; // direction with length of 1
Ray ray = new Ray(pPos1, dir);
float dist = maxDist;
if (GetIntersectionTime(ray, ref dist, false, ModelIgnoreFlags.Nothing))
{
pResultHitPos = pPos1 + dir * dist;
if (pModifyDist < 0)
{
if ((pResultHitPos - pPos1).magnitude() > -pModifyDist)
{
pResultHitPos += dir * pModifyDist;
}
else
{
pResultHitPos = pPos1;
}
}
else
{
pResultHitPos += dir * pModifyDist;
}
result = true;
}
else
{
pResultHitPos = pPos2;
result = false;
}
return(result);
}
