/// <summary>
/// Unblacklists the specified target.
/// </summary>
/// <param name = "target">The target.</param>
public static void Unblacklist(PUnit target)
{
if (target == null) return;
lock (blacklist)
{
blacklist.Remove("GUID" + target.GUID);
}
Logging.Write("Removed: '" + target.GUID + " from badlist'");
}
/// <summary>
/// Blacklists the specified target.
/// </summary>
/// <param name = "target">The target.</param>
/// <param name = "length">The length.</param>
/// <param name = "writeText">if set to <c>true</c> [write text].</param>
public static void Blacklist(PUnit target, uint length, bool writeText)
{
if (target == null) return;
lock (blacklist)
{
blacklist["GUID" + target.GUID] = DateTime.Now.AddSeconds(length);
}
if (writeText)
Logging.Write("Added GUID: '" + target.GUID + "' to bad list for " + length + " seconds");
}
// ReSharper restore InconsistentNaming
/// <summary>
/// Determines whether the specified target is blacklisted.
/// </summary>
/// <param name = "target">The target.</param>
/// <returns>
/// <c>true</c> if the specified target is blacklisted; otherwise, <c>false</c>.
/// </returns>
public static bool IsBlacklisted(PUnit target)
{
try
{
if (target != null && blacklist.ContainsKey("GUID" + target.GUID))
{
TimeSpan diff = blacklist["GUID" + target.GUID] - DateTime.Now;
if (diff.TotalSeconds > 0) return true;
Unblacklist(target);
}
}
catch (Exception e)
{
Logging.Write("PPullBlackList: " + e);
}
return false;
}
public static Reaction GetReaction(PUnit localObj, PUnit mobObj)
{
try
{
if (localObj.Faction < 1 || mobObj.Faction < 1)
{
return Reaction.Missing;
}
return FindReactionFromFactions(localObj.Faction, mobObj.Faction);
}
catch (Exception)
{
//Logging.Write("Exception when comparing: " + localObj.Name + " : " + mobObj.Name);
return Reaction.Missing;
}
}
public static void DoSell(PUnit vendor)
{
try
{
ProtectedList.Load();
MailList.Load();
MoveHelper.MoveToUnit(vendor, 3);
vendor.Location.Face();
vendor.Interact(false);
Thread.Sleep(1000);
if(ObjectManager.MyPlayer.Target != vendor)
{
vendor.Location.Face();
vendor.Interact(false);
Thread.Sleep(1000);
}
//MouseHelper.Hook();
//MailManager.OpenAllBags();
if (LazySettings.ShouldVendor)
{
Logging.Write("[Vendor]Going to sell items");
//Sell();
}
if (LazySettings.ShouldRepair)
{
Repair();
}
} finally
{
MailManager.CloseAllBags();
MouseHelper.ReleaseMouse();
if (SellFinished != null)
{
SellFinished("VendorEngine", new EventArgs());
}
}
}
/// <summary>
/// Targetings me or my pet.
/// </summary>
/// <param name = "u">The unit.</param>
/// <returns></returns>
public static bool TargetingMeOrPet(PUnit u)
{
if (u == null || MyPlayer == null)
{
return false;
}
if (u.TargetGUID == MyPlayer.GUID)
{
return true;
}
if (!MyPlayer.HasLivePet)
{
return false;
}
if (u.TargetGUID == MyPlayer.PetGUID)
{
return true;
}
return false;
}
private static void ReadObjectList()
{
var currentObject = new PObject(Memory.Read<uint>(CurrentManager + (uint) Pointers.ObjectManager.FirstObject));
LocalGUID = Memory.Read<UInt64>(CurrentManager + (uint) Pointers.ObjectManager.LocalGUID);
while (currentObject.BaseAddress != UInt32.MinValue &&
currentObject.BaseAddress%2 == UInt32.MinValue)
{
// Keep the static reference to the local player updated... at all times.
if (currentObject.GUID == LocalGUID)
{
//MessageBox.Show("Found localplayer! 0x" + currentObject.ToString("X8"));
MyPlayer.UpdateBaseAddress(currentObject.BaseAddress);
}
if (!ObjectDictionary.ContainsKey(currentObject.GUID))
{
PObject obj = null;
// Add the object based on it's *actual* type. Note: WoW's Object descriptors for OBJECT_FIELD_TYPE
// is a bitmask. We want to use the type at 0x14, as it's an 'absolute' type.
switch (currentObject.Type)
{
// Belive it or not, the base Object class is hardly used in WoW.
case (int) Constants.ObjectType.Object:
obj = new PObject(currentObject.BaseAddress);
break;
case (int) Constants.ObjectType.Unit:
obj = new PUnit(currentObject.BaseAddress);
break;
case (int) Constants.ObjectType.Player:
obj = new PPlayer(currentObject.BaseAddress);
break;
case (int) Constants.ObjectType.GameObject:
obj = new PGameObject(currentObject.BaseAddress);
break;
case (int) Constants.ObjectType.Item:
obj = new PItem(currentObject.BaseAddress);
break;
case (int) Constants.ObjectType.Container:
obj = new PContainer(currentObject.BaseAddress);
break;
// These two aren't used in most bots, as they're fairly pointless.
// They are AI and area triggers for NPCs handled by the client itself.
case (int) Constants.ObjectType.AiGroup:
case (int) Constants.ObjectType.AreaTrigger:
break;
}
if (obj != null)
{
// We have a valid object that isn't in the object list already.
// So lets add it.
ObjectDictionary.Add(currentObject.GUID, obj);
}
}
else
{
// The object already exists, just update the pointer.
ObjectDictionary[currentObject.GUID].UpdateBaseAddress(currentObject.BaseAddress);
}
// We need the next object.
currentObject.BaseAddress =
Memory.Read<uint>(currentObject.BaseAddress + (uint) Pointers.ObjectManager.NextObject);
}
}
/// <summary>
/// Gets the closest attacker other than the PUnit specified. .
/// </summary>
/// <param name = "exclude">The PUnit to exclude.</param>
/// <returns></returns>
public static PUnit GetClosestAttackerExclude(PUnit exclude)
{
PUnit closestAttacker = null;
try
{
List<PUnit> units = GetAttackers;
foreach (PUnit u in units)
{
if (u.GUID != exclude.GUID)
{
if (closestAttacker == null) closestAttacker = u;
else if (u.DistanceToSelf < closestAttacker.DistanceToSelf) closestAttacker = u;
}
}
}
catch (Exception)
{
}
return closestAttacker;
}
/// <summary>
/// Determines whether [is it safe at] [the specified ignore].
/// </summary>
/// <param name = "ignore">The ignore.</param>
/// <param name = "u">The u.</param>
/// <returns>
/// <c>true</c> if [is it safe at] [the specified ignore]; otherwise, <c>false</c>.
/// </returns>
public static bool IsItSafeAt(ulong ignore, PUnit u)
{
return IsItSafeAt(ignore, u.Location);
}
public abstract PullResult Pull(PUnit target);
private static PUnit GetClosestBesides(IEnumerable<PUnit> list, PUnit ignore)
{
double closest = double.MaxValue;
PUnit toReturn = null;
foreach (PUnit pUnit in list)
{
if (pUnit.DistanceToSelf < closest && (ignore.GUID != pUnit.GUID) && !ignore.IsPet &&
!(pUnit.IsInCombat || pUnit.IsTargetingMe || pUnit.IsTargetingMyPet))
{
closest = pUnit.DistanceToSelf;
toReturn = pUnit;
}
}
return toReturn;
}
public static void DoWork(PUnit unit)
{
MoveHelper.ReleaseKeys();
if (!unit.IsLootable)
return;
Logging.Write("Looting: " + unit.Name);
if (unit.DistanceToSelf > 5)
{
MoveHelper.MoveToLoc(unit.Location, 4, false, true);
}
if (ObjectManager.ShouldDefend)
{
Logging.Write("Skipping loot, we got into combat");
return;
}
Thread.Sleep(200);
if (ObjectManager.MyPlayer.HasLivePet)
Thread.Sleep(700);
if (ObjectManager.MyPlayer.Target != unit)
{
unit.Interact(false);
}
else
{
KeyHelper.SendKey("InteractTarget");
}
if (ObjectManager.ShouldDefend)
return;
TimeOut.Reset();
while (!ObjectManager.MyPlayer.LootWinOpen && !TimeOut.IsReady)
Thread.Sleep(100);
TimeOut.Reset();
if (GrindingSettings.Skin || GrindingSettings.WaitForLoot)
{
while (ObjectManager.MyPlayer.LootWinOpen && !TimeOut.IsReady)
Thread.Sleep(100);
Thread.Sleep(1300);
}
else
{
Thread.Sleep(200);
}
GrindingEngine.UpdateStats(1, 0, 0);
PBlackList.Blacklist(unit, 300, false);
if (unit.IsSkinnable && GrindingSettings.Skin)
{
Logging.Write("Skinning");
KeyHelper.SendKey("TargetLastTarget");
Thread.Sleep(1000);
if (!ObjectManager.MyPlayer.Target.IsValid)
{
unit.Interact(false);
}
else
{
KeyHelper.SendKey("InteractTarget");
}
TimeOut.Reset();
while (!ObjectManager.MyPlayer.LootWinOpen && !TimeOut.IsReady)
{
Thread.Sleep(100);
}
if (GrindingSettings.WaitForLoot)
{
Thread.Sleep(500);
}
GrindingEngine.UpdateStats(1, 0, 0);
}
}
public void PrePull(PUnit target)
{
//Logging.Debug("Pre pull started");
if (target.DistanceToSelf > Behavior.PrePullDistance)
{
MoveHelper.MoveToUnit(target, Behavior.PrePullDistance);
}
foreach (Rule rule in Behavior.PrePullController.GetRules.Where(rule => rule.IsOk))
{
rule.ExecuteAction(Behavior.GlobalCooldown);
}
//Logging.Debug("Pre pull done");
}
private bool HasBuffId(PUnit target, string buffIds)
{
string[] buffId = buffIds.Split(',');
foreach (string s in buffId)
{
try
{
switch (OwnerCondition)
{
case BuffOwnerConditionEnum.Owner:
if (target.HasBuff(Convert.ToInt32(s), true))
return true;
break;
case BuffOwnerConditionEnum.NotOwner:
if (target.HasBuff(Convert.ToInt32(s), false))
return true;
break;
case BuffOwnerConditionEnum.DoesNotMatter:
if (target.HasBuff(Convert.ToInt32(s), false))
return true;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
catch (ThreadAbortException)
{
}
catch (Exception e)
{
Logging.Write("Error checking buff: " + e);
}
}
return false;
}
public static void DoLootAfterCombat(PUnit unit)
{
if (!GrindingSettings.Loot)
return;
if (ObjectManager.ShouldDefend)
return;
Thread.Sleep(500);
if (!ObjectManager.MyPlayer.Target.IsValid && unit.IsLootable)
{
KeyHelper.SendKey("TargetLastTarget");
}
Thread.Sleep(500);
if (ObjectManager.MyPlayer.Target.IsValid)
{
DoWork(ObjectManager.MyPlayer.Target);
}
}
private bool HasBuffByName(PUnit target, string buffIds)
{
string[] buffId = buffIds.Split(',');
foreach (string s in buffId)
{
try
{
switch (OwnerCondition)
{
case BuffOwnerConditionEnum.Owner:
if (target.HasBuff(s, true))
return true;
break;
case BuffOwnerConditionEnum.NotOwner:
if (target.HasBuff(s, false))
return true;
break;
default:
throw new ArgumentOutOfRangeException();
}
}
catch (Exception)
{
//Logging.Write("Could not convert " + s + " to int when checking buffs - fix your BuffCondition: ");
}
}
return false;
}
private void AZRUN()
{
BarMapper.MapBars();
KeyHelper.LoadKeys();
string BossName = "看门者克里克希尔";
List<string> EmName = new List<string>();
EmName.Add("看守者纳尔伊");
EmName.Add("看守者加什拉");
EmName.Add("看守者希尔希克");
List<int> MyBadBuff = new List<int>();
MyBadBuff.Add(52087); // 蛛网裹体
MyBadBuff.Add(52086); // 蛛网裹体
while (ObjectManager.MyPlayer.IsAlive)
{
// 循环开始
PUnit boss = new PUnit(0);
Dictionary<string, PUnit> em = new Dictionary<string, PUnit>();
// 加buff
if (!ObjectManager.MyPlayer.HasBuff("钢皮合剂")) KeyHelper.SendLuaOverChat("/use 钢皮合剂");
if (!ObjectManager.MyPlayer.HasBuff("坚韧")) KeyHelper.SendLuaOverChat("/use 坚韧符文卷轴 II");
// 找到怪的地址
int FoundCount = 0;
em.Clear();
foreach (PUnit uu in ObjectManager.GetUnits)
{
if (uu.Name.Equals(BossName))
{
boss = uu;
FoundCount++;
continue;
}
foreach (string ename in EmName)
{
if (uu.Name.Equals(ename))
{
em.Add(ename, uu);
FoundCount++;
continue;
}
}
}
if (FoundCount < 4)
{
Logging.Write("找不到怪了");
return;
}
// 面对boss
boss.Face();
// 开机能
if (!ObjectManager.MyPlayer.HasBuff("野性印记")) BarMapper.CastSpell("野性印记");
if (!ObjectManager.MyPlayer.HasBuff("猎豹形态")) BarMapper.CastSpell("猎豹形态");
Thread.Sleep(1000);
// 定位一个
int killcount = 0;
foreach (string ename in EmName)
{
PUnit emUnit = em[ename];
while (!emUnit.TargetGUID.Equals(ObjectManager.MyPlayer.GUID))
{
KeyHelper.SendLuaOverChat("/target " + ename);
BarMapper.CastSpell("精灵之火（野性）");
Thread.Sleep(100);
}
//Thread.Sleep(500);
// 猛虎之怒
if (BarMapper.IsSpellReadyByName("猛虎之怒"))
{
BarMapper.CastSpell("猛虎之怒");
Thread.Sleep(10);
}
// 树皮术
if (BarMapper.IsSpellReadyByName("树皮术"))
{
BarMapper.CastSpell("树皮术");
Thread.Sleep(10);
}
// 等待怪过来
while (emUnit.Location.DistanceToSelf2D > 5)
{
if (killcount > 0) BarMapper.CastSpell("横扫");
};
emUnit.Location.Face();
// 杀，直到怪死
int count = 0;
Logging.Write("血量：" + emUnit.Health + " 怪物名称：" + emUnit.Name + " 是死是活：" + emUnit.IsAlive);
int UHealth = 0;
UHealth = emUnit.Health;
while (UHealth == -1) UHealth = emUnit.Health;
while (UHealth > 0)
{
Thread.Sleep(10);
if (!ObjectManager.MyPlayer.IsCasting)
{
//调整朝向
if (!emUnit.Location.IsFacing(0.3f)) emUnit.Location.Face();
//Logging.Write("Count is " + count.ToString());
// 检查自己的buff
while (ObjectManager.MyPlayer.HasBuff(MyBadBuff)) { };
// 猛虎之怒
if (BarMapper.IsSpellReadyByName("猛虎之怒"))
{
BarMapper.CastSpell("猛虎之怒");
Thread.Sleep(10);
}
// 树皮术
if (BarMapper.IsSpellReadyByName("树皮术"))
{
BarMapper.CastSpell("树皮术");
Thread.Sleep(10);
}
// 凶猛撕咬--终结技
//if (count == 4 && BarMapper.IsSpellReadyByName("凶猛撕咬"))
if (count > 4)
{
//BarMapper.CastSpell("凶猛撕咬");
KeyLowHelper.PressKey(MicrosoftVirtualKeys.LeftShift);
KeyLowHelper.PressKey(MicrosoftVirtualKeys.key1);
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.key1);
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.LeftShift);
Thread.Sleep(10);
KeyLowHelper.PressKey(MicrosoftVirtualKeys.key3);
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.key3);
//Thread.Sleep(10);
count = 0;
}
//// 裂伤
//if (BarMapper.IsSpellReadyByName("裂伤") && !emUnit.HasBuff("裂伤"))
//{
// BarMapper.CastSpell("裂伤");
// Thread.Sleep(10);
// count++;
//}
// 斜掠
if (BarMapper.IsSpellReadyByName("裂伤"))
{
//BarMapper.CastSpell("裂伤");
KeyLowHelper.PressKey(MicrosoftVirtualKeys.LeftShift);
KeyLowHelper.PressKey(MicrosoftVirtualKeys.key1);
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.key1);
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.LeftShift);
Thread.Sleep(10);
KeyLowHelper.PressKey(MicrosoftVirtualKeys.key2);
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.key2);
count++;
//Thread.Sleep(10);
}
Logging.Write("血量：" + emUnit.Health);
}
UHealth = emUnit.Health;
while (UHealth == -1)
{
UHealth = emUnit.Health;
if (UHealth == 0)
{
int HealthTry1 = emUnit.Health;
int HealthTry2 = emUnit.Health;
UHealth = (HealthTry1 >= HealthTry2 ? HealthTry1 : HealthTry2);
}
}
if (ObjectManager.MyPlayer.IsDead) return;
}
killcount++;
}
while (ObjectManager.MyPlayer.HasBuff(MyBadBuff)) { };
// 一直横扫，直到全死
//while (true)
//{
// if (!ObjectManager.MyPlayer.HasBuff(MyBadBuff))
// {
// if (BarMapper.IsSpellReadyByName("生存本能")) { BarMapper.CastSpell("生存本能"); }
// if (ObjectManager.MyPlayer.IsDead) return;
// break;
// }
//}
//while (true)
//{
// if (!ObjectManager.MyPlayer.HasBuff(MyBadBuff))
// {
// if (BarMapper.IsSpellReadyByName("狂暴")) { BarMapper.CastSpell("狂暴"); }
// if (ObjectManager.MyPlayer.IsDead) return;
// break;
// }
//}
KeyLowHelper.PressKey(MicrosoftVirtualKeys.LeftShift);
KeyLowHelper.PressKey(MicrosoftVirtualKeys.key1);
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.key1);
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.LeftShift);
Thread.Sleep(10);
KeyLowHelper.PressKey(MicrosoftVirtualKeys.key4);
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.key4);
Thread.Sleep(10);
KeyLowHelper.PressKey(MicrosoftVirtualKeys.key5);
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.key5);
//while (BarMapper.IsSpellReadyByName("狂暴")) { BarMapper.CastSpell("狂暴"); break; }
// 加点血
while (ObjectManager.MyPlayer.Health < 30)
{
if (!ObjectManager.MyPlayer.HasBuff(MyBadBuff))
{
if (BarMapper.IsSpellReadyByName("回春术")) { BarMapper.CastSpell("回春术"); break; }
if (ObjectManager.MyPlayer.IsDead) return;
}
}
while (ObjectManager.MyPlayer.Health < 30)
{
if (!ObjectManager.MyPlayer.HasBuff(MyBadBuff))
{
if (BarMapper.IsSpellReadyByName("愈合")) { BarMapper.CastSpell("愈合"); break; }
if (ObjectManager.MyPlayer.IsDead) return;
}
}
while (!ObjectManager.MyPlayer.HasBuff("猎豹形态"))
{
if (!ObjectManager.MyPlayer.HasBuff(MyBadBuff))
{
if (BarMapper.IsSpellReadyByName("猎豹形态")) { BarMapper.CastSpell("猎豹形态"); break; }
if (ObjectManager.MyPlayer.IsDead) return;
}
}
boss.Face();
while (true)
{
//ObjectManager.MyPlayer.IsInCombat
Thread.Sleep(100);
bool TargetME = false;
PUnit emO = new PUnit(0);
foreach (PUnit uu in ObjectManager.GetUnits)
{
if (uu.IsPlayer) continue;
if (uu.Name.Equals(boss.Name)) continue;
if (uu.TargetGUID.Equals(ObjectManager.MyPlayer.GUID)) { TargetME = true; emO = uu; break; }
}
if (!TargetME) break;
emO.Face();
KeyLowHelper.PressKey(MicrosoftVirtualKeys.LeftShift);
KeyLowHelper.PressKey(MicrosoftVirtualKeys.key5);
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.key5);
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.LeftShift);
Thread.Sleep(10);
KeyLowHelper.PressKey(MicrosoftVirtualKeys.key2);
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.key2);
Thread.Sleep(10);
KeyLowHelper.PressKey(MicrosoftVirtualKeys.key4);
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.key4);
Thread.Sleep(10);
KeyLowHelper.PressKey(MicrosoftVirtualKeys.LeftShift);
KeyLowHelper.PressKey(MicrosoftVirtualKeys.key2);
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.key2);
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.LeftShift);
Thread.Sleep(10);
KeyLowHelper.PressKey(MicrosoftVirtualKeys.key5);
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.key5);
Thread.Sleep(10);
//BarMapper.CastSpell("猛虎之怒");
//BarMapper.CastSpell("树皮术");
//BarMapper.CastSpell("横扫");
if (ObjectManager.MyPlayer.IsDead) return;
}
// 面对boss
boss.Face();
// 召唤“打架赛车”
KeyHelper.SendLuaOverChat("/use 蓝色打架赛车");
BarMapper.CastSpell("蓝色打架赛车");
Thread.Sleep(1000);
PUnit djsc = new PUnit(0);
bool FoundDJSC = false;
while (!FoundDJSC)
{
foreach (PUnit uu in ObjectManager.GetUnits)
{
if (uu.Name.Contains("打架赛车"))
{
djsc = uu;
FoundDJSC = true;
}
}
if (ObjectManager.MyPlayer.IsDead) return;
}
Thread.Sleep(500);
// 走到boss旁边，打架赛车Y不小于646
//while (djsc.Location.DistanceFromXY(boss.Location) > 6)
string ddd = Convert.ToString(djsc.Location.Y);
float PosY = djsc.Location.Y;
while (PosY > 648 || PosY == 0)
{
KeyLowHelper.PressKey(MicrosoftVirtualKeys.Up);
Thread.Sleep(100);
PosY = djsc.Location.Y;
ddd = ddd + Convert.ToString(PosY);
if (ObjectManager.MyPlayer.IsDead) return;
}
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.Up);
Logging.Write(ddd);
// 一直跳，直到boss消失
while (boss.Health > 0)
{
KeyLowHelper.PressKey(MicrosoftVirtualKeys.Space);
Thread.Sleep(10);
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.Space);
Thread.Sleep(500);
if (ObjectManager.MyPlayer.IsDead) return;
}
while (ObjectManager.MyPlayer.IsInCombat) { };
// 给自己加血
KeyHelper.SendLuaOverChat("/use 黄油面包卷");
Thread.Sleep(1000);
while (ObjectManager.MyPlayer.HasBuff("进食") || ObjectManager.MyPlayer.Health < 100) { };
while (ObjectManager.MyPlayer.Health < 100 && ObjectManager.MyPlayer.ManaPoints > 5590)
{
// 治疗之触
if (BarMapper.IsSpellReadyByName("治疗之触"))
{
BarMapper.CastSpell("治疗之触");
Thread.Sleep(100);
}
if (ObjectManager.MyPlayer.IsDead) return;
}
// 等待一段时间，直到boss重新出现
Thread.Sleep(1000);
bool FoundBoss = false;
while (!FoundBoss)
{
foreach (PUnit uu in ObjectManager.GetUnits)
{
if (uu.Name.Equals(BossName))
{
FoundBoss = true;
}
}
Thread.Sleep(200);
if (ObjectManager.MyPlayer.IsDead) return;
}
// 猎豹形态
//BarMapper.CastSpell("猎豹形态");
//MessageBox.Show("OK");
// 每个小号跳一次
Process[] wcc = Process.GetProcessesByName("Wow");
foreach (Process proc in wcc)
{
KeyLowHelper.PressKey(proc.MainWindowHandle, MicrosoftVirtualKeys.Space);
Thread.Sleep(10);
KeyLowHelper.ReleaseKey(proc.MainWindowHandle, MicrosoftVirtualKeys.Space);
Thread.Sleep(100);
}
while (ObjectManager.MyPlayer.Health < 100)
{
while (BarMapper.IsSpellReadyByName("生命之血")) { BarMapper.CastSpell("生命之血"); break; }
if (ObjectManager.MyPlayer.ManaPoints > 5590)
{
// 治疗之触
if (BarMapper.IsSpellReadyByName("治疗之触"))
{
BarMapper.CastSpell("治疗之触");
Thread.Sleep(100);
}
}
if (ObjectManager.MyPlayer.IsDead) return;
}
}
}
public override void Combat(PUnit target)
{
if (Behavior.UseAutoAttack)
{
target.InteractWithTarget();
}
if (Behavior.SendPet)
PetAttackKey.SendKey();
//Logging.Debug("Combat started");
while (true)
{
try
{
if (target.DistanceToSelf > Behavior.CombatDistance)
MoveHelper.MoveToUnit(target, Behavior.CombatDistance);
}
catch
{
}
if (!ObjectManager.MyPlayer.IsValid || ObjectManager.MyPlayer.Target != target)
target.TargetHostile();
if (PveBehaviorSettings.AvoidAddsCombat)
ConsiderAvoidAdds(target);
foreach (Rule rule in Behavior.CombatController.GetRules.Where(rule => rule.IsOk))
{
if (target.IsValid && target.IsAlive)
{
if (!target.Location.IsFacing())
{
target.Face();
}
rule.ExecuteAction(Behavior.GlobalCooldown);
break;
}
}
Thread.Sleep(10);
Application.DoEvents();
}
}
/*
internal static bool IsUsabelAction(int slot)
{
var foo = (uint)Pointers.ActionBar.IsUsableAction + (uint)slot * 0x04;
var isUsabelAction = Memory.Read<int>(ObjectManager.BaseAddressModule + foo);
foo = (uint)Pointers.ActionBar.IsUsableActionNoMana + (uint)slot * 0x04;
var isUsabelActionNoMana = Memory.Read<int>(ObjectManager.BaseAddressModule + foo);
if (isUsabelAction == 0 && isUsabelActionNoMana == 0)
{
Logging.Write("Slot: " + slot + " is usabel");
return true;
}
Logging.Write("Slot: " + slot + " is not usabel");
return false;
}
*/
public static bool HasBuff(PUnit check, string name)
{
List<int> ids = GetIdsFromName(name);
if (ObjectManager.Initialized)
if (check.HasBuff(ids))
return true;
return false;
}
internal static void StartCombat(PUnit u)
{
if (ObjectManager.MyPlayer.IsDead)
{
Stop();
return;
}
Unit.BaseAddress = u.BaseAddress;
InvokeCombatStatusChanged(new GCombatEventArgs(CombatType.CombatStarted));
_combatThread = new Thread(CombatThread) {IsBackground = true};
_combatThread.Name = "CombatThread";
_combatThread.Start();
_combatResult = CombatResult.Unknown;
while (_combatThread.IsAlive)
{
try
{
if (Unit.IsDead)
{
_combatResult = CombatResult.Success;
break;
}
if (!Unit.IsValid || PBlackList.IsBlacklisted(Unit))
{
if (!Langs.TrainingDummy(ObjectManager.MyPlayer.Target.Name))
{
_combatResult = CombatResult.Bugged;
break;
}
}
if (ObjectManager.MyPlayer.IsDead)
{
_combatResult = CombatResult.Died;
break;
}
if (Unit.IsPet || Unit.IsTotem)
{
Logging.Write("We are attacking a totem or a pet... doh");
_combatResult = CombatResult.Bugged;
break;
}
if (!Langs.TrainingDummy(Unit.Name) && Unit.IsTagged && !Unit.IsTaggedByMe && !Unit.IsTargetingMe &&
Unit != ObjectManager.MyPlayer)
{
Logging.Write("Other player tag");
_combatResult = CombatResult.OtherPlayerTag;
break;
}
}
catch (Exception e)
{
Logging.Write("Exeption in combat handler: " + e);
}
Thread.Sleep(160);
}
ExitCombat();
}
public override PullResult Pull(PUnit target)
{
//Logging.Debug("Pull started");
Buff();
PrePull(target);
if (Behavior.UseAutoAttack)
{
target.InteractWithTarget();
}
if (!MoveHelper.MoveToUnit(target, Behavior.PullDistance))
return PullResult.CouldNotPull;
if (Behavior.SendPet)
PetAttackKey.SendKey();
foreach (Rule rule in Behavior.PullController.GetRules.Where(rule => rule.IsOk))
{
target.Face();
rule.ExecuteAction(Behavior.GlobalCooldown);
}
// Logging.Debug("Pull done");
if (PPullBlackList.IsBlacklisted(target))
{
return PullResult.CouldNotPull;
}
return PullResult.Success;
}
private static NameValuePair[] GetTargetNameValuePairs(PUnit target)
{
var wuUtils = new PUnitUtils(target.BaseAddress);
return wuUtils.GetNameValuePairs().ToArray();
}
public virtual void LogicAttack(PUnit target)
{
try
{
DamageActions.Sort();
PAction pAction = (from a in DamageActions
where a.IsWanted && (a.IsReady || a.WaitUntilReady)
select a).FirstOrDefault();
if (pAction != null)
pAction.Execute();
}
catch (ThreadAbortException)
{
}
catch (Exception e)
{
Log("Error in LogicAttack please check class code: " + e);
}
}
public static void StartCombat(PUnit u)
{
PrivCombatHandler.StartCombat(u);
}
public abstract void Combat(PUnit target);
/*
* ConsiderAvoidAdds - Avoid Adds
*/
internal void ConsiderAvoidAdds(PUnit target)
{
bool petattacking = false;
List<PUnit> closeUnits = ObjectManager.CheckForMobsAtLoc(target.Location,
PveBehaviorSettings.SkipAddsDis + 5, false);
if (closeUnits.Count == 0) return;
PUnit closestAdd = GetClosestBesides(closeUnits, target);
if (closestAdd == null) return;
if (closestAdd.GUID == target.GUID) return;
// Somebody is close enough to maybe jump in. If the monster is in front of us and close
// enough, might be time to back it up.
if (closestAdd.DistanceToSelf < Avoidaddsdistance)
{
Logging.Write("Possible add: " + closestAdd.Name + ": " + closestAdd.DistanceToSelf);
_addBackup.Reset();
var futility = new Ticker(3000);
closestAdd.Face();
MoveHelper.Backwards(true);
if (ObjectManager.MyPlayer.HasLivePet)
{
petattacking = ObjectManager.MyPlayer.Pet.Target.IsValid;
PetFollow.SendKey();
}
while (!futility.IsReady)
{
Thread.Sleep(10);
closestAdd.Face();
if (closestAdd.DistanceToSelf > Avoidaddsdistance + 6.0) // Slack space.
break;
}
MoveHelper.Backwards(false);
if (ObjectManager.MyPlayer.HasLivePet && petattacking)
PetAttackKey.SendKey();
_addBackup.Reset();
}
}
private static bool IsValidTarget(PUnit unitTofind)
{
if (unitTofind.IsPlayer || unitTofind.IsTagged || unitTofind.IsDead || unitTofind.IsTotem)
{
return false;
}
SubProfile currentProfile = GrindingEngine.CurrentProfile.GetSubProfile();
if (unitTofind.Level < currentProfile.MobMinLevel ||
unitTofind.Level > currentProfile.MobMaxLevel)
return false;
if (currentProfile.Ignore != null)
{
if (currentProfile.Ignore.Any(tstIgnore => tstIgnore == unitTofind.Name))
{
return false;
}
}
if (currentProfile.Factions != null)
{
if (currentProfile.Factions.Any(faction => unitTofind.Faction == faction))
{
return true;
}
}
return false;
}
/// <summary>
/// Attacking me or my pet.
/// </summary>
/// <param name = "u">The unit.</param>
/// <returns></returns>
public static bool AttackingMeOrPet(PUnit u)
{
//return TargetingMeOrPet(u) && u.IsInCombat && (u.IsAutoAttacking || u.IsCasting);
return TargetingMeOrPet(u) && u.IsInCombat;
}
public static bool DoAction()
{
// 跑到邮箱点（计算到中间节点的距离和到邮箱的距离，选择路径）
logger.Add("跑到邮箱点");
if (LocMailbox.DistanceToSelf2D > LocMid.DistanceToSelf2D)
{
logger.Add("在靠近AHer这边，先跑到中间节点，然后去邮箱那边");
if (!MoveHelper.MoveToLoc(LocMid, 2))
{
logger.Add("跑到中间节点");
return false;
}
}
if (!MoveHelper.MoveToLoc(LocMailbox, 2))
{
logger.Add("跑到邮箱点出错");
return false;
}
// 打开邮箱
logger.Add("打开邮箱");
if (!MailManager.TargetMailBox())
{
logger.Add("打开邮箱出错");
return false;
}
//// 遍历物品，保证背包中有足够的拍卖品。这里要注意背包空间
//logger.Add("遍历 待拍卖物品列表 ");
//foreach (DataRow dr in Items.Rows)
//{
// logger.Add("检查背包剩余空间");
// if (Inventory.FreeBagSlots <= 1)
// {
// logger.Add("检查背包剩余空间为1，不能继续");
// return false;
// }
// string AHSellItem = dr["item_name"].ToString();
// logger.Add("通过lua获知物品在背包和邮箱中的数量");
// if (!SpyFrame.lua_SetDispCountItemName(AHSellItem))
// {
// logger.Add("在执行SetDispCountItemName时出错，物品：" + AHSellItem);
// return false;
// }
// Thread.Sleep(500);
// Dictionary<string, int> MineCount = SpyFrame.GetDispCountItemCount();
// logger.Add(string.Format("物品{0}在背包中的数量为{1}，在邮箱中的数量为：{2}", AHSellItem, MineCount["BAG"], MineCount["MAIL"]));
// if (MineCount["BAG"] == 0 && MineCount["MAIL"] == 0) continue;
// //int WantCount = (int)dr["item_count"] * (int)dr["item_stacksize"] > MineCount["BAG"]
// // ? (int)dr["item_count"] * (int)dr["item_stacksize"] - MineCount["BAG"]
// // : 0
// // ;
// //if (WantCount == 0) continue;
// //// 拿邮件(LUA)
// //logger.Add(string.Format("从邮箱中拿{0}个{1}", WantCount, mine));
// // 全拿东西，不考虑包包大小
// if (MineCount["MAIL"] > 0)
// {
// if (!SpyFrame.lua_GetMAILAsItem(AHSellItem, 100000))
// {
// logger.Add("从邮箱里面拿 " + AHSellItem + " 失败");
// return false;
// }
// }
// Thread.Sleep(1000);
//}
// 邮箱东西全拿
Thread.Sleep(2000);
SpyFrame.lua_GetAllMail();
Thread.Sleep(2000);
// 跑到邮箱点
logger.Add("跑到中间节点");
if (!MoveHelper.MoveToLoc(LocMid, 2))
{
logger.Add("跑到中间节点");
return false;
}
// 跑到拍卖师身边
logger.Add("跑到拍卖师身边");
if (!MoveHelper.MoveToLoc(LocAHer, 2))
{
logger.Add("跑到拍卖师身边出错");
return false;
}
// 找到拍卖师，打开拍卖界面
logger.Add(string.Format("定位拍卖师：{0}", AHerName));
PUnit aher = new PUnit(0);
bool found = false;
foreach (PUnit unit in ObjectManager.GetUnits)
{
if (unit.Name.Equals(AHerName) && unit.Location.DistanceToSelf2D < 5)
{
//unit.Location.Face();
//unit.TargetFriend();
//unit.Interact();
aher = unit;
found = true;
break;
}
}
if (!found)
{
logger.Add(string.Format("没找到名字是{0}的拍卖师", AHerName));
return false;
}
KeyHelper.SendLuaOverChat("/target " + AHerName);
Thread.Sleep(500);
if (!ObjectManager.MyPlayer.Target.Name.Equals(AHerName))
{
logger.Add(string.Format("没有命中拍卖师的目标"));
return false;
}
aher.Location.Face();
aher.InteractWithTarget();
Thread.Sleep(2000);
// 上货。 遍历待拍卖物品，扫描物品最低价格，最低价格不低于起拍价格，就上架
Stopwatch swJump = new Stopwatch();
swJump.Restart();
logger.Add(string.Format("开始上货"));
foreach (DataRow dr in Items.Rows)
{
string ahitem = dr["item_name"].ToString();
// 看看包里面有没有货
if (!SpyFrame.lua_SetDispCountItemName(ahitem))
{
logger.Add("在执行SetDispCountItemName时出错，物品：" + ahitem);
return false;
}
Thread.Sleep(500);
Dictionary<string, int> ItemCount = SpyFrame.GetDispCountItemCount();
if (ItemCount["BAG"] == 0)
{
logger.Add("背包里面没有物品：" + ahitem);
continue;
}
// 跳，防止AFK
if (swJump.Elapsed.TotalMinutes > AFK_Minutes)
{
KeyLowHelper.PressKey(MicrosoftVirtualKeys.Space);
KeyLowHelper.ReleaseKey(MicrosoftVirtualKeys.Space);
Thread.Sleep(3000);
swJump.Restart();
}
// 扫描最低价格
logger.Add(string.Format("扫描物品[{0}]的最低价格", ahitem));
Dictionary<string, string> scanresult = SpyFrame.lua_AHSearchDoor(ahitem);
if (scanresult == null)
{
logger.Add(string.Format("获取物品[{0}]的最低价格出现错误，返回值为NULL", ahitem));
return false;
}
logger.Add(string.Format("物品[{0}]的最低价格是[{1}]，由[{2}]出价", ahitem, scanresult["PRIZE"], scanresult["SELLER"]));
SpyDB.SaveAhInfo(scanresult["SELLER"].ToString(), ahitem, Convert.ToInt32(scanresult["PRIZE"]));
// 计算最低价格，准备上货
if (scanresult["SELLER"].Equals(ObjectManager.MyPlayer.Name))
{
logger.Add(string.Format("价格最低的就是我自己，所以不用上货"));
continue;
}
int prize, minprize, maxprize;
maxprize = Convert.ToInt32(dr["item_maxprice"]);
minprize = Convert.ToInt32(dr["item_minprice"]);
// 如果目前出价低于心里价位，不出货
if (Convert.ToInt32(scanresult["PRIZE"]) < minprize)
{
logger.Add(string.Format("[{0}]出价低过心里价位[{1}]，暂时不出货", scanresult["PRIZE"], minprize));
continue;
}
if (scanresult["SELLER"].Equals("NOBODY"))
{
logger.Add(string.Format("拍卖场没有人卖[{0}]，将按照数据库中记录的最高价格[{1}]上货", ahitem, maxprize));
prize = maxprize;
}
else
{
if (maxprize < Convert.ToInt32(scanresult["PRIZE"]))
prize = maxprize;
else
prize = Convert.ToInt32(scanresult["PRIZE"]) - 1;
logger.Add(string.Format("进过计算，物品[{0}]将按照单价[{1}]上架", ahitem, prize));
// 取消拍卖物品
logger.Add(string.Format("取消AH中单价低于[{0}]的[{1}]", prize, ahitem));
if (!SpyFrame.lua_CancelAll(ahitem, prize))
{
logger.Add(string.Format("取消AH出错"));
return false;
}
}
// 上货
int StackSize = (int)(dr["item_stacksize"]);
int StackCount = (int)(dr["item_count"]);
logger.Add(string.Format("开始拍卖单价为[{0}]的“{1}”[{2}]堆，每堆[{3}]个", prize, ahitem, StackCount, StackSize));
if (!SpyFrame.lua_StartAuction(ahitem, prize, StackSize, StackCount))
{
logger.Add(string.Format("拍卖失败"));
return false;
}
// 标记工作状态
WORKING = true;
}
//
return true;
}
public GCombatEventArgs(CombatType type, PUnit unit)
{
CombatType = type;
Unit = unit;
}
