public void FaceUnit(WowPlayer player, WowPosition positionToFace)
{
float angle = BotMath.GetFacingAngle(player.Position, positionToFace);
TrashMem.Write(player.BaseAddress + OffsetList.OffsetPlayerRotation, angle);
SendKey(new IntPtr(0x41), 0, 0); // the "S" key to go a bit backwards TODO: find better method 0x53
}
public MirrorImageData(WowPlayer source, WowGuid destination)
{
this.Entity = destination;
this.Model = source.Model;
this.Race = source.Race;
this.Gender = source.Gender;
this.Class = source.Class;
this.Skin = source.Skin;
this.Face = source.Face;
this.Hair = source.HairStyle;
this.HairColor = source.HairColor;
this.FaceFeatures = source.FaceFeatures;
this.Guild = new WowGuid(source.GetULong(ObjectUpdateFields.OBJECT_FIELD_DATA));
this.Head = source.GetVisibleItemEntry(InventorySlot.Head);
this.Shoulders = source.GetVisibleItemEntry(InventorySlot.Shoulders);
this.Body = source.GetVisibleItemEntry(InventorySlot.Body);
this.Chest = source.GetVisibleItemEntry(InventorySlot.Chest);
this.Waist = source.GetVisibleItemEntry(InventorySlot.Waist);
this.Legs = source.GetVisibleItemEntry(InventorySlot.Legs);
this.Feet = source.GetVisibleItemEntry(InventorySlot.Feet);
this.Wrists = source.GetVisibleItemEntry(InventorySlot.Wrists);
this.Hands = source.GetVisibleItemEntry(InventorySlot.Hands);
this.Back = source.GetVisibleItemEntry(InventorySlot.Back);
this.Tabard = source.GetVisibleItemEntry(InventorySlot.Tabard);
}
public bool CompareItems(IItem newItem, IItem currentItem)
{
WowPlayer player = (WowPlayer)ObjectManager.GetWowObjectByGuid(WowDataAdapter.PlayerGuid);
return(ItemUtils.IsItemUsefulForMe(player, newItem) &&
newItem.ItemLevel > currentItem.ItemLevel);
}
public static bool IsArmorEquipableForCharacter(WowPlayer wowPlayer, ArmorItem item)
{
// TODO: handle class specific items
if (item.ArmorType == ArmorType.MISCELLANEOUS)
{
return(true);
}
switch (wowPlayer.Class)
{
case WowClass.DeathKnight: return(item.ArmorType == ArmorType.PLATE);
case WowClass.Druid: return(item.ArmorType == ArmorType.LEATHER);
case WowClass.Hunter: return(wowPlayer.Level < 40 ? item.ArmorType == ArmorType.LEATHER : item.ArmorType == ArmorType.MAIL);
case WowClass.Mage: return(item.ArmorType == ArmorType.CLOTH);
case WowClass.Paladin: return(wowPlayer.Level < 40 ? item.ArmorType == ArmorType.MAIL : item.ArmorType == ArmorType.PLATE);
case WowClass.Priest: return(item.ArmorType == ArmorType.CLOTH);
case WowClass.Rogue: return(item.ArmorType == ArmorType.LEATHER);
case WowClass.Shaman: return(wowPlayer.Level < 40 ? item.ArmorType == ArmorType.LEATHER : item.ArmorType == ArmorType.MAIL);
case WowClass.Warlock: return(item.ArmorType == ArmorType.CLOTH);
case WowClass.Warrior: return(wowPlayer.Level < 40 ? item.ArmorType == ArmorType.MAIL : item.ArmorType == ArmorType.PLATE);
}
return(false);
}
public WowPlayer ReadWowPlayer(uint activeObject, WowObjectType wowObjectType = WowObjectType.Player)
{
WowUnit wowUnit = ReadWowUnit(activeObject, wowObjectType);
WowPlayer player = new WowPlayer()
{
BaseAddress = activeObject,
DescriptorAddress = wowUnit.DescriptorAddress,
Guid = wowUnit.Guid,
Type = wowObjectType,
Name = ReadPlayerName(wowUnit.Guid),
TargetGuid = wowUnit.TargetGuid,
Position = wowUnit.Position,
FactionTemplate = wowUnit.FactionTemplate,
UnitFlags = wowUnit.UnitFlags,
UnitFlagsDynamic = wowUnit.UnitFlagsDynamic,
Health = wowUnit.Health,
MaxHealth = wowUnit.MaxHealth,
Energy = wowUnit.Energy,
MaxEnergy = wowUnit.MaxEnergy,
Level = wowUnit.Level,
CurrentlyCastingSpellId = wowUnit.CurrentlyCastingSpellId,
CurrentlyChannelingSpellId = wowUnit.CurrentlyChannelingSpellId
};
if (wowUnit.Guid == PlayerGuid)
{
player.Exp = ReadInt(wowUnit.DescriptorAddress + OffsetList.DescriptorOffsetExp);
player.MaxExp = ReadInt(wowUnit.DescriptorAddress + OffsetList.DescriptorOffsetMaxExp);
player.Race = (WowRace)ReadByte(OffsetList.StaticRace);
player.Class = (WowClass)ReadByte(OffsetList.StaticClass);
PlayerBase = activeObject;
}
return(player);
}
public void OnStart(GameInterface game)
{
this.game = game;
SettingsInstance = this.LoadSettingsJSON <Settings>();
WoWPlayerMe locaPlayer = game.GetGameObjects(null, players, npcs);
WowPlayer myTargetPlayer = players.FirstOrDefault(i => i.Health > 0 && i.GUID == locaPlayer.TargetGUID);
WowNpc myTargetNpc = npcs.FirstOrDefault(i => i.Health > 0 && i.GUID == locaPlayer.TargetGUID);
if (myTargetPlayer != null)
{
guid = myTargetPlayer.GUID;
}
else if (myTargetNpc != null)
{
guid = myTargetNpc.GUID;
}
else
{
this.LogPrint("Unit isn't found!");
}
libNavigator = Utilities.GetReferenceOfPlugin("LibNavigator");
if (libNavigator == null)
{
this.ShowNotify("LibNavigator isn't found! Plugin will not work.", true, true);
this.LogPrint("LibNavigator isn't found! Plugin will not work.");
return;
}
(timer = this.CreateTimer(500, game, OnPulse)).Start();
}
public WowMeBlip(WowPlayer unit) : base(unit)
{
MouseDown += RecordPosition;
MouseMove += MoveScreen;
FillContextMenu();
}
private WowPlayer ReadWowPlayer(IntPtr activeObject, WowObjectType wowObjectType)
{
if (WowInterface.XMemory.Read(IntPtr.Add(activeObject, WowInterface.OffsetList.WowObjectDescriptor.ToInt32()), out IntPtr descriptorAddress) &&
WowInterface.XMemory.ReadStruct(IntPtr.Add(activeObject, WowInterface.OffsetList.WowUnitPosition.ToInt32()), out Vector3 position))
{
WowPlayer player = new WowPlayer(activeObject, wowObjectType)
{
DescriptorAddress = descriptorAddress,
Position = position
};
// First read the descriptor, then lookup the Name by GUID
player.UpdateRawWowPlayer(WowInterface.XMemory);
player.Name = ReadPlayerName(player.Guid);
player.Auras = WowInterface.HookManager.GetUnitAuras(activeObject);
if (PlayerGuid != 0 && player.Guid == PlayerGuid)
{
if (WowInterface.XMemory.Read(WowInterface.OffsetList.ComboPoints, out byte comboPoints))
{
player.ComboPoints = comboPoints;
}
Player = player;
}
return(player);
}
return(null);
}
public void UpdatePlayerRelationship(WowPlayer player)
{
if (IsPlayerKnown(player))
{
PlayerRelationships[player.Guid].Poll(player);
}
}
public bool IsUnitToFollowThere()
{
WowPlayer playerToFollow = null;
// TODO: make this crap less redundant
// check the specific character
List <WowPlayer> wowPlayers = WowInterface.ObjectManager.WowObjects.OfType <WowPlayer>().ToList();
if (wowPlayers.Count > 0)
{
if (Config.FollowSpecificCharacter)
{
playerToFollow = wowPlayers.FirstOrDefault(p => p.Name == Config.SpecificCharacterToFollow);
playerToFollow = SkipIfOutOfRange(playerToFollow);
}
// check the group/raid leader
if (playerToFollow == null && Config.FollowGroupLeader)
{
playerToFollow = wowPlayers.FirstOrDefault(p => p.Guid == WowInterface.ObjectManager.PartyleaderGuid);
playerToFollow = SkipIfOutOfRange(playerToFollow);
}
// check the group members
if (playerToFollow == null && Config.FollowGroupMembers)
{
playerToFollow = wowPlayers.FirstOrDefault(p => WowInterface.ObjectManager.PartymemberGuids.Contains(p.Guid));
playerToFollow = SkipIfOutOfRange(playerToFollow);
}
}
return(playerToFollow != null);
}
public bool AttackNearEnemies(double range = 25)
{
IEnumerable <WowPlayer> nearEnemies = WowInterface.ObjectManager.GetNearEnemies <WowPlayer>(WowInterface.ObjectManager.Player.Position, range);
if (nearEnemies.Count() > 0)
{
WowPlayer target = nearEnemies.FirstOrDefault(e => BotUtils.IsValidUnit(e));
if (target != null)
{
if (WowInterface.ObjectManager.Player.Position.GetDistance(target.Position) > 10)
{
WowInterface.MovementEngine.SetState(MovementEngineState.Moving, target.Position);
WowInterface.MovementEngine.Execute();
return(true);
}
else
{
WowInterface.HookManager.TargetGuid(target.Guid);
WowInterface.HookManager.StartAutoAttack(WowInterface.ObjectManager.Target);
return(true);
}
}
}
return(false);
}
private void ReadObjectCreateUpdate(StreamHandler Reader)
{
var guid = Reader.ReadPackedGuid();
var type = (ObjectTypeId)Reader.ReadByte();
WowObject obj;
switch (type)
{
case ObjectTypeId.Container:
obj = new WowContainer();
break;
case ObjectTypeId.Corpse:
obj = new WowCorpse();
break;
case ObjectTypeId.DynamicObject:
obj = new WowDynamicObject();
break;
case ObjectTypeId.GameObject:
obj = new WowGameObject();
break;
case ObjectTypeId.Item:
obj = new WowItem();
break;
case ObjectTypeId.Object:
default:
throw new Exception("Cannot instantiate an object with TypeId=" + type);
case ObjectTypeId.Player:
obj = new WowPlayer();
break;
case ObjectTypeId.Unit:
obj = new WowUnit();
break;
case ObjectTypeId.AreaTrigger:
obj = new WowAreaTrigger();
break;
}
obj.Guid = guid;
obj.MovementData = new MovementInfo(Reader);
obj.SetValues(ReadValues(Reader));
obj.ResetUpdatedFields();
if (!m_createdObjects.ContainsKey(guid))
{
m_createdObjects.Add(guid, obj);
}
else
{
Console.WriteLine("Error: Created object duplicate guid {0}", guid);
}
}
private BehaviorTreeStatus AttackNearWeakestEnemy(CtfBlackboard blackboard)
{
WowPlayer weakestPlayer = WowInterface.ObjectManager.GetNearEnemies <WowPlayer>(WowInterface.ObjectManager.Player.Position, 20.0).OrderBy(e => e.Health).FirstOrDefault();
if (weakestPlayer != null)
{
double distance = weakestPlayer.Position.GetDistance(WowInterface.ObjectManager.Player.Position);
double threshold = WowInterface.CombatClass.IsMelee ? 3.0 : 28.0;
if (distance > threshold)
{
WowInterface.MovementEngine.SetMovementAction(MovementAction.Move, weakestPlayer.Position);
}
else if (ActionEvent.Run())
{
WowInterface.Globals.ForceCombat = true;
WowInterface.HookManager.WowTargetGuid(weakestPlayer.Guid);
}
}
else
{
return(BehaviorTreeStatus.Failed);
}
return(BehaviorTreeStatus.Ongoing);
}
public List <IAbility> Solution_BattlePreparing_withpeoplehirt()
{
Target = friendsAndme.FirstOrDefault(x => x.HealthPercentage < 95 && (RejuvenationCheck_checkthetarget(x) == true || Lifebloom_use_check == true || x.HealthPercentage < Regrowth_healthcheck));
if (Target != null)
{
if (Target.HealthPercentage < Regrowth_healthcheck)
{
Regrowth_use_check = true;
}
else
{
Regrowth_use_check = false;
}
if (Target.HealthPercentage < HealingTouch_HeallthCheck && FengRao >= 7)
{
Healingtouch_use_check = true;
}
else
{
Healingtouch_use_check = false;
}
return(LeveL1_Healting);
}
else
{
return(Solution_BattlePreparing());
}
}
//获得用于战斗逻辑的各项战斗条件
public void UpdateEnvironment()
{
Target = null;
MycurrentTarget = null;
//各类单位集合更新数据
Me = Game.Instance.Player;
players = Game.Instance.Manager.Objects.OfType <WowPlayer>().Where(x => x.Distance < 40 && x.InLoS).ToList();
foreach (var player in players)
{
player.Update();
}
friends = players.Where(x => x.IsFriendly).ToList();
friendsAndme = friends;
friendsAndme.Add(Me);
friendsAndme.Sort(CompareByHeathPercentage);
//血量最低队友
lowestHealthFriend = friendsAndme.First();
//更新血量低于70%的队友数量
lowhealthfriendCOunt = friendsAndme.Where(x => x.HealthPercentage < 70).Count();
enemies = players.Where(x => x.IsHostile).ToList();
MycurrentTarget = Me.GetTargetUnit();
MycurrentTarget.Update();//必须刷新，之前没刷新过
RejuventurationCount = Me.GetAura(207640).StackCount;
//更新生命绽放使用条件
PVE_Checks_Update();
}
private static void Pulse()
{
var objectManager = _reader.ReadUInt((uint)Offsets.WowObjectManager.BASE);
var currentObject = _reader.ReadUInt(objectManager + (uint)Offsets.WowObjectManager.FIRST_OBJECT);
var activeGuidList = new List <ulong>();
while (currentObject != 0 && (currentObject & 1) == 0)
{
var objectType = _reader.ReadByte(currentObject + (uint)Offsets.WowObject.OBJECT_FIELD_TYPE);
switch (objectType)
{
case (byte)ObjectType.Unit:
{
var unit = new WowUnit(_reader, currentObject);
_objects.GetOrAdd(unit.Guid, unit);
activeGuidList.Add(unit.Guid);
break;
}
case (byte)ObjectType.Player:
{
var player = new WowPlayer(_process, _reader, currentObject);
_objects.GetOrAdd(player.Guid, player);
activeGuidList.Add(player.Guid);
break;
}
case (byte)ObjectType.Item:
{
break;
}
case (byte)ObjectType.GameObject:
{
var obj = new WowGameObject(_reader, currentObject);
_objects.GetOrAdd(obj.Guid, obj);
activeGuidList.Add(obj.Guid);
break;
}
}
var nextObject = _reader.ReadUInt(currentObject + (uint)Offsets.WowObjectManager.NEXT_OBJECT);
if (nextObject == currentObject)
{
break;
}
currentObject = nextObject;
}
var deadGuids = _objects.Keys.Where(k => !activeGuidList.Contains(k)).Select(k => k);
foreach (var guid in deadGuids)
{
IWowObject deadObject;
_objects.TryRemove(guid, out deadObject);
}
}
public WowPlayer ReadWowPlayer(IntPtr activeObject, WowObjectType wowObjectType = WowObjectType.Player)
{
WowUnit wowUnit = ReadWowUnit(activeObject, wowObjectType);
if (wowUnit != null)
{
WowPlayer player = new WowPlayer()
{
BaseAddress = activeObject,
CombatReach = wowUnit.CombatReach,
DescriptorAddress = wowUnit.DescriptorAddress,
Guid = wowUnit.Guid,
Type = wowObjectType,
Name = ReadPlayerName(wowUnit.Guid),
TargetGuid = wowUnit.TargetGuid,
Position = wowUnit.Position,
Rotation = wowUnit.Rotation,
FactionTemplate = wowUnit.FactionTemplate,
UnitFlags = wowUnit.UnitFlags,
UnitFlagsDynamic = wowUnit.UnitFlagsDynamic,
Health = wowUnit.Health,
MaxHealth = wowUnit.MaxHealth,
Mana = wowUnit.Mana,
MaxMana = wowUnit.MaxMana,
Energy = wowUnit.Energy,
MaxEnergy = wowUnit.MaxEnergy,
Rage = wowUnit.Rage,
MaxRage = wowUnit.MaxRage,
Runeenergy = wowUnit.Runeenergy,
MaxRuneenergy = wowUnit.MaxRuneenergy,
Level = wowUnit.Level,
Race = wowUnit.Race,
Class = wowUnit.Class,
Gender = wowUnit.Gender,
PowerType = wowUnit.PowerType,
IsAutoAttacking = wowUnit.IsAutoAttacking,
CurrentlyCastingSpellId = wowUnit.CurrentlyCastingSpellId,
CurrentlyChannelingSpellId = wowUnit.CurrentlyChannelingSpellId
};
if (PlayerGuid != 0 && wowUnit.Guid == PlayerGuid)
{
if (XMemory.Read(IntPtr.Add(wowUnit.DescriptorAddress, OffsetList.DescriptorExp.ToInt32()), out int exp) &&
XMemory.Read(IntPtr.Add(wowUnit.DescriptorAddress, OffsetList.DescriptorMaxExp.ToInt32()), out int maxExp) &&
XMemory.Read(OffsetList.ComboPoints, out byte comboPoints))
{
player.Exp = exp;
player.MaxExp = maxExp;
player.ComboPoints = comboPoints;
}
Player = player;
}
return(player);
}
return(null);
}
protected override void DoExit(WowPlayer Entity)
{
//on exit, if there is a previous state, go back to it
if (PreviousState != null)
{
CallChangeStateEvent(Entity, PreviousState, false, false);
}
}
public void FacePosition(WowPlayer player, Vector3 positionToFace)
{
float angle = BotMath.GetFacingAngle(player.Position, positionToFace);
SetFacing(player, angle);
// buggy atm
// SendMovementPacket(player, 0xDA);
}
private void SetProgressbarToClassColor(WowPlayer player)
{
switch (player.Class)
{
case WowClass.DeathKnight:
progressbarBothealth.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#C41F3B"));
progressbarBotenergy.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FF8FFFEB"));
break;
case WowClass.Druid:
progressbarBothealth.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FF7D0A"));
progressbarBotenergy.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FF8FC2FF"));
break;
case WowClass.Hunter:
progressbarBothealth.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#ABD473"));
progressbarBotenergy.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FF8FC2FF"));
break;
case WowClass.Mage:
progressbarBothealth.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#69CCF0"));
progressbarBotenergy.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FF8FC2FF"));
break;
case WowClass.Paladin:
progressbarBothealth.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#F58CBA"));
progressbarBotenergy.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FF8FC2FF"));
break;
case WowClass.Priest:
progressbarBothealth.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FFFFFF"));
progressbarBotenergy.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FF8FC2FF"));
break;
case WowClass.Rogue:
progressbarBothealth.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FFF569"));
progressbarBotenergy.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FFFFF88F"));
break;
case WowClass.Shaman:
progressbarBothealth.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#0070DE"));
progressbarBotenergy.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FF8FC2FF"));
break;
case WowClass.Warlock:
progressbarBothealth.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#9482C9"));
progressbarBotenergy.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FF8FC2FF"));
break;
case WowClass.Warrior:
progressbarBothealth.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#C79C6E"));
progressbarBotenergy.Foreground = new SolidColorBrush((Color)ColorConverter.ConvertFromString("#FFE6E6E6"));
break;
default:
break;
}
}
public bool IsMeInCombat()
{
WowPlayer player = ((WowPlayer)ObjectManager.GetWowObjectByGuid(WowDataAdapter.PlayerGuid));
if (player != null)
{
return(player.IsInCombat);
}
return(false);
}
protected override void DoEnter(WowPlayer Entity)
{
base.DoEnter(Entity);
Output.Instance.Script("Core.DoEnter() -- Begin", this);
// We override the default states with our own
inCombatState = new Paladin.InCombatState();
restState = new Paladin.RestState();
Output.Instance.Script("Core.DoEnter() -- End", this);
}
private BehaviorTreeStatus FollowNearestUnit(GhostBlackboard blackboard)
{
WowPlayer player = blackboard.PlayerToFollow;
if (WowInterface.Player.Position.GetDistance(player.Position) > Config.MinFollowDistance)
{
WowInterface.MovementEngine.SetMovementAction(MovementAction.Move, player.Position);
}
return(BehaviorTreeStatus.Ongoing);
}
public static void Emergency(WowPlayer player)
{
if (!player.IsCasting("Holy Light") && !player.IsCasting("Flash of Light"))
{
if (!player.HasBuff("Forbearance"))
{
if (player.CanCast("Divine Protection"))
{
if (player.CanCast("Divine Shield") && divineShield)
{
player.SpellStopCasting();
player.CastSpellByName("Divine Shield");
}
else
{
player.SpellStopCasting();
player.CastSpellByName("Divine Protection");
}
HealSystem(player);
}
else if (player.CanCast("Blessing of Protection"))
{
player.SpellStopCasting();
player.CastSpellByName("Blessing of Protection");
HealSystem(player);
}
}
if (!player.HasBuff(emBless) && player.CanCast(emBless) && emergBless)
{
player.CastSpellByName(emBless);
}
if (player.CanCast("Lay on Hands") && !player.HasBuff("Forbearance"))
{
player.SpellStopCasting();
player.CastSpellByName("Lay on Hands");
}
if (player.HasBuff("Forbearance"))
{
if (player.CanCast("Lay on Hands") && player.HpPct < 24)
{
player.SpellStopCasting();
player.CastSpellByName("Lay on Hands");
}
}
if (player.HpPct < MinHPPct)
{
HealSystem(player);
}
}
}
public bool TryGetPlayerRelationship(WowPlayer player, out Relationship relationship)
{
if (PlayerRelationships.ContainsKey(player.Guid))
{
relationship = PlayerRelationships[player.Guid];
return(true);
}
relationship = default;
return(false);
}
private static void InitializePlayer()
{
ObjectManager = new ObjectManager();
Player = new WowPlayer(ObjectManager.GetLocalPlayerObject());
Player.SetCurrentMapInfo();
Player.SetCharInfo();
if (WoWInGame != null)
{
WoWInGame();
}
}
protected void SelfHeal(WowPlayer player)
{
Output.Instance.Script("SelfHeal()", this);
foreach (var spell in HealingSpells)
{
if (!spell.IsOnCooldown() && (spell.Cost < player.Mp))
{
Output.Instance.Script("SelfHeal() - Casting " + spell.Name, this);
player.CastSpellByName(spell.Name, true);
}
}
}
public void ClickToMove(WowPlayer player, Vector3 position)
{
if (WowInterface.XMemory.AllocateMemory(12, out IntPtr codeCaveVector3))
{
WowInterface.XMemory.Write(codeCaveVector3, position);
CallObjectFunction(player.BaseAddress, WowInterface.OffsetList.FunctionPlayerClickToMove, new List <object>()
{
codeCaveVector3.ToInt32()
});
WowInterface.XMemory.FreeMemory(codeCaveVector3);
}
}
private WowPlayer SkipIfOutOfRange(WowPlayer playerToFollow)
{
if (playerToFollow != null)
{
double distance = playerToFollow.Position.GetDistance(WowInterface.ObjectManager.Player.Position);
if (UnitIsOutOfRange(distance))
{
playerToFollow = null;
}
}
return(playerToFollow);
}
public PlayerRelationship GetPlayerRelationship(WowPlayer player, bool rememberIfUnknown = true)
{
if (RememberedUnits.ContainsKey(player.Guid))
{
return((PlayerRelationship)((int)Math.Round(RememberedUnits[player.Guid])));
}
else if (rememberIfUnknown)
{
RememberedUnits.Add(player.Guid, 0);
}
return(PlayerRelationship.Unknown);
}
