private void KillClosestByNameAction(Actions.Action action)
{
bool notTheClosest;
if (!bool.TryParse(action.GetParameterValue("notclosest"), out notTheClosest))
{
notTheClosest = false;
}
if (Cache.Instance.NormalApproach) Cache.Instance.NormalApproach = false;
List<string> targetNames = action.GetParameterValues("target");
// No parameter? Ignore kill action
if (targetNames.Count == 0)
{
Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "No targets defined!", Logging.Teal);
Nextaction();
return;
}
//
// the way this is currently written is will NOT stop after killing the first target as intended, it will clear all targets with the Name given
//
Cache.Instance.AddPrimaryWeaponPriorityTarget(Cache.Instance.PotentialCombatTargets.Where(t => targetNames.Contains(t.Name)).OrderBy(t => t.Distance).Take(1).FirstOrDefault(),PrimaryWeaponPriority.PriorityKillTarget, "CombatMissionCtrl.KillClosestByName");
//if (Settings.Instance.TargetSelectionMethod == "isdp")
//{
if (Cache.Instance.GetBestPrimaryWeaponTarget((double)Distances.OnGridWithMe, false, "combat", Cache.Instance.PotentialCombatTargets.OrderBy(t => t.Distance).Take(1).ToList()))
_clearPocketTimeout = null;
//}
//else //use new target selection method
//{
// if (Cache.Instance.__GetBestWeaponTargets((double)Distances.OnGridWithMe, Cache.Instance.PotentialCombatTargets.Where(e => !e.IsSentry || (e.IsSentry && Settings.Instance.KillSentries)).OrderBy(t => t.Distance).Take(1).ToList()).Any())
// _clearPocketTimeout = null;
//}
// Do we have a timeout? No, set it to now + 5 seconds
if (!_clearPocketTimeout.HasValue) _clearPocketTimeout = DateTime.UtcNow.AddSeconds(5);
// Are we in timeout?
if (DateTime.UtcNow < _clearPocketTimeout.Value) return;
// We have cleared the Pocket, perform the next action \o/ - reset the timers that we had set for actions...
Nextaction();
// Reset timeout
_clearPocketTimeout = null;
return;
}
private void DebuggingWait(Actions.Action action)
{
// Default timeout is 1200 seconds
int timeout;
if (!int.TryParse(action.GetParameterValue("timeout"), out timeout))
timeout = 1200;
if (_waiting)
{
if (DateTime.Now.Subtract(_waitingSince).TotalSeconds < timeout)
return;
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Nothing targeted us within [ " + timeout + "sec]!", Logging.Teal);
// Nothing has targeted us in the specified timeout
_waiting = false;
Nextaction();
return;
}
// Start waiting
_waiting = true;
_waitingSince = DateTime.Now;
}
private void IgnoreAction(Actions.Action action)
{
bool clear;
if (!bool.TryParse(action.GetParameterValue("clear"), out clear))
clear = false;
//List<string> removehighestbty = action.GetParameterValues("RemoveHighestBty");
//List<string> addhighestbty = action.GetParameterValues("AddHighestBty");
List<string> add = action.GetParameterValues("add");
List<string> remove = action.GetParameterValues("remove");
//string targetNames = action.GetParameterValue("target");
//int distancetoapp;
//if (!int.TryParse(action.GetParameterValue("distance"), out distancetoapp))
// distancetoapp = 1000;
//IEnumerable<EntityCache> targets = Cache.Instance.Entities.Where(e => targetNames.Contains(e.Name));
// EntityCache target = targets.OrderBy(t => t.Distance).First();
//IEnumerable<EntityCache> targetsinrange = Cache.Instance.Entities.Where(b => Cache.Instance.DistanceFromEntity(b.X ?? 0, b.Y ?? 0, b.Z ?? 0,target) < distancetoapp);
//IEnumerable<EntityCache> targetsoutofrange = Cache.Instance.Entities.Where(b => Cache.Instance.DistanceFromEntity(b.X ?? 0, b.Y ?? 0, b.Z ?? 0, target) < distancetoapp);
if (clear)
Cache.Instance.IgnoreTargets.Clear();
else
{
add.ForEach(a => Cache.Instance.IgnoreTargets.Add(a.Trim()));
remove.ForEach(a => Cache.Instance.IgnoreTargets.Remove(a.Trim()));
}
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Updated ignore list", Logging.Teal);
if (Cache.Instance.IgnoreTargets.Any())
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Currently ignoring: " + Cache.Instance.IgnoreTargets.Aggregate((current, next) => current + "[" + next + "]"), Logging.Teal);
else
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Your ignore list is empty", Logging.Teal);
_currentAction++;
}
private void ActivateAction(Actions.Action action)
{
bool optional;
if (!bool.TryParse(action.GetParameterValue("optional"), out optional))
optional = false;
string target = action.GetParameterValue("target");
// No parameter? Although we should not really allow it, assume its the acceleration gate :)
if (string.IsNullOrEmpty(target))
target = "Acceleration Gate";
IEnumerable<EntityCache> targets = Cache.Instance.EntitiesByName(target).ToList();
if (!targets.Any())
{
if (!_waiting)
{
Logging.Log("CombatMissionCtrl", "Activate: Can't find [" + target + "] to activate! Waiting 30 seconds before giving up", Logging.Teal);
_waitingSince = DateTime.Now;
_waiting = true;
}
else if (_waiting)
{
if (DateTime.Now.Subtract(_waitingSince).TotalSeconds > Time.Instance.NoGateFoundRetryDelay_seconds)
{
Logging.Log("CombatMissionCtrl",
"Activate: After 30 seconds of waiting the gate is still not on grid: CombatMissionCtrlState.Error",
Logging.Teal);
if (optional) //if this action has the optional paramater defined as true then we are done if we cant find the gate
DoneAction();
else
_States.CurrentCombatMissionCtrlState = CombatMissionCtrlState.Error;
}
}
return;
}
//if (closest.Distance <= (int)Distance.CloseToGateActivationRange) // if your distance is less than the 'close enough' range, default is 7000 meters
EntityCache closest = targets.OrderBy(t => t.Distance).First();
if (closest.Distance < (int)Distance.GateActivationRange + 5000)
{
// Tell the drones module to retract drones
Cache.Instance.IsMissionPocketDone = true;
// We cant activate if we have drones out
if (Cache.Instance.ActiveDrones.Any())
return;
//
// this is a bad idea for a speed tank, we ought to somehow cache the object they are orbiting/approaching, etc
// this seemingly slowed down the exit from certain missions for me for 2-3min as it had a command to orbit some random object
// after the "done" command
//
if (closest.Distance < -10100)
{
if (DateTime.Now > Cache.Instance.NextOrbit)
{
closest.Orbit(1000);
Logging.Log("CombatMissionCtrl", "Activate: We are too close to [" + closest.Name + "] Initiating orbit", Logging.Orange);
}
return;
}
if (closest.Distance >= -10100)
{
// Add bookmark (before we activate)
if (Settings.Instance.CreateSalvageBookmarks)
BookmarkPocketForSalvaging();
//Logging.Log("CombatMissionCtrl", "Activate: Reload before moving to next pocket", Logging.teal);
if (!Combat.ReloadAll(closest)) return;
if (DateTime.Now > Cache.Instance.NextActivateAction)
{
Logging.Log("CombatMissionCtrl", "Activate: [" + closest.Name + "] Move to next pocket after reload command and change state to 'NextPocket'", Logging.Green);
closest.Activate();
// Do not change actions, if NextPocket gets a timeout (>2 mins) then it reverts to the last action
_moveToNextPocket = DateTime.Now;
_States.CurrentCombatMissionCtrlState = CombatMissionCtrlState.NextPocket;
}
return;
}
}
else if (closest.Distance < (int)Distance.WarptoDistance) //else if (closest.Distance < (int)Distance.WarptoDistance) //if we are inside warpto distance then approach
{
// Move to the target
if (DateTime.Now > Cache.Instance.NextApproachAction && (Cache.Instance.IsOrbiting || Cache.Instance.Approaching == null || Cache.Instance.Approaching.Id != closest.Id))
{
Logging.Log("CombatMissionCtrl.Activate", "Approaching target [" + closest.Name + "][ID: " + closest.Id + "][" + Math.Round(closest.Distance / 1000, 0) + "k away]", Logging.Teal);
closest.Approach();
}
else if (Cache.Instance.IsOrbiting || Cache.Instance.Approaching == null || Cache.Instance.Approaching.Id != closest.Id)
{
Logging.Log("CombatMissionCtrl", "Activate: Delaying approach for: [" + Math.Round(Cache.Instance.NextApproachAction.Subtract(DateTime.Now).TotalSeconds, 0) + "] seconds", Logging.Teal);
}
return;
}
else if (closest.Distance > (int)Distance.WarptoDistance)//we must be outside warpto distance, but we are likely in a deadspace so align to the target
{
// We cant warp if we have drones out - but we are aligning not warping so we do not care
//if (Cache.Instance.ActiveDrones.Count() > 0)
// return;
if (DateTime.Now > Cache.Instance.NextAlign)
{
// Only happens if we are asked to Activate something that is outside Distance.CloseToGateActivationRange (default is: 6k)
Logging.Log("CombatMissionCtrl", "Activate: AlignTo: [" + closest.Name + "] This only happens if we are asked to Activate something that is outside [" + Distance.CloseToGateActivationRange + "]", Logging.Teal);
closest.AlignTo();
}
else
{
Logging.Log("CombatMissionCtrl", "Activate: Unable to align: Next Align in [" + Cache.Instance.NextAlign.Subtract(DateTime.Now).TotalSeconds + "] seconds", Logging.Teal);
}
return;
}
else //how in the world would we ever get here?
{
Logging.Log("CombatMissionCtrl", "Activate: Error: [" + closest.Name + "] at [" + closest.Distance + "] is not within jump distance, within warpable distance or outside warpable distance, (!!!), retrying action.", Logging.Teal);
return;
}
}
private void ClearPocketAction(Actions.Action action)
{
if (!Cache.Instance.NormalApproach)
Cache.Instance.NormalApproach = true;
// Get lowest range
double range = Cache.Instance.MaxRange;
int DistanceToClear;
if (!int.TryParse(action.GetParameterValue("distance"), out DistanceToClear))
DistanceToClear = (int)range;
if (DistanceToClear != 0 && DistanceToClear != -2147483648 && DistanceToClear != 2147483647)
{
range = Math.Min(Cache.Instance.MaxRange, DistanceToClear);
}
//panic handles adding any priority targets and combat will prefer to kill any priority targets
EntityCache target = null;
// Or is there a target that is targeting us?
target = target ?? Cache.Instance.TargetedBy.Where(t => !t.IsSentry && !t.IsEntityIShouldLeaveAlone && !t.IsContainer && t.IsNpc && t.CategoryId == (int)CategoryID.Entity && t.GroupId != (int)Group.LargeCollidableStructure && !Cache.Instance.IgnoreTargets.Contains(t.Name.Trim())).OrderBy(t => t.Distance).FirstOrDefault();
// Or is there any target?
target = target ?? Cache.Instance.Entities.Where(t => !t.IsSentry && !t.IsEntityIShouldLeaveAlone && !t.IsContainer && t.IsNpc && t.CategoryId == (int)CategoryID.Entity && t.GroupId != (int)Group.LargeCollidableStructure && !Cache.Instance.IgnoreTargets.Contains(t.Name.Trim())).OrderBy(t => t.Distance).FirstOrDefault();
if (Settings.Instance.KillSentries)
{
target = target ?? Cache.Instance.Entities.Where(t => !t.IsEntityIShouldLeaveAlone && !t.IsContainer && t.IsNpc && t.CategoryId == (int)CategoryID.Entity && t.GroupId != (int)Group.LargeCollidableStructure && !Cache.Instance.IgnoreTargets.Contains(t.Name.Trim())).OrderBy(t => t.Distance).FirstOrDefault();
}
if (target == null)
_targetNull = true;
else
_targetNull = false;
int targetedby = Cache.Instance.TargetedBy.Count(t => !t.IsSentry && !t.IsEntityIShouldLeaveAlone && !t.IsContainer && t.IsNpc && t.CategoryId == (int)CategoryID.Entity && t.GroupId != (int)Group.LargeCollidableStructure && !Cache.Instance.IgnoreTargets.Contains(t.Name.Trim()));
if (target != null)
{
// Reset timeout
_clearPocketTimeout = null;
// Lock target if within weapons range
if (target.Distance < range)
{
//panic handles adding any priority targets and combat will prefer to kill any priority targets
if (_targetNull && targetedby == 0 && DateTime.Now > Cache.Instance.NextReload)
{
if (!Combat.ReloadAll(target)) return;
}
if (Cache.Instance.DirectEve.ActiveShip.MaxLockedTargets > 0)
{
if (target.IsTarget || target.IsTargeting || target.IsActiveTarget || !target.IsValid) //This target is already targeted no need to target it again
{
//noop
}
else if (!Cache.Instance.IgnoreTargets.Contains(target.Name.Trim()))
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Targeting [" + target.Name + "][ID: " + target.Id + "][" + Math.Round(target.Distance / 1000, 0) + "k away]", Logging.Teal);
target.LockTarget();
}
if (Cache.Instance.IgnoreTargets.Contains(target.Name.Trim()))
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "We have attempted to target an NPC that is on the ignore list (why?) Name [" + target.Name + "][" + target.Id + "][" + target.Distance + "]", Logging.Teal);
}
}
}
NavigateOnGrid.NavigateIntoRange(target, "CombatMissionCtrl." + _pocketActions[_currentAction]);
if (target.Distance > range) //target is not in range...
{
if (DateTime.Now > Cache.Instance.NextReload)
{
//Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction] ,"ReloadAll: Reload weapons",Logging.teal);
if (!Combat.ReloadAll(target)) return;
}
}
return;
}
// Do we have a timeout? No, set it to now + 5 seconds
if (!_clearPocketTimeout.HasValue)
_clearPocketTimeout = DateTime.Now.AddSeconds(5);
// Are we in timeout?
if (DateTime.Now < _clearPocketTimeout.Value)
return;
// We have cleared the Pocket, perform the next action \o/ - reset the timers that we had set for actions...
Nextaction();
// Reset timeout
_clearPocketTimeout = null;
}
private void MoveToAction(Actions.Action action)
{
if (Cache.Instance.NormalApproach)
Cache.Instance.NormalApproach = false;
string target = action.GetParameterValue("target");
// No parameter? Although we should not really allow it, assume its the acceleration gate :)
if (string.IsNullOrEmpty(target))
target = "Acceleration Gate";
int DistanceToApproach;
if (!int.TryParse(action.GetParameterValue("distance"), out DistanceToApproach))
DistanceToApproach = 4000;
bool stopWhenTargeted;
if (!bool.TryParse(action.GetParameterValue("StopWhenTargeted"), out stopWhenTargeted))
stopWhenTargeted = false;
bool stopWhenAggressed;
if (!bool.TryParse(action.GetParameterValue("StopWhenAggressed"), out stopWhenAggressed))
stopWhenAggressed = false;
IEnumerable<EntityCache> targets = Cache.Instance.EntitiesByName(target).ToList();
if (!targets.Any())
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "no entities found named [" + target + "] proceeding to next action", Logging.Teal);
Nextaction();
return;
}
EntityCache closest = targets.OrderBy(t => t.Distance).First();
if (stopWhenTargeted)
{
if (Cache.Instance.TargetedBy != null && Cache.Instance.TargetedBy.Any())
{
if (Cache.Instance.Approaching != null)
{
Cache.Instance.DirectEve.ExecuteCommand(DirectCmd.CmdStopShip);
Cache.Instance.Approaching = null;
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Stop ship, we have been targeted and are [" + DistanceToApproach + "] from [ID: " +
closest.Name + "][" + Math.Round(closest.Distance / 1000, 0) + "k away]", Logging.Teal);
}
}
}
if (stopWhenAggressed)
{
if (Cache.Instance.Aggressed.Any(t => !t.IsSentry))
{
if (Cache.Instance.Approaching != null)
{
Cache.Instance.DirectEve.ExecuteCommand(DirectCmd.CmdStopShip);
Cache.Instance.Approaching = null;
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Stop ship, we have been targeted and are [" + DistanceToApproach + "] from [ID: " +
closest.Name + "][" + Math.Round(closest.Distance / 1000, 0) + "k away]", Logging.Teal);
}
}
}
if (closest.Distance <= DistanceToApproach) // if we are inside the range that we are supposed to approach assume we are done
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "We are [" + Math.Round(closest.Distance, 0) + "] from a [" + target + "] we do not need to go any further", Logging.Teal);
Nextaction();
if (Cache.Instance.Approaching != null)
{
Cache.Instance.DirectEve.ExecuteCommand(DirectCmd.CmdStopShip);
Cache.Instance.Approaching = null;
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Stop ship, we are [" + DistanceToApproach + "] from [ID: " + closest.Name + "][" + Math.Round(closest.Distance / 1000, 0) + "k away]", Logging.Teal);
}
//if (Settings.Instance.SpeedTank)
//{
// //this should at least keep speed tanked ships from going poof if a mission XML uses moveto
// closest.Orbit(Cache.Instance.OrbitDistance);
// Logging.Log("CombatMissionCtrl","MoveTo: Initiating orbit after reaching target")
//}
}
else if (closest.Distance < (int)Distance.WarptoDistance) // if we are inside warptorange you need to approach (you cant warp from here)
{
// Move to the target
if (DateTime.Now > Cache.Instance.NextApproachAction && (Cache.Instance.Approaching == null || Cache.Instance.Approaching.Id != closest.Id))
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Approaching target [" + closest.Name + "][ID: " + closest.Id + "][" + Math.Round(closest.Distance / 1000, 0) + "k away]", Logging.Teal);
closest.Approach();
}
}
else // if we are outside warpto distance (presumably inside a deadspace where we cant warp) align to the target
{
if (DateTime.Now > Cache.Instance.NextAlign)
{
// Probably never happens
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Aligning to target [" + closest.Name + "][ID: " + closest.Id + "][" + Math.Round(closest.Distance / 1000, 0) + "k away]", Logging.Teal);
closest.AlignTo();
}
}
return;
}
private void UseDrones(Actions.Action action)
{
bool usedrones;
if (!bool.TryParse(action.GetParameterValue("use"), out usedrones))
usedrones = true;
if (!usedrones)
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Disable launch of drones", Logging.Teal);
Cache.Instance.UseDrones = false;
}
else
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Enable launch of drones", Logging.Teal);
Cache.Instance.UseDrones = true;
}
Nextaction();
return;
}
private void ActivateAction(Actions.Action action)
{
if (DateTime.UtcNow < _nextCombatMissionCtrlAction)
return;
//we cant move in bastion mode, do not try
List<ModuleCache> bastionModules = null;
bastionModules = Cache.Instance.Modules.Where(m => m.GroupId == (int)Group.Bastion && m.IsOnline).ToList();
if (bastionModules.Any(i => i.IsActive))
{
Logging.Log("CombatMissionCtrl.Activate", "BastionMode is active, we cannot move, aborting attempt to Activate until bastion deactivates", Logging.Debug);
_nextCombatMissionCtrlAction = DateTime.UtcNow.AddSeconds(15);
return;
}
bool optional;
if (!bool.TryParse(action.GetParameterValue("optional"), out optional))
{
optional = false;
}
string target = action.GetParameterValue("target");
// No parameter? Although we should not really allow it, assume its the acceleration gate :)
if (string.IsNullOrEmpty(target))
{
target = "Acceleration Gate";
}
IEnumerable<EntityCache> targets = Cache.Instance.EntitiesByName(target, Cache.Instance.EntitiesOnGrid.Where(i => i.Distance < (int)Distances.OnGridWithMe)).ToList();
if (!targets.Any())
{
if (!_waiting)
{
Logging.Log("CombatMissionCtrl", "Activate: Can't find [" + target + "] to activate! Waiting 30 seconds before giving up", Logging.Teal);
_waitingSince = DateTime.UtcNow;
_waiting = true;
}
else if (_waiting)
{
if (DateTime.UtcNow.Subtract(_waitingSince).TotalSeconds > Time.Instance.NoGateFoundRetryDelay_seconds)
{
Logging.Log("CombatMissionCtrl",
"Activate: After 30 seconds of waiting the gate is still not on grid: CombatMissionCtrlState.Error",
Logging.Teal);
if (optional) //if this action has the optional parameter defined as true then we are done if we cant find the gate
{
DoneAction();
}
else
{
_States.CurrentCombatMissionCtrlState = CombatMissionCtrlState.Error;
}
}
}
return;
}
//if (closest.Distance <= (int)Distance.CloseToGateActivationRange) // if your distance is less than the 'close enough' range, default is 7000 meters
EntityCache closest = targets.OrderBy(t => t.Distance).FirstOrDefault();
if (closest != null)
{
if (closest.Distance <= (int)Distances.GateActivationRange)
{
if (Settings.Instance.DebugActivateGate) Logging.Log("CombatMissionCtrl", "if (closest.Distance [" + closest.Distance + "] <= (int)Distances.GateActivationRange [" + (int)Distances.GateActivationRange + "])", Logging.Green);
// Tell the drones module to retract drones
Cache.Instance.IsMissionPocketDone = true;
// We cant activate if we have drones out
if (Cache.Instance.ActiveDrones.Any())
{
if (Settings.Instance.DebugActivateGate) Logging.Log("CombatMissionCtrl", "if (Cache.Instance.ActiveDrones.Any())", Logging.Green);
return;
}
//
// this is a bad idea for a speed tank, we ought to somehow cache the object they are orbiting/approaching, etc
// this seemingly slowed down the exit from certain missions for me for 2-3min as it had a command to orbit some random object
// after the "done" command
//
if (closest.Distance < -10100)
{
if (Settings.Instance.DebugActivateGate) Logging.Log("CombatMissionCtrl", "if (closest.Distance < -10100)", Logging.Green);
AttemptsToGetAwayFromGate++;
if (AttemptsToGetAwayFromGate > 30)
{
if (DateTime.UtcNow > Cache.Instance.NextOrbit)
{
closest.Orbit(1000);
Logging.Log("CombatMissionCtrl", "Activate: We are too close to [" + closest.Name + "] Initiating orbit", Logging.Orange);
}
return;
}
}
if (Settings.Instance.DebugActivateGate) Logging.Log("CombatMissionCtrl", "if (closest.Distance >= -10100)", Logging.Green);
// Add bookmark (before we activate)
if (Settings.Instance.CreateSalvageBookmarks)
{
BookmarkPocketForSalvaging();
}
if (Settings.Instance.DebugActivateGate) Logging.Log("CombatMissionCtrl", "Activate: Reload before moving to next pocket", Logging.Teal);
if (!Combat.ReloadAll(Cache.Instance.MyShipEntity, true)) return;
if (Settings.Instance.DebugActivateGate) Logging.Log("CombatMissionCtrl", "Activate: Done reloading", Logging.Teal);
AttemptsToActivateGateTimer++;
if (DateTime.UtcNow > Cache.Instance.NextActivateAction || AttemptsToActivateGateTimer > 30)
{
Logging.Log("CombatMissionCtrl", "Activate: [" + closest.Name + "] Move to next pocket after reload command and change state to 'NextPocket'", Logging.Green);
closest.Activate();
AttemptsToActivateGateTimer = 0;
// Do not change actions, if NextPocket gets a timeout (>2 mins) then it reverts to the last action
_moveToNextPocket = DateTime.UtcNow;
_States.CurrentCombatMissionCtrlState = CombatMissionCtrlState.NextPocket;
}
if (Settings.Instance.DebugActivateGate) Logging.Log("CombatMissionCtrl", "------------------", Logging.Green);
return;
}
AttemptsToActivateGateTimer = 0;
AttemptsToGetAwayFromGate = 0;
if (closest.Distance < (int)Distances.WarptoDistance) //else if (closest.Distance < (int)Distances.WarptoDistance) //if we are inside warpto distance then approach
{
if (Settings.Instance.DebugActivateGate) Logging.Log("CombatMissionCtrl", "if (closest.Distance < (int)Distances.WarptoDistance)", Logging.Green);
// Move to the target
if (DateTime.UtcNow > Cache.Instance.NextApproachAction)
{
if (Cache.Instance.IsOrbiting(closest.Id) || Cache.Instance.Approaching == null || Cache.Instance.Approaching.Id != closest.Id || Cache.Instance.MyShipEntity.Velocity < 100)
{
Logging.Log("CombatMissionCtrl.Activate", "Approaching target [" + closest.Name + "][" + Cache.Instance.MaskedID(closest.Id) + "][" + Math.Round(closest.Distance / 1000, 0) + "k away]", Logging.Teal);
closest.Approach();
return;
}
if (Settings.Instance.DebugActivateGate) Logging.Log("CombatMissionCtrl", "Cache.Instance.IsOrbiting [" + Cache.Instance.IsOrbiting(closest.Id) + "] Cache.Instance.MyShip.Velocity [" + Math.Round(Cache.Instance.MyShipEntity.Velocity,0) + "m/s]", Logging.Green);
if (Settings.Instance.DebugActivateGate) if (Cache.Instance.Approaching != null) Logging.Log("CombatMissionCtrl", "Cache.Instance.Approaching.Id [" + Cache.Instance.Approaching.Id + "][closest.Id: " + closest.Id + "]", Logging.Green);
if (Settings.Instance.DebugActivateGate) Logging.Log("CombatMissionCtrl", "------------------", Logging.Green);
return;
}
if (Cache.Instance.IsOrbiting(closest.Id) || Cache.Instance.Approaching == null || Cache.Instance.Approaching.Id != closest.Id)
{
Logging.Log("CombatMissionCtrl", "Activate: Delaying approach for: [" + Math.Round(Cache.Instance.NextApproachAction.Subtract(DateTime.UtcNow).TotalSeconds, 0) + "] seconds", Logging.Teal);
return;
}
if (Settings.Instance.DebugActivateGate) Logging.Log("CombatMissionCtrl", "------------------", Logging.Green);
return;
}
if (closest.Distance > (int)Distances.WarptoDistance)//we must be outside warpto distance, but we are likely in a DeadSpace so align to the target
{
// We cant warp if we have drones out - but we are aligning not warping so we do not care
//if (Cache.Instance.ActiveDrones.Count() > 0)
// return;
if (DateTime.UtcNow > Cache.Instance.NextAlign)
{
// Only happens if we are asked to Activate something that is outside Distance.CloseToGateActivationRange (default is: 6k)
Logging.Log("CombatMissionCtrl", "Activate: AlignTo: [" + closest.Name + "] This only happens if we are asked to Activate something that is outside [" + Distances.CloseToGateActivationRange + "]", Logging.Teal);
closest.AlignTo();
return;
}
Logging.Log("CombatMissionCtrl", "Activate: Unable to align: Next Align in [" + Cache.Instance.NextAlign.Subtract(DateTime.UtcNow).TotalSeconds + "] seconds", Logging.Teal);
return;
}
Logging.Log("CombatMissionCtrl", "Activate: Error: [" + closest.Name + "] at [" + closest.Distance + "] is not within jump distance, within warpable distance or outside warpable distance, (!!!), retrying action.", Logging.Teal);
}
return;
}
private void ActivateBastionAction(Actions.Action action)
{
bool _done = false;
if (Cache.Instance.Modules.Any())
{
List<ModuleCache> bastionModules = null;
bastionModules = Cache.Instance.Modules.Where(m => m.GroupId == (int)Group.Bastion && m.IsOnline).ToList();
if (!bastionModules.Any() || bastionModules.Any(i => i.IsActive))
{
_done = true;
}
}
if (_done)
{
Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "ActivateBastion Action completed.", Logging.Teal);
// Nothing has targeted us in the specified timeout
_waiting = false;
Nextaction();
return;
}
// Default timeout is 60 seconds
int DeactivateAfterSeconds;
if (!int.TryParse(action.GetParameterValue("DeactivateAfterSeconds"), out DeactivateAfterSeconds))
{
DeactivateAfterSeconds = 5;
}
Cache.Instance.NextBastionModeDeactivate = DateTime.UtcNow.AddSeconds(DeactivateAfterSeconds);
// Start bastion mode
if (!Combat.ActivateBastion()) return;
return;
}
private void OrbitEntityAction(Actions.Action action)
{
if (Cache.Instance.NormalApproach)
{
Cache.Instance.NormalApproach = false;
}
Cache.Instance.normalNav = false;
string target = action.GetParameterValue("target");
bool notTheClosest;
if (!bool.TryParse(action.GetParameterValue("notclosest"), out notTheClosest))
{
notTheClosest = false;
}
// No parameter? Although we should not really allow it, assume its the acceleration gate :)
if (string.IsNullOrEmpty(target))
{
Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "No Entity Specified to orbit: skipping OrbitEntity Action", Logging.Teal);
Nextaction();
return;
}
IEnumerable<EntityCache> targets = Cache.Instance.EntitiesByPartialName(target).ToList();
if (!targets.Any())
{
// Unlike activate, no target just means next action
_currentAction++;
return;
}
EntityCache closest = targets.OrderBy(t => t.Distance).FirstOrDefault();
if (notTheClosest)
{
closest = targets.OrderByDescending(t => t.Distance).FirstOrDefault();
}
if (closest != null)
{
// Move to the target
Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "Setting [" + closest.Name + "][" + Cache.Instance.MaskedID(closest.Id) + "][" + Math.Round(closest.Distance / 1000, 0) + "k away as the Orbit Target]", Logging.Teal);
closest.Orbit(Cache.Instance.OrbitDistance);
}
Nextaction();
return;
}
private void WaitUntilAggressed(Actions.Action action)
{
// Default timeout is 60 seconds
int timeout;
if (!int.TryParse(action.GetParameterValue("timeout"), out timeout))
{
timeout = 60;
}
// Default timeout is 30 seconds
int WaitUntilShieldsAreThisLow;
if (!int.TryParse(action.GetParameterValue("WaitUntilShieldsAreThisLow"), out WaitUntilShieldsAreThisLow))
{
WaitUntilShieldsAreThisLow = 45;
Settings.Instance.MinimumShieldPct = WaitUntilShieldsAreThisLow;
}
// Default timeout is 30 seconds
int WaitUntilArmorIsThisLow;
if (!int.TryParse(action.GetParameterValue("WaitUntilArmorIsThisLow"), out WaitUntilArmorIsThisLow))
{
WaitUntilArmorIsThisLow = 100;
Settings.Instance.MinimumArmorPct = WaitUntilArmorIsThisLow;
}
if (_waiting)
{
if (DateTime.UtcNow.Subtract(_waitingSince).TotalSeconds < timeout)
{
return;
}
Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "Nothing targeted us within [ " + timeout + "sec]!", Logging.Teal);
// Nothing has targeted us in the specified timeout
_waiting = false;
Nextaction();
return;
}
// Start waiting
_waiting = true;
_waitingSince = DateTime.UtcNow;
return;
}
private void MoveToBackgroundAction(Actions.Action action)
{
if (DateTime.UtcNow < _nextCombatMissionCtrlAction)
return;
//we cant move in bastion mode, do not try
List<ModuleCache> bastionModules = null;
bastionModules = Cache.Instance.Modules.Where(m => m.GroupId == (int)Group.Bastion && m.IsOnline).ToList();
if (bastionModules.Any(i => i.IsActive))
{
Logging.Log("CombatMissionCtrl.MoveToBackground", "BastionMode is active, we cannot move, aborting attempt to Activate until bastion deactivates", Logging.Debug);
_nextCombatMissionCtrlAction = DateTime.UtcNow.AddSeconds(15);
return;
}
if (Cache.Instance.NormalApproach)
{
Cache.Instance.NormalApproach = false;
}
Cache.Instance.normalNav = false;
int DistanceToApproach;
if (!int.TryParse(action.GetParameterValue("distance"), out DistanceToApproach))
{
DistanceToApproach = (int)Distances.GateActivationRange;
}
string target = action.GetParameterValue("target");
// No parameter? Although we should not really allow it, assume its the acceleration gate :)
if (string.IsNullOrEmpty(target))
{
target = "Acceleration Gate";
}
IEnumerable<EntityCache> targets = Cache.Instance.EntitiesByName(target, Cache.Instance.EntitiesOnGrid.ToList());
if (!targets.Any())
{
// Unlike activate, no target just means next action
_currentAction++;
return;
}
EntityCache closest = targets.OrderBy(t => t.Distance).FirstOrDefault();
if (closest != null)
{
// Move to the target
Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "Approaching target [" + closest.Name + "][" + Cache.Instance.MaskedID(closest.Id) + "][" + Math.Round(closest.Distance / 1000, 0) + "k away]", Logging.Teal);
closest.Approach(DistanceToApproach);
_nextCombatMissionCtrlAction = DateTime.UtcNow.AddSeconds(5);
}
Nextaction();
return;
}
private void MoveToAction(Actions.Action action)
{
if (DateTime.UtcNow < _nextCombatMissionCtrlAction)
return;
//we cant move in bastion mode, do not try
List<ModuleCache> bastionModules = null;
bastionModules = Cache.Instance.Modules.Where(m => m.GroupId == (int)Group.Bastion && m.IsOnline).ToList();
if (bastionModules.Any(i => i.IsActive))
{
Logging.Log("CombatMissionCtrl.MoveTo", "BastionMode is active, we cannot move, aborting attempt to Activate until bastion deactivates", Logging.Debug);
_nextCombatMissionCtrlAction = DateTime.UtcNow.AddSeconds(15);
return;
}
if (Cache.Instance.NormalApproach)
{
Cache.Instance.NormalApproach = false;
}
Cache.Instance.normalNav = false;
string target = action.GetParameterValue("target");
// No parameter? Although we should not really allow it, assume its the acceleration gate :)
if (string.IsNullOrEmpty(target))
{
target = "Acceleration Gate";
}
int DistanceToApproach;
if (!int.TryParse(action.GetParameterValue("distance"), out DistanceToApproach))
{
DistanceToApproach = (int)Distances.GateActivationRange;
}
bool stopWhenTargeted;
if (!bool.TryParse(action.GetParameterValue("StopWhenTargeted"), out stopWhenTargeted))
{
stopWhenTargeted = false;
}
bool stopWhenAggressed;
if (!bool.TryParse(action.GetParameterValue("StopWhenAggressed"), out stopWhenAggressed))
{
stopWhenAggressed = false;
}
IEnumerable<EntityCache> targets = Cache.Instance.EntitiesByName(target, Cache.Instance.EntitiesOnGrid.ToList());
if (!targets.Any())
{
Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "no entities found named [" + target + "] proceeding to next action", Logging.Teal);
Nextaction();
return;
}
EntityCache closest = targets.OrderBy(t => t.Distance).FirstOrDefault();
//if (Settings.Instance.TargetSelectionMethod == "isdp")
//{
Cache.Instance.GetBestPrimaryWeaponTarget(Cache.Instance.MaxRange, false, "Combat");
//}
//else //use new target selection method
//{
// Cache.Instance.__GetBestWeaponTargets(Cache.Instance.MaxRange);
//}
if (closest != null)
{
if (stopWhenTargeted)
{
if (Cache.Instance.TargetedBy != null && Cache.Instance.TargetedBy.Any())
{
if (Cache.Instance.Approaching != null)
{
if (Cache.Instance.MyShipEntity.Velocity != 0 && DateTime.UtcNow > Cache.Instance.NextApproachAction)
{
NavigateOnGrid.StopMyShip();
Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "Stop ship, we have been targeted and are [" + DistanceToApproach + "] from [ID: " + closest.Name + "][" + Math.Round(closest.Distance / 1000, 0) + "k away]", Logging.Teal);
}
}
}
}
if (stopWhenAggressed)
{
if (Cache.Instance.Aggressed.Any(t => !t.IsSentry))
{
if (Cache.Instance.Approaching != null)
{
if (Cache.Instance.MyShipEntity.Velocity != 0 && DateTime.UtcNow > Cache.Instance.NextApproachAction)
{
NavigateOnGrid.StopMyShip();
Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "Stop ship, we have been targeted and are [" + DistanceToApproach + "] from [ID: " + closest.Name + "][" + Math.Round(closest.Distance / 1000, 0) + "k away]", Logging.Teal);
}
}
}
}
if (closest.Distance < DistanceToApproach) // if we are inside the range that we are supposed to approach assume we are done
{
Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "We are [" + Math.Round(closest.Distance, 0) + "] from a [" + target + "] we do not need to go any further", Logging.Teal);
Nextaction();
if (Cache.Instance.Approaching != null)
{
if (Cache.Instance.MyShipEntity.Velocity != 0 && DateTime.UtcNow > Cache.Instance.NextApproachAction)
{
NavigateOnGrid.StopMyShip();
Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "Stop ship, we have been targeted and are [" + DistanceToApproach + "] from [ID: " + closest.Name + "][" + Math.Round(closest.Distance / 1000, 0) + "k away]", Logging.Teal);
}
}
//if (Settings.Instance.SpeedTank)
//{
// //this should at least keep speed tanked ships from going poof if a mission XML uses moveto
// closest.Orbit(Cache.Instance.OrbitDistance);
// Logging.Log("CombatMissionCtrl","MoveTo: Initiating orbit after reaching target")
//}
return;
}
if (closest.Distance < (int)Distances.WarptoDistance) // if we are inside warpto range you need to approach (you cant warp from here)
{
if (Settings.Instance.DebugMoveTo) Logging.Log("CombatMissionCtrl.MoveTo", "if (closest.Distance < (int)Distances.WarptoDistance)] - NextApproachAction [" + Cache.Instance.NextApproachAction + "]", Logging.Teal);
// Move to the target
if (Settings.Instance.DebugMoveTo) if (Cache.Instance.Approaching == null) Logging.Log("CombatMissionCtrl.MoveTo", "if (Cache.Instance.Approaching == null)", Logging.Teal);
if (Settings.Instance.DebugMoveTo) if (Cache.Instance.Approaching != null) Logging.Log("CombatMissionCtrl.MoveTo", "Cache.Instance.Approaching.Id [" + Cache.Instance.Approaching.Id + "]", Logging.Teal);
if (Cache.Instance.Approaching == null || Cache.Instance.Approaching.Id != closest.Id || Cache.Instance.MyShipEntity.Velocity < 100)
{
Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "Approaching target [" + closest.Name + "][" + Cache.Instance.MaskedID(closest.Id) + "][" + Math.Round(closest.Distance / 1000, 0) + "k away]", Logging.Teal);
closest.Approach();
_nextCombatMissionCtrlAction = DateTime.UtcNow.AddSeconds(5);
return;
}
if (Settings.Instance.DebugMoveTo) if (Cache.Instance.Approaching != null) Logging.Log("CombatMissionCtrl.MoveTo", "-----------", Logging.Teal);
return;
}
if (DateTime.UtcNow > Cache.Instance.NextAlign)
{
// Probably never happens
Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "Aligning to target [" + closest.Name + "][" + Cache.Instance.MaskedID(closest.Id) + "][" + Math.Round(closest.Distance / 1000, 0) + "k away]", Logging.Teal);
closest.AlignTo();
_nextCombatMissionCtrlAction = DateTime.UtcNow.AddSeconds(5);
return;
}
if (Settings.Instance.DebugMoveTo) Logging.Log("CombatMissionCtrl.MoveTo", "Nothing to do. Next Approach [" + Cache.Instance.NextApproachAction + " ] NextAlign [" + Cache.Instance.NextAlign + "]", Logging.Teal);
}
return;
}
private void LootItemAction(Actions.Action action)
{
try
{
Cache.Instance.CurrentlyShouldBeSalvaging = true;
Cache.Instance.MissionLoot = true;
List<string> items = action.GetParameterValues("item");
List<string> targetNames = action.GetParameterValues("target");
// if we are not generally looting we need to re-enable the opening of wrecks to
// find this LootItems we are looking for
if (Settings.Instance.SpeedTank || !Settings.Instance.SpeedTank) Cache.Instance.OpenWrecks = true;
int quantity;
if (!int.TryParse(action.GetParameterValue("quantity"), out quantity))
{
quantity = 1;
}
bool done = items.Count == 0;
if (!done)
{
//if (!Cache.Instance.OpenCargoHold("CombatMissionCtrl.LootItemAction")) return;
if (Cache.Instance.CurrentShipsCargo.Window.IsReady)
{
if (Cache.Instance.CurrentShipsCargo.Items.Any(i => (items.Contains(i.TypeName) && (i.Quantity >= quantity))))
{
done = true;
}
}
}
if (done)
{
Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "We are done looting - we have the item(s)", Logging.Teal);
// now that we have completed this action revert OpenWrecks to false
if (Settings.Instance.SpeedTank) Cache.Instance.OpenWrecks = false;
Cache.Instance.MissionLoot = false;
Cache.Instance.CurrentlyShouldBeSalvaging = false;
_currentAction++;
return;
}
//
// sorting by distance is bad if we are moving (we'd change targets unpredictably)... sorting by ID should be better and be nearly the same(?!)
//
IOrderedEnumerable<EntityCache> containers = Cache.Instance.Containers.Where(e => !Cache.Instance.LootedContainers.Contains(e.Id)).OrderBy(e => e.Distance);
if (!containers.Any())
{
Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "We are done looting - no containers left to loot", Logging.Teal);
if (Settings.Instance.SpeedTank) Cache.Instance.OpenWrecks = false;
Cache.Instance.MissionLoot = false;
Cache.Instance.CurrentlyShouldBeSalvaging = false;
_currentAction++;
return;
}
EntityCache container = containers.FirstOrDefault(c => targetNames.Contains(c.Name)) ?? containers.FirstOrDefault();
if (container != null && (container.Distance > (int)Distances.SafeScoopRange && (Cache.Instance.Approaching == null || Cache.Instance.Approaching.Id != container.Id)))
{
if (DateTime.UtcNow > Cache.Instance.NextApproachAction && (Cache.Instance.Approaching == null || Cache.Instance.Approaching.Id != container.Id))
{
Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "Approaching target [" + container.Name + "][" + Cache.Instance.MaskedID(container.Id) + "] which is at [" + Math.Round(container.Distance / 1000, 0) + "k away]", Logging.Teal);
container.Approach();
}
}
}
catch (Exception exception)
{
Logging.Log("CombatMissionCtrl.LootItemAction","Exception logged was [" + exception + "]",Logging.Teal);
}
return;
}
private void KillOnceAction(Actions.Action action)
{
if (Cache.Instance.NormalApproach)
Cache.Instance.NormalApproach = false;
bool notTheClosest;
if (!bool.TryParse(action.GetParameterValue("notclosest"), out notTheClosest))
notTheClosest = false;
int numberToIgnore;
if (!int.TryParse(action.GetParameterValue("numbertoignore"), out numberToIgnore))
numberToIgnore = 0;
List<string> targetNames = action.GetParameterValues("target");
// No parameter? Ignore kill action
if (targetNames.Count == 0)
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "No targets defined in kill action!", Logging.Orange);
Nextaction();
return;
}
IEnumerable<EntityCache> targets = Cache.Instance.Entities.Where(e => targetNames.Contains(e.Name)).ToList();
if (targets.Count() == numberToIgnore)
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "All targets killed " + targetNames.Aggregate((current, next) => current + "[" + next + "]"), Logging.Teal);
// We killed it/them !?!?!? :)
Nextaction();
return;
}
EntityCache target = targets.OrderBy(t => t.Distance).First();
if (target != null)
{
// Reset timeout
_clearPocketTimeout = null;
// Are we approaching the active (out of range) target?
// Wait for it (or others) to get into range
// Lock priority target if within weapons range
if (notTheClosest)
target = targets.OrderByDescending(t => t.Distance).First();
if (target.Distance < Cache.Instance.MaxRange)
{
//panic handles adding any priority targets and combat will prefer to kill any priority targets
if (Cache.Instance.PriorityTargets.All(pt => pt.Id != target.Id))
{
//Adds the target we want to kill to the priority list so that combat.cs will kill it (especially if it is an LCO this is important)
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Adding [" + target.Name + "][ID: " + target.Id + "] as a priority target", Logging.Teal);
Cache.Instance.AddPriorityTargets(new[] { target }, Priority.PriorityKillTarget);
}
if (Cache.Instance.DirectEve.ActiveShip.MaxLockedTargets > 0)
{
if (!(target.IsTarget || target.IsTargeting)) //This target is not targeted and need to target it
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Targeting [" + target.Name + "][ID: " + target.Id + "][" + Math.Round(target.Distance / 1000, 0) + "k away]", Logging.Teal);
target.LockTarget();
// the target has been added to the priority targets list and has been targeted.
// this should ensure that the combat module (and/or the next action) kills the target.
Nextaction();
return;
}
}
}
NavigateOnGrid.NavigateIntoRange(target, "CombatMissionCtrl." + _pocketActions[_currentAction]);
return;
}
}
private void AddWebifierByNameAction(Actions.Action action)
{
bool notTheClosest;
if (!bool.TryParse(action.GetParameterValue("notclosest"), out notTheClosest))
{
notTheClosest = false;
}
int numberToIgnore;
if (!int.TryParse(action.GetParameterValue("numbertoignore"), out numberToIgnore))
{
numberToIgnore = 0;
}
List<string> targetNames = action.GetParameterValues("target");
// No parameter? Ignore kill action
if (!targetNames.Any())
{
Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "No targets defined in AddWebifierByName action!", Logging.Teal);
Nextaction();
return;
}
Cache.Instance.AddWebifierByName(targetNames.FirstOrDefault(), numberToIgnore, notTheClosest);
//
// this action is passive and only adds things to the WarpScramblers list )before they have a chance to scramble you, so you can target them early
//
Nextaction();
return;
}
private void LootItemAction(Actions.Action action)
{
Cache.Instance.MissionLoot = true;
List<string> items = action.GetParameterValues("item");
List<string> targetNames = action.GetParameterValues("target");
// if we are not generally looting we need to re-enable the opening of wrecks to
// find this LootItems we are looking for
Cache.Instance.OpenWrecks = true;
int quantity;
if (!int.TryParse(action.GetParameterValue("quantity"), out quantity))
quantity = 1;
bool done = items.Count == 0;
if (!done)
{
DirectContainer cargo = Cache.Instance.DirectEve.GetShipsCargo();
// We assume that the ship's cargo will be opened somewhere else
if (cargo.Window.IsReady)
done |= cargo.Items.Any(i => (items.Contains(i.TypeName) && (i.Quantity >= quantity)));
}
if (done)
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "We are done looting", Logging.Teal);
// now that we have completed this action revert OpenWrecks to false
Cache.Instance.OpenWrecks = false;
Cache.Instance.MissionLoot = false;
_currentAction++;
return;
}
IOrderedEnumerable<EntityCache> containers = Cache.Instance.Containers.Where(e => !Cache.Instance.LootedContainers.Contains(e.Id)).OrderBy(e => e.Distance);
//IOrderedEnumerable<EntityCache> containers = Cache.Instance.Containers.Where(e => !Cache.Instance.LootedContainers.Contains(e.Id)).OrderBy(e => e.Id);
//IOrderedEnumerable<EntityCache> containers = Cache.Instance.Containers.Where(e => !Cache.Instance.LootedContainers.Contains(e.Id)).OrderByDescending(e => e.Id);
if (!containers.Any())
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "We are done looting", Logging.Teal);
_currentAction++;
return;
}
EntityCache container = containers.FirstOrDefault(c => targetNames.Contains(c.Name)) ?? containers.FirstOrDefault();
if (container != null && (container.Distance > (int)Distance.SafeScoopRange && (Cache.Instance.Approaching == null || Cache.Instance.Approaching.Id != container.Id)))
{
if (DateTime.Now > Cache.Instance.NextApproachAction && (Cache.Instance.Approaching == null || Cache.Instance.Approaching.Id != container.Id))
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Approaching target [" + container.Name + "][ID: " + container.Id + "] which is at [" + Math.Round(container.Distance / 1000, 0) + "k away]", Logging.Teal);
container.Approach();
}
}
}
private void ClearAggroAction(Actions.Action action)
{
if (!Cache.Instance.NormalApproach) Cache.Instance.NormalApproach = true;
// Get lowest range
int DistanceToClear;
if (!int.TryParse(action.GetParameterValue("distance"), out DistanceToClear))
{
DistanceToClear = (int)Distances.OnGridWithMe;
}
if (DistanceToClear != 0 && DistanceToClear != -2147483648 && DistanceToClear != 2147483647)
{
DistanceToClear = (int)Distances.OnGridWithMe;
}
//if (Settings.Instance.TargetSelectionMethod == "isdp")
//{
if (Cache.Instance.GetBestPrimaryWeaponTarget(DistanceToClear, false, "combat", Cache.Instance.combatTargets.Where(t => t.IsTargetedBy).ToList()))
_clearPocketTimeout = null;
//}
//else //use new target selection method
//{
// if (Cache.Instance.__GetBestWeaponTargets(DistanceToClear, Cache.Instance.combatTargets.Where(t => t.IsTargetedBy)).Any())
// _clearPocketTimeout = null;
//}
// Do we have a timeout? No, set it to now + 5 seconds
if (!_clearPocketTimeout.HasValue) _clearPocketTimeout = DateTime.UtcNow.AddSeconds(5);
// Are we in timeout?
if (DateTime.UtcNow < _clearPocketTimeout.Value) return;
// We have cleared the Pocket, perform the next action \o/ - reset the timers that we had set for actions...
Nextaction();
// Reset timeout
_clearPocketTimeout = null;
}
private void MoveToBackgroundAction(Actions.Action action)
{
if (Cache.Instance.NormalApproach)
Cache.Instance.NormalApproach = false;
int DistanceToApproach;
if (!int.TryParse(action.GetParameterValue("distance"), out DistanceToApproach))
DistanceToApproach = 4000;
string target = action.GetParameterValue("target");
// No parameter? Although we should not really allow it, assume its the acceleration gate :)
if (string.IsNullOrEmpty(target))
target = "Acceleration Gate";
IEnumerable<EntityCache> targets = Cache.Instance.EntitiesByName(target).ToList();
if (!targets.Any())
{
// Unlike activate, no target just means next action
_currentAction++;
return;
}
EntityCache closest = targets.OrderBy(t => t.Distance).First();
// Move to the target
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Approaching target [" + closest.Name + "][ID: " + closest.Id + "][" + Math.Round(closest.Distance / 1000, 0) + "k away]", Logging.Teal);
closest.Approach(DistanceToApproach);
Nextaction();
}
private void ClearPocketAction(Actions.Action action)
{
if (!Cache.Instance.NormalApproach)
{
Cache.Instance.NormalApproach = true;
}
// Get lowest range
int DistanceToClear;
if (!int.TryParse(action.GetParameterValue("distance"), out DistanceToClear))
{
DistanceToClear = (int)Cache.Instance.MaxRange;
}
if (DistanceToClear != 0 && DistanceToClear != -2147483648 && DistanceToClear != 2147483647)
{
DistanceToClear = (int)Distances.OnGridWithMe;
}
//panic handles adding any priority targets and combat will prefer to kill any priority targets
//If the closest target is out side of our max range, combat cant target, which means GetBest cant return true, so we are going to try and use potentialCombatTargets instead
if (Cache.Instance.PotentialCombatTargets.Any())
{
//we may be too far out of range of the closest target to get combat to kick in, lets move us into range here
EntityCache ClosestPotentialCombatTarget = null;
if (Settings.Instance.DebugClearPocket) Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "Cache.Instance.__GetBestWeaponTargets(DistanceToClear);", Logging.Debug);
// Target
//if (Settings.Instance.TargetSelectionMethod == "isdp")
//{
if (Cache.Instance.GetBestPrimaryWeaponTarget(DistanceToClear, false, "combat"))
_clearPocketTimeout = null;
//}
//else //use new target selection method
//{
// if (Cache.Instance.__GetBestWeaponTargets(DistanceToClear).Any())
// _clearPocketTimeout = null;
//}
//
// grab the preferredPrimaryWeaponsTarget if its defined and exists on grid as our navigation point
//
if (Cache.Instance.PreferredPrimaryWeaponTargetID != null && Cache.Instance.PreferredPrimaryWeaponTarget != null)
{
if (Cache.Instance.PreferredPrimaryWeaponTarget.IsOnGridWithMe)
{
if (Settings.Instance.DebugClearPocket) Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "ClosestPotentialCombatTarget = Cache.Instance.PreferredPrimaryWeaponTarget [" + Cache.Instance.PreferredPrimaryWeaponTarget.Name + "]", Logging.Debug);
ClosestPotentialCombatTarget = Cache.Instance.PreferredPrimaryWeaponTarget;
}
}
//
// retry to use PreferredPrimaryWeaponTarget
//
if (ClosestPotentialCombatTarget == null && Cache.Instance.PreferredPrimaryWeaponTargetID != null && Cache.Instance.PreferredPrimaryWeaponTarget != null)
{
if (Cache.Instance.PreferredPrimaryWeaponTarget.IsOnGridWithMe)
{
if (Settings.Instance.DebugClearPocket) Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "ClosestPotentialCombatTarget = Cache.Instance.PreferredPrimaryWeaponTarget [" + Cache.Instance.PreferredPrimaryWeaponTarget.Name + "]", Logging.Debug);
ClosestPotentialCombatTarget = Cache.Instance.PreferredPrimaryWeaponTarget;
}
}
if (ClosestPotentialCombatTarget == null) //otherwise just grab something close (excluding sentries)
{
if (Settings.Instance.DebugClearPocket) Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "ClosestPotentialCombatTarget = Cache.Instance.PotentialCombatTargets.OrderBy(t => t.Nearest5kDistance).FirstOrDefault(); [" + Cache.Instance.PotentialCombatTargets.OrderBy(t => t.Nearest5kDistance).FirstOrDefault().Name + "]", Logging.Debug);
ClosestPotentialCombatTarget = Cache.Instance.PotentialCombatTargets.OrderBy(t => t.Nearest5kDistance).FirstOrDefault();
}
if (ClosestPotentialCombatTarget != null && (ClosestPotentialCombatTarget.Distance > Cache.Instance.MaxRange || !ClosestPotentialCombatTarget.IsInOptimalRange))
{
if (!Cache.Instance.IsApproachingOrOrbiting(ClosestPotentialCombatTarget.Id))
{
NavigateOnGrid.NavigateIntoRange(ClosestPotentialCombatTarget, "combatMissionControl", true);
}
}
_clearPocketTimeout = null;
}
//Cache.Instance.AddPrimaryWeaponPriorityTargets(Cache.Instance.potentialCombatTargets.Where(t => targetNames.Contains(t.Name)).OrderBy(t => t.Distance).ToList(), PrimaryWeaponPriority.PriorityKillTarget, "CombatMissionCtrl.KillClosestByName");
// Do we have a timeout? No, set it to now + 5 seconds
if (!_clearPocketTimeout.HasValue) _clearPocketTimeout = DateTime.UtcNow.AddSeconds(5);
// Are we in timeout?
if (DateTime.UtcNow < _clearPocketTimeout.Value) return;
// We have cleared the Pocket, perform the next action \o/ - reset the timers that we had set for actions...
Nextaction();
// Reset timeout
_clearPocketTimeout = null;
return;
}
private void WaitUntilTargeted(Actions.Action action)
{
IEnumerable<EntityCache> targetedBy = Cache.Instance.TargetedBy;
if (targetedBy != null && targetedBy.Any())
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "We have been targeted!", Logging.Teal);
// We have been locked, go go go ;)
_waiting = false;
Nextaction();
return;
}
// Default timeout is 30 seconds
int timeout;
if (!int.TryParse(action.GetParameterValue("timeout"), out timeout))
timeout = 30;
if (_waiting)
{
if (DateTime.Now.Subtract(_waitingSince).TotalSeconds < timeout)
return;
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Nothing targeted us within [ " + timeout + "sec]!", Logging.Teal);
// Nothing has targeted us in the specified timeout
_waiting = false;
Nextaction();
return;
}
// Start waiting
_waiting = true;
_waitingSince = DateTime.Now;
}
private void ClearWithinWeaponsRangeOnlyAction(Actions.Action action)
{
// Get lowest range
int DistanceToClear;
if (!int.TryParse(action.GetParameterValue("distance"), out DistanceToClear))
{
DistanceToClear = (int)Cache.Instance.MaxRange;
}
if (DistanceToClear != 0 && DistanceToClear != -2147483648 && DistanceToClear != 2147483647)
{
DistanceToClear = (int)Distances.OnGridWithMe;
}
//
// note this WILL clear sentries within the range given... it does NOT respect the KillSentries setting. 75% of the time this wont matter as sentries will be outside the range
//
// Target
//if (Settings.Instance.TargetSelectionMethod == "isdp")
//{
if (Cache.Instance.GetBestPrimaryWeaponTarget(DistanceToClear, false, "combat"))
_clearPocketTimeout = null;
//}
//else //use new target selection method
//{
// if (Cache.Instance.__GetBestWeaponTargets(DistanceToClear).Any())
// _clearPocketTimeout = null;
//}
// Do we have a timeout? No, set it to now + 5 seconds
if (!_clearPocketTimeout.HasValue)
{
_clearPocketTimeout = DateTime.UtcNow.AddSeconds(5);
}
// Are we in timeout?
if (DateTime.UtcNow < _clearPocketTimeout.Value)
{
return;
}
Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "is complete: no more targets in weapons range", Logging.Teal);
Nextaction();
// Reset timeout
_clearPocketTimeout = null;
return;
}
private void AggroOnlyAction(Actions.Action action)
{
if (Cache.Instance.NormalApproach)
Cache.Instance.NormalApproach = false;
bool ignoreAttackers;
if (!bool.TryParse(action.GetParameterValue("ignoreattackers"), out ignoreAttackers))
ignoreAttackers = false;
bool breakOnAttackers;
if (!bool.TryParse(action.GetParameterValue("breakonattackers"), out breakOnAttackers))
breakOnAttackers = false;
bool notTheClosest;
if (!bool.TryParse(action.GetParameterValue("notclosest"), out notTheClosest))
notTheClosest = false;
int numberToIgnore;
if (!int.TryParse(action.GetParameterValue("numbertoignore"), out numberToIgnore))
numberToIgnore = 0;
List<string> targetNames = action.GetParameterValues("target");
// No parameter? Ignore kill action
if (targetNames.Count == 0)
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "No targets defined!", Logging.Teal);
Nextaction();
return;
}
IEnumerable<EntityCache> targets = Cache.Instance.Entities.Where(e => targetNames.Contains(e.Name)).ToList();
if (targets.Count() == numberToIgnore)
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "All targets gone " + targetNames.Aggregate((current, next) => current + "[" + next + "]"), Logging.Teal);
// We killed it/them !?!?!? :)
Nextaction();
return;
}
if (Cache.Instance.Aggressed.Any(t => !t.IsSentry && targetNames.Contains(t.Name)))
{
// We are being attacked, break the kill order
if (Cache.Instance.RemovePriorityTargets(targets))
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Done with AggroOnly: We have aggro.", Logging.Teal);
foreach (EntityCache target in Cache.Instance.Targets.Where(e => targets.Any(t => t.Id == e.Id)))
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Unlocking [" + target.Name + "][ID: " + target.Id + "][" + Math.Round(target.Distance / 1000, 0) + "k away] due to aggro being obtained", Logging.Teal);
target.UnlockTarget();
return;
}
Nextaction();
return;
}
if (!ignoreAttackers || breakOnAttackers)
{
// Apparently we are busy, wait for combat to clear attackers first
IEnumerable<EntityCache> targetedBy = Cache.Instance.TargetedBy;
if (targetedBy != null && targetedBy.Count(t => !t.IsSentry && t.Distance < Cache.Instance.WeaponRange) > 0)
return;
}
EntityCache closest = targets.OrderBy(t => t.Distance).First();
if (notTheClosest)
closest = targets.OrderByDescending(t => t.Distance).First();
//panic handles adding any priority targets and combat will prefer to kill any priority targets
if (Cache.Instance.PriorityTargets.All(pt => pt.Id != closest.Id))
{
//Adds the target we want to kill to the priority list so that combat.cs will kill it (especially if it is an LCO this is important)
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Adding [" + closest.Name + "][ID: " + closest.Id + "] as a priority target", Logging.Teal);
Cache.Instance.AddPriorityTargets(new[] { closest }, Priority.PriorityKillTarget);
}
}
private void ClearWithinWeaponsRangeWithAggroOnlyAction(Actions.Action action)
{
if (Cache.Instance.NormalApproach)
{
Cache.Instance.NormalApproach = false;
}
// Get lowest range
int DistanceToClear;
if (!int.TryParse(action.GetParameterValue("distance"), out DistanceToClear))
{
DistanceToClear = (int)Cache.Instance.MaxRange;
}
if (DistanceToClear != 0 && DistanceToClear != -2147483648 && DistanceToClear != 2147483647)
{
DistanceToClear = (int)Distances.OnGridWithMe;
}
//
// the important bit is here... Adds target to the PrimaryWeapon or Drone Priority Target Lists so that they get killed (we basically wait for combat.cs to do that before proceeding)
//
//if (Settings.Instance.TargetSelectionMethod == "isdp")
//{
if (Cache.Instance.GetBestPrimaryWeaponTarget(DistanceToClear, false, "combat", Cache.Instance.combatTargets.Where(t => t.IsTargetedBy).ToList()))
_clearPocketTimeout = null;
//}
//else //use new target selection method
//{
// if (Cache.Instance.__GetBestWeaponTargets(DistanceToClear, Cache.Instance.combatTargets.Where(t => t.IsTargetedBy)).Any())
// _clearPocketTimeout = null;
//}
// Do we have a timeout? No, set it to now + 5 seconds
if (!_clearPocketTimeout.HasValue)
{
_clearPocketTimeout = DateTime.UtcNow.AddSeconds(5);
}
// Are we in timeout?
if (DateTime.UtcNow < _clearPocketTimeout.Value)
{
return;
}
Logging.Log("CombatMissionCtrl[" + Cache.Instance.PocketNumber + "]." + _pocketActions[_currentAction], "is complete: no more targets that are targeting us", Logging.Teal);
Nextaction();
// Reset timeout
_clearPocketTimeout = null;
return;
}
private void ClearWithinWeaponsRangewAggroOnlyAction(Actions.Action action)
{
// Get lowest range
double DistanceToConsiderTargets = Cache.Instance.MaxRange;
int DistanceToClear;
if (!int.TryParse(action.GetParameterValue("distance"), out DistanceToClear))
DistanceToClear = (int)DistanceToConsiderTargets;
if (DistanceToClear != 0 && DistanceToClear != -2147483648 && DistanceToClear != 2147483647)
{
DistanceToConsiderTargets = Math.Min(Cache.Instance.MaxRange, DistanceToClear);
}
EntityCache target = Cache.Instance.PriorityTargets.OrderBy(t => t.Distance).FirstOrDefault(t => t.Distance < DistanceToConsiderTargets && !(Cache.Instance.IgnoreTargets.Contains(t.Name.Trim()) && !Cache.Instance.TargetedBy.Any(w => w.IsWarpScramblingMe || w.IsNeutralizingMe || w.IsWebbingMe)));
// Or is there a target within DistanceToConsiderTargets that is targeting us?
target = target ?? Cache.Instance.TargetedBy.Where(t => t.Distance < DistanceToConsiderTargets && !t.IsEntityIShouldLeaveAlone && !t.IsContainer && t.IsNpc && t.CategoryId == (int)CategoryID.Entity && t.GroupId != (int)Group.LargeCollidableStructure && !Cache.Instance.IgnoreTargets.Contains(t.Name.Trim())).OrderBy(t => t.Distance).FirstOrDefault();
if (target != null)
{
// Reset timeout
_clearPocketTimeout = null;
// Lock priority target if within weapons range
if (target.Distance < Cache.Instance.MaxRange)
{
//panic handles adding any priority targets and combat will prefer to kill any priority targets
if (Cache.Instance.DirectEve.ActiveShip.MaxLockedTargets > 0)
{
if (target.IsTarget || target.IsTargeting) //This target is already targeted no need to target it again
{
//noop
}
else
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Targeting [" + target.Name + "][ID: " + target.Id + "][" + Math.Round(target.Distance / 1000, 0) + "k away]", Logging.Teal);
target.LockTarget();
}
}
return;
}
}
// Do we have a timeout? No, set it to now + 5 seconds
if (!_clearPocketTimeout.HasValue)
_clearPocketTimeout = DateTime.Now.AddSeconds(5);
// Are we in timeout?
if (DateTime.Now < _clearPocketTimeout.Value)
return;
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "is complete: no more targets that are targeting us", Logging.Teal);
Nextaction();
// Reset timeout
_clearPocketTimeout = null;
}
private void DropItemAction(Actions.Action action)
{
try
{
Cache.Instance.DropMode = true;
List<string> items = action.GetParameterValues("item");
string targetName = action.GetParameterValue("target");
int quantity;
if (!int.TryParse(action.GetParameterValue("quantity"), out quantity))
{
quantity = 1;
}
if (!CargoHoldHasBeenStacked)
{
Logging.Log("MissionController.DropItem", "Stack CargoHold", Logging.Orange);
if (!Cache.Instance.StackCargoHold("DropItem")) return;
CargoHoldHasBeenStacked = true;
return;
}
IEnumerable<EntityCache> targetEntities = Cache.Instance.EntitiesByName(targetName, Cache.Instance.EntitiesOnGrid.ToList());
if (targetEntities.Any())
{
Logging.Log("MissionController.DropItem", "We have [" + targetEntities.Count() + "] entities on grid that match our target by name: [" + targetName.FirstOrDefault() + "]", Logging.Orange);
targetEntities = targetEntities.Where(i => i.IsContainer || i.GroupId == (int)Group.LargeColidableObject); //some missions (like: Onslaught - lvl1) have LCOs that can hold and take cargo, note that same mission has a LCS with the same name!
if (!targetEntities.Any())
{
Logging.Log("MissionController.DropItem", "No entity on grid named: [" + targetEntities.FirstOrDefault() + "] that is also a container", Logging.Orange);
// now that we have completed this action revert OpenWrecks to false
Cache.Instance.DropMode = false;
Nextaction();
return;
}
EntityCache closest = targetEntities.OrderBy(t => t.Distance).FirstOrDefault();
if (closest == null)
{
Logging.Log("MissionController.DropItem", "closest: target named [" + targetName.FirstOrDefault() + "] was null" + targetEntities, Logging.Orange);
// now that we have completed this action revert OpenWrecks to false
Cache.Instance.DropMode = false;
Nextaction();
return;
}
if (closest.Distance > (int)Distances.SafeScoopRange)
{
if (Cache.Instance.Approaching == null || Cache.Instance.Approaching.Id != closest.Id)
{
if (DateTime.UtcNow > Cache.Instance.NextApproachAction)
{
Logging.Log("MissionController.DropItem", "Approaching target [" + closest.Name + "][" + Cache.Instance.MaskedID(closest.Id) + "] which is at [" + Math.Round(closest.Distance / 1000, 0) + "k away]", Logging.White);
closest.Approach(1000);
}
}
}
else if (Cache.Instance.MyShipEntity.Velocity < 50) //nearly stopped
{
if (DateTime.UtcNow > Cache.Instance.NextOpenContainerInSpaceAction)
{
Cache.Instance.NextOpenContainerInSpaceAction = DateTime.UtcNow.AddSeconds(Cache.Instance.RandomNumber(6, 10));
DirectContainer container = null;
container = Cache.Instance.DirectEve.GetContainer(closest.Id);
if (container == null)
{
Logging.Log("MissionController.DropItem", "if (container == null)", Logging.White);
return;
}
if (ItemsHaveBeenMoved)
{
Logging.Log("MissionController.DropItem", "We have Dropped the items: ItemsHaveBeenMoved [" + ItemsHaveBeenMoved + "]", Logging.White);
// now that we have completed this action revert OpenWrecks to false
Cache.Instance.DropMode = false;
Nextaction();
return;
}
if (Cache.Instance.CurrentShipsCargo.Items.Any())
{
int CurrentShipsCargoItemCount = 0;
CurrentShipsCargoItemCount = Cache.Instance.CurrentShipsCargo.Items.Count();
//DirectItem itemsToMove = null;
//itemsToMove = Cache.Instance.CurrentShipsCargo.Items.FirstOrDefault(i => i.TypeName.ToLower() == items.FirstOrDefault().ToLower());
//if (itemsToMove == null)
//{
// Logging.Log("MissionController.DropItem", "CurrentShipsCargo has [" + CurrentShipsCargoItemCount + "] items. Item We are supposed to move is: [" + items.FirstOrDefault() + "]", Logging.White);
// return;
//}
int ItemNumber = 0;
foreach (DirectItem CurrentShipsCargoItem in Cache.Instance.CurrentShipsCargo.Items)
{
ItemNumber++;
Logging.Log("MissionController.DropItem", "[" + ItemNumber + "] Found [" + CurrentShipsCargoItem.Quantity + "][" + CurrentShipsCargoItem.TypeName + "] in Current Ships Cargo: StackSize: [" + CurrentShipsCargoItem.Stacksize + "] We are looking for: [" + items.FirstOrDefault() + "]", Logging.Debug);
if (CurrentShipsCargoItem.TypeName.ToLower() == items.FirstOrDefault().ToLower())
{
Logging.Log("MissionController.DropItem", "[" + ItemNumber + "] container.Capacity [" + container.Capacity + "] ItemsHaveBeenMoved [" + ItemsHaveBeenMoved + "]", Logging.Debug);
if (!ItemsHaveBeenMoved)
{
Logging.Log("MissionController.DropItem", "Moving Items: " + items.FirstOrDefault() + " from cargo ship to " + container.TypeName, Logging.White);
//
// THIS IS NOT WORKING - EXCEPTION/ERROR IN CLIENT...
//
//container.Add(CurrentShipsCargoItem, quantity);
Cache.Instance.NextOpenContainerInSpaceAction = DateTime.UtcNow.AddSeconds(Cache.Instance.RandomNumber(4, 6));
ItemsHaveBeenMoved = true;
return;
}
return;
}
}
}
else
{
Logging.Log("MissionController.DropItem", "No Items: Cache.Instance.CurrentShipsCargo.Items.Any()", Logging.Debug);
}
}
}
return;
}
Logging.Log("MissionController.DropItem", "No entity on grid named: [" + targetEntities.FirstOrDefault() + "]", Logging.Orange);
// now that we have completed this action revert OpenWrecks to false
Cache.Instance.DropMode = false;
Nextaction();
return;
}
catch (Exception exception)
{
Logging.Log("DropItemAction", "Exception: [" + exception + "]", Logging.Debug);
}
return;
}
private void DropItemAction(Actions.Action action)
{
Cache.Instance.DropMode = true;
var items = action.GetParameterValues("item");
var target = action.GetParameterValue("target");
int quantity;
if (!int.TryParse(action.GetParameterValue("quantity"), out quantity))
quantity = 1;
var done = items.Count == 0;
IEnumerable<EntityCache> targets = Cache.Instance.EntitiesByName(target).ToList();
if (!targets.Any())
{
Logging.Log("MissionController.DropItem", "No target name: " + targets, Logging.Orange);
// now that we have completed this action revert OpenWrecks to false
Cache.Instance.DropMode = false;
Nextaction();
return;
}
var closest = targets.OrderBy(t => t.Distance).First();
if (closest.Distance > (int)Distance.SafeScoopRange)
{
if (Cache.Instance.Approaching == null || Cache.Instance.Approaching.Id != closest.Id)
{
if (DateTime.Now > Cache.Instance.NextApproachAction)
{
Logging.Log("MissionController.DropItem", "Approaching target [" + closest.Name + "][ID: " + closest.Id + "] which is at [" + Math.Round(closest.Distance / 1000, 0) + "k away]", Logging.White);
closest.Approach(1000);
}
}
}
else
{
if (!done)
{
if (DateTime.Now > Cache.Instance.NextOpenContainerInSpaceAction)
{
var cargo = Cache.Instance.DirectEve.GetShipsCargo();
if (closest.CargoWindow == null)
{
Logging.Log("MissionController.DropItem", "Open Cargo", Logging.White);
closest.OpenCargo();
Cache.Instance.NextOpenContainerInSpaceAction = DateTime.Now.AddSeconds(Cache.Instance.RandomNumber(4, 6));
return;
}
// Get the container that is associated with the cargo container
var container = Cache.Instance.DirectEve.GetContainer(closest.Id);
var itemsToMove = cargo.Items.FirstOrDefault(i => i.TypeName.ToLower() == items.FirstOrDefault().ToLower());
if (itemsToMove != null)
{
Logging.Log("MissionController.DropItem", "Moving Items: " + items.FirstOrDefault() + " from cargo ship to " + container.TypeName, Logging.White);
container.Add(itemsToMove, quantity);
done = container.Items.Any(i => i.TypeName.ToLower() == items.FirstOrDefault().ToLower() && (i.Quantity >= quantity));
Cache.Instance.NextOpenContainerInSpaceAction = DateTime.Now.AddSeconds(Cache.Instance.RandomNumber(4, 6));
}
else
{
Logging.Log("MissionController.DropItem", "Error not found Items", Logging.White);
Cache.Instance.DropMode = false;
Nextaction();
return;
}
}
}
else
{
Logging.Log("MissionController.DropItem", "We are done", Logging.White);
// now that we've completed this action revert OpenWrecks to false
Cache.Instance.DropMode = false;
Nextaction();
return;
}
}
}
private void KillClosestByNameAction(Actions.Action action)
{
bool notTheClosest;
if (!bool.TryParse(action.GetParameterValue("notclosest"), out notTheClosest))
notTheClosest = false;
if (Cache.Instance.NormalApproach)
Cache.Instance.NormalApproach = false;
List<string> targetNames = action.GetParameterValues("target");
// No parameter? Ignore kill action
if (targetNames.Count == 0)
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "No targets defined!", Logging.Teal);
Nextaction();
return;
}
//IEnumerable<EntityCache> targets = Cache.Instance.Entities.Where(e => targetNames.Contains(e.Name));
EntityCache target = Cache.Instance.Entities.Where(e => targetNames.Contains(e.Name)).OrderBy(t => t.Distance).First();
if (notTheClosest)
target = Cache.Instance.Entities.Where(e => targetNames.Contains(e.Name)).OrderByDescending(t => t.Distance).First();
if (target != null)
{
if (target.Distance < Cache.Instance.MaxRange)
{
if (Cache.Instance.PriorityTargets.All(pt => pt.Id != target.Id))
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Adding [" + target.Name + "][ID: " + target.Id + "] as a priority target", Logging.Teal);
Cache.Instance.AddPriorityTargets(new[] { target }, Priority.PriorityKillTarget);
}
if (Cache.Instance.DirectEve.ActiveShip.MaxLockedTargets > 0)
{
if (!(target.IsTarget || target.IsTargeting))
//This target is not targeted and need to target it
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Targeting [" + target.Name + "][ID: " + target.Id + "][" + Math.Round(target.Distance / 1000, 0) + "k away]", Logging.Teal);
target.LockTarget();
// the target has been added to the priority targets list and has been targeted.
// this should ensure that the combat module (and/or the next action) kills the target.
Nextaction();
return;
}
}
}
NavigateOnGrid.NavigateIntoRange(target, "CombatMissionCtrl." + _pocketActions[_currentAction]);
}
else
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "All targets killed, not valid anymore ", Logging.Teal);
// We killed it/them !?!?!? :)
Nextaction();
return;
}
}
private void KillAction(Actions.Action action)
{
if (Cache.Instance.NormalApproach)
Cache.Instance.NormalApproach = false;
bool ignoreAttackers;
if (!bool.TryParse(action.GetParameterValue("ignoreattackers"), out ignoreAttackers))
ignoreAttackers = false;
bool breakOnAttackers;
if (!bool.TryParse(action.GetParameterValue("breakonattackers"), out breakOnAttackers))
breakOnAttackers = false;
bool notTheClosest;
if (!bool.TryParse(action.GetParameterValue("notclosest"), out notTheClosest))
notTheClosest = false;
int numberToIgnore;
if (!int.TryParse(action.GetParameterValue("numbertoignore"), out numberToIgnore))
numberToIgnore = 0;
List<string> targetNames = action.GetParameterValues("target");
// No parameter? Ignore kill action
if (targetNames.Count == 0)
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "No targets defined in kill action!", Logging.Teal);
Nextaction();
return;
}
IEnumerable<EntityCache> targets = Cache.Instance.Entities.Where(e => targetNames.Contains(e.Name)).ToList();
if (targets.Count() == numberToIgnore)
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "All targets killed " + targetNames.Aggregate((current, next) => current + "[" + next + "]"), Logging.Teal);
// We killed it/them !?!?!? :)
Nextaction();
return;
}
if (breakOnAttackers && Cache.Instance.TargetedBy.Any(t => !t.IsSentry && t.Distance < Cache.Instance.WeaponRange))
{
// We are being attacked, break the kill order
if (Cache.Instance.RemovePriorityTargets(targets))
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Breaking off kill order, new spawn has arrived!", Logging.Teal);
foreach (EntityCache entity in Cache.Instance.Targets.Where(e => targets.Any(t => t.Id == e.Id)))
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Unlocking [" + entity.Name + "][ID: " + entity.Id + "][" + Math.Round(entity.Distance / 1000, 0) + "k away] due to kill order being put on hold", Logging.Teal);
entity.UnlockTarget();
}
}
if (!ignoreAttackers || breakOnAttackers)
{
// Apparently we are busy, wait for combat to clear attackers first
IEnumerable<EntityCache> targetedBy = Cache.Instance.TargetedBy;
if (targetedBy != null && targetedBy.Count(t => !t.IsSentry && t.Distance < Cache.Instance.WeaponRange) > 0)
return;
}
EntityCache target = targets.OrderBy(t => t.Distance).First();
int targetedby = Cache.Instance.TargetedBy.Count(t => !t.IsSentry && !t.IsEntityIShouldLeaveAlone && !t.IsContainer && t.IsNpc && t.CategoryId == (int)CategoryID.Entity && t.GroupId != (int)Group.LargeCollidableStructure && !Cache.Instance.IgnoreTargets.Contains(t.Name.Trim()));
if (target != null)
{
// Reset timeout
_clearPocketTimeout = null;
// Are we approaching the active (out of range) target?
// Wait for it (or others) to get into range
// Lock priority target if within weapons range
if (notTheClosest)
target = targets.OrderByDescending(t => t.Distance).First();
if (target.Distance < Cache.Instance.MaxRange)
{
//panic handles adding any priority targets and combat will prefer to kill any priority targets
if (Cache.Instance.PriorityTargets.All(pt => pt.Id != target.Id))
{
//Adds the target we want to kill to the priority list so that combat.cs will kill it (especially if it is an LCO this is important)
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Adding [" + target.Name + "][ID: " + target.Id + "] as a priority target", Logging.Teal);
Cache.Instance.AddPriorityTargets(new[] { target }, Priority.PriorityKillTarget);
}
if (_targetNull && targetedby == 0 && DateTime.Now > Cache.Instance.NextReload)
{
//Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction] ,"Reload if [" + _targetNull + "] && [" + targetedby + "] == 0 AND [" + Math.Round(target.Distance, 0) + "] < [" + Cache.Instance.MaxRange + "]", Logging.teal);
if (!Combat.ReloadAll(target)) return;
}
if (Cache.Instance.DirectEve.ActiveShip.MaxLockedTargets > 0)
{
if (!(target.IsTarget || target.IsTargeting)) //This target is not targeted and need to target it
{
Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction], "Targeting [" + target.Name + "][ID: " + target.Id + "][" + Math.Round(target.Distance / 1000, 0) + "k away]", Logging.Teal);
target.LockTarget();
}
}
}
NavigateOnGrid.NavigateIntoRange(target, "CombatMissionCtrl." + _pocketActions[_currentAction]);
if (target.Distance > Cache.Instance.MaxRange)
{
if (DateTime.Now > Cache.Instance.NextReload)
{
//Logging.Log("CombatMissionCtrl." + _pocketActions[_currentAction] ,"ReloadAll: Reload weapons", Logging.teal);
if (!Combat.ReloadAll(target)) return;
}
}
return;
}
}
private void KillClosestAction(Actions.Action action)
{
if (Cache.Instance.NormalApproach) Cache.Instance.NormalApproach = false;
bool notTheClosest;
if (!bool.TryParse(action.GetParameterValue("notclosest"), out notTheClosest))
{
notTheClosest = false;
}
//
// the way this is currently written is will NOT stop after killing the first target as intended, it will clear all targets with the Name given, in this everything on grid
//
//if (Settings.Instance.TargetSelectionMethod == "isdp")
//{
if (Cache.Instance.GetBestPrimaryWeaponTarget((double)Distances.OnGridWithMe, false, "combat", Cache.Instance.PotentialCombatTargets.OrderBy(t => t.Distance).Take(1).ToList()))
_clearPocketTimeout = null;
//}
//else //use new target selection method
//{
// if (Cache.Instance.__GetBestWeaponTargets((double)Distances.OnGridWithMe, Cache.Instance.PotentialCombatTargets.Where(e => !e.IsSentry || (e.IsSentry && Settings.Instance.KillSentries)).OrderBy(t => t.Distance).Take(1).ToList()).Any())
// _clearPocketTimeout = null;
//}
// Do we have a timeout? No, set it to now + 5 seconds
if (!_clearPocketTimeout.HasValue) _clearPocketTimeout = DateTime.UtcNow.AddSeconds(5);
// Are we in timeout?
if (DateTime.UtcNow < _clearPocketTimeout.Value) return;
// We have cleared the Pocket, perform the next action \o/ - reset the timers that we had set for actions...
Nextaction();
// Reset timeout
_clearPocketTimeout = null;
return;
}