public static void DisposeCombatClass()
{
try
{
lock (CombatClassLocker)
{
if (_instanceFromOtherAssembly != null)
{
_instanceFromOtherAssembly.Dispose();
}
if (_worker != null)
{
if (_worker.IsAlive)
{
_worker.Abort();
}
}
}
}
catch (Exception exception)
{
Logging.WriteError("DisposeCombatClass(): " + exception);
}
finally
{
_instanceFromOtherAssembly = null;
_assembly = null;
_obj = null;
}
}
public AmeisenBotStateMachine(
string botDataPath,
Process wowProcess,
AmeisenBotConfig config,
XMemory xMemory,
IOffsetList offsetList,
ObjectManager objectManager,
CharacterManager characterManager,
HookManager hookManager,
EventHookManager eventHookManager,
IAmeisenBotCache botCache,
IPathfindingHandler pathfindingHandler,
IMovementEngine movementEngine,
ICombatClass combatClass)
{
AmeisenLogger.Instance.Log("Starting AmeisenBotStateMachine...", LogLevel.Verbose);
BotDataPath = botDataPath;
Config = config;
XMemory = xMemory;
OffsetList = offsetList;
ObjectManager = objectManager;
CharacterManager = characterManager;
HookManager = hookManager;
EventHookManager = eventHookManager;
BotCache = botCache;
LastObjectUpdate = DateTime.Now;
LastGhostCheck = DateTime.Now;
LastEventPull = DateTime.Now;
LastState = AmeisenBotState.None;
UnitLootList = new Queue <ulong>();
States = new Dictionary <AmeisenBotState, State>()
{
{ AmeisenBotState.None, new StateNone(this, config) },
{ AmeisenBotState.StartWow, new StateStartWow(this, config, wowProcess, xMemory) },
{ AmeisenBotState.Login, new StateLogin(this, config, offsetList, characterManager) },
{ AmeisenBotState.LoadingScreen, new StateLoadingScreen(this, xMemory, config, objectManager) },
{ AmeisenBotState.Idle, new StateIdle(this, config, offsetList, objectManager, characterManager, hookManager, eventHookManager, combatClass, UnitLootList) },
{ AmeisenBotState.Dead, new StateDead(this, config, objectManager, hookManager) },
{ AmeisenBotState.Ghost, new StateGhost(this, config, offsetList, objectManager, characterManager, hookManager, pathfindingHandler, movementEngine) },
{ AmeisenBotState.Following, new StateFollowing(this, config, objectManager, characterManager, pathfindingHandler, movementEngine) },
{ AmeisenBotState.Attacking, new StateAttacking(this, config, objectManager, characterManager, hookManager, pathfindingHandler, movementEngine, combatClass) },
{ AmeisenBotState.Repairing, new StateRepairing(this, config, objectManager, hookManager, characterManager, pathfindingHandler, movementEngine) },
{ AmeisenBotState.Selling, new StateSelling(this, config, objectManager, hookManager, characterManager, pathfindingHandler, movementEngine) },
{ AmeisenBotState.Healing, new StateEating(this, config, objectManager, characterManager) },
{ AmeisenBotState.InsideAoeDamage, new StateInsideAoeDamage(this, config, objectManager, characterManager, pathfindingHandler, movementEngine) },
{ AmeisenBotState.Looting, new StateLooting(this, config, offsetList, objectManager, characterManager, hookManager, pathfindingHandler, movementEngine, UnitLootList) }
};
CurrentState = States.First();
CurrentState.Value.Enter();
}
public StateIdle(AmeisenBotStateMachine stateMachine, AmeisenBotConfig config, IOffsetList offsetList, ObjectManager objectManager, CharacterManager characterManager, HookManager hookManager, EventHookManager eventHookManager, ICombatClass combatClass, Queue <ulong> unitLootList) : base(stateMachine)
{
Config = config;
OffsetList = offsetList;
ObjectManager = objectManager;
HookManager = hookManager;
EventHookManager = eventHookManager;
CharacterManager = characterManager;
CombatClass = combatClass;
UnitLootList = unitLootList;
}
public StateAttacking(AmeisenBotStateMachine stateMachine, AmeisenBotConfig config, ObjectManager objectManager, CharacterManager characterManager, HookManager hookManager, IPathfindingHandler pathfindingHandler, IMovementEngine movementEngine, ICombatClass combatClass) : base(stateMachine)
{
Config = config;
ObjectManager = objectManager;
CharacterManager = characterManager;
HookManager = hookManager;
PathfindingHandler = pathfindingHandler;
MovementEngine = movementEngine;
CombatClass = combatClass;
// default distance values
DistanceToTarget = combatClass == null || combatClass.IsMelee ? 3.0 : 25.0;
}
public CPDefault(List <Spell> spells, ICombatClass spellStrategy, IMovementStrategy movementStrategy)
{
Spells = spells;
SpellStrategy = spellStrategy;
MovementStrategy = movementStrategy;
}
private void InitAIEvents(Critter npc, ICombatClass combatClass)
{
Critter currentTarget = null;
long NextProcessTime = 0;
npc.Attacked += (sender, e) => {
if (e.Attacker != null)
npc.AddEnemyInStack (e.Attacker.Id);
};
npc.PlaneBegin += (sender, e) => {
if (e.Plane.Type == PlaneType.CustomAI) {
e.Result = NpcPlaneEventResult.Keep;
} else {
//TODO: check if discard
Global.Log ("Plane begin: " + e.Plane.Type);
}
};
npc.PlaneRun += (sender, e) => {
e.Result = NpcPlaneEventResult.Discard;
};
npc.PlaneEnd += (sender, e) => {
if (e.Plane.Type == PlaneType.CustomAI) {
if (NextProcessTime <= Time.ElapsedMilliseconds) {
var breakTime = ProcessCustomAI (npc, ref currentTarget, combatClass, e.Plane);
NextProcessTime = Time.ElapsedMilliseconds + (breakTime == 0 ? PROCESS_INTERVAL : breakTime);
}
e.Result = NpcPlaneEventResult.Keep;
} else if (e.Plane.Type == PlaneType.Walk) {
e.Result = ProcessWalkResult (npc, e);
} else {
e.Result = NpcPlaneEventResult.Discard;
}
};
npc.DropPlanes ();
npc.AddPlane (CreateCustomAIPlane ());
}
private long ProcessCustomAI(Critter npc, ref Critter currentTarget, ICombatClass combatClass, NpcPlane plane)
{
currentTarget = combatClass.ChooseNextTarget (npc, currentTarget);
if (currentTarget == null)
return 0;
var attackChoice = combatClass.ChooseAttack (npc, currentTarget);
if (attackChoice != null) {
var position = combatClass.ChooseAttackPosition (npc, currentTarget, attackChoice);
if (position != null) {
GoToPosition (npc, plane, position [0], position [1], position [2]);
return 0;
}
return AttackTarget (npc, currentTarget, attackChoice);
}
var itemChoice = combatClass.ChooseItem (npc, currentTarget);
if (itemChoice != null) {
UseItemOnTarget (npc, currentTarget, itemChoice);
return 0;
}
var skillChoice = combatClass.ChooseSkill (npc, currentTarget);
if (skillChoice != null) {
UseSkillOnTarget (npc, currentTarget, skillChoice);
return 0;
}
return 0;
}
public static void LoadCombatClass(string pathToCombatClassFile, bool settingOnly = false,
bool resetSettings = false,
bool cSharpFile = true)
{
try
{
_pathToCombatClassFile = pathToCombatClassFile;
if (_instanceFromOtherAssembly != null)
{
_instanceFromOtherAssembly.Dispose();
}
_instanceFromOtherAssembly = null;
_assembly = null;
_obj = null;
if (cSharpFile)
{
CodeDomProvider cc = new CSharpCodeProvider();
var cp = new CompilerParameters();
IEnumerable <string> assemblies = AppDomain.CurrentDomain
.GetAssemblies()
.Where(
a =>
!a.IsDynamic &&
!a.CodeBase.Contains((Process.GetCurrentProcess().ProcessName + ".exe")))
.Select(a => a.Location);
cp.ReferencedAssemblies.AddRange(assemblies.ToArray());
StreamReader sr = File.OpenText(pathToCombatClassFile);
string toCompile = sr.ReadToEnd();
CompilerResults cr = cc.CompileAssemblyFromSource(cp, toCompile);
if (cr.Errors.HasErrors)
{
String text = cr.Errors.Cast <CompilerError>().Aggregate("Compilator Error :\n",
(current, err) => current + (err + "\n"));
Logging.WriteError(text);
MessageBox.Show(text);
return;
}
_assembly = cr.CompiledAssembly;
_obj = _assembly.CreateInstance("Main", true);
_threadName = "CombatClass CS";
}
else
{
_assembly = Assembly.LoadFrom(_pathToCombatClassFile);
_obj = _assembly.CreateInstance("Main", false);
_threadName = "CombatClass DLL";
}
if (_obj != null && _assembly != null)
{
_instanceFromOtherAssembly = _obj as ICombatClass;
if (_instanceFromOtherAssembly != null)
{
if (settingOnly)
{
if (resetSettings)
{
_instanceFromOtherAssembly.ResetConfiguration();
}
else
{
_instanceFromOtherAssembly.ShowConfiguration();
}
_instanceFromOtherAssembly.Dispose();
return;
}
_worker = new Thread(_instanceFromOtherAssembly.Initialize)
{
IsBackground = true, Name = _threadName
};
_worker.Start();
}
else
{
Logging.WriteError("Custom Class Loading error.");
}
}
}
catch (Exception exception)
{
Logging.WriteError("LoadCombatClass(string _pathToCombatClassFile): " + exception);
}
}
