// bool cleared = false;
public UndockSeperationTask(IAutopilot autopilotSubsystem, IDockingSubsystem dockingSubsystem, MyGridProgram program)
{
AutopilotSubsystem = autopilotSubsystem;
DockingSubsystem = dockingSubsystem;
WaitTask = new WaitTask();
Program = program;
}
public LocustAttackTaskGenerator(MyGridProgram program, LocustCombatSystem combatSystem, IAutopilot autopilot, IAgentSubsystem agentSubsystem)
{
Program = program;
CombatSystem = combatSystem;
Autopilot = autopilot;
AgentSubsystem = agentSubsystem;
}
public UndockFirstTaskGenerator(MyGridProgram program, IAutopilot autopilot, IDockingSubsystem dockingSubsystem)
{
Autopilot = autopilot;
DockingSubsystem = dockingSubsystem;
CompoundTask.Do(new Dictionary <MyTuple <IntelItemType, long>, IFleetIntelligence>(), TimeSpan.Zero, null);
CompoundTask.Reset();
UndockSeperationTask = new UndockSeperationTask(Autopilot, DockingSubsystem, program);
UndockSeperationTask.Do(new Dictionary <MyTuple <IntelItemType, long>, IFleetIntelligence>(), TimeSpan.Zero, null);
DockingSubsystem.Undock(true);
}
public AutoPDCTaskGenerator(MyGridProgram program, IAutopilot autopilot, IIntelProvider intelProvider)
{
Program = program;
Autopilot = autopilot;
IntelProvider = intelProvider;
program.GridTerminalSystem.GetBlocksOfType(Rotors, (IMyMotorAdvancedStator r) => { return(r.CustomName.Contains("Elevation") && r.CubeGrid == program.Me.CubeGrid); });
MyTask = new AutoPDCTask(Program, Autopilot, IntelProvider);
MyTask.Do(new Dictionary <MyTuple <IntelItemType, long>, IFleetIntelligence>(), TimeSpan.Zero, null);
}
public HornetAttackTaskGenerator(MyGridProgram program, HornetCombatSubsystem combatSystem, IAutopilot autopilot, IAgentSubsystem agentSubsystem, IMonitorSubsystem monitorSubsystem, IIntelProvider intelProvider)
{
Program = program;
CombatSystem = combatSystem;
Autopilot = autopilot;
AgentSubsystem = agentSubsystem;
MonitorSubsystem = monitorSubsystem;
IntelProvider = intelProvider;
HornetAttackTask = new HornetAttackTask(Program, CombatSystem, Autopilot, AgentSubsystem, MonitorSubsystem, IntelProvider);
HornetAttackTask.Do(new Dictionary <MyTuple <IntelItemType, long>, IFleetIntelligence>(), TimeSpan.Zero, null);
}
public LocustAttackTask(MyGridProgram program, LocustCombatSystem combatSystem, IAutopilot autopilot, IAgentSubsystem agentSubsystem, MyTuple <IntelItemType, long> intelKey)
{
Program = program;
CombatSystem = combatSystem;
Autopilot = autopilot;
AgentSubsystem = agentSubsystem;
IntelKey = intelKey;
Status = TaskStatus.Incomplete;
LeadTask = new WaypointTask(Program, Autopilot, new Waypoint(), WaypointTask.AvoidObstacleMode.Avoid);
}
public WaypointTask(MyGridProgram program, IAutopilot pilotSubsystem, Waypoint waypoint, AvoidObstacleMode avoidObstacleMode = AvoidObstacleMode.SmartEnter, IMyTerminalBlock moveReference = null)
{
Autopilot = pilotSubsystem;
Program = program;
Destination = waypoint;
IntelScratchpad = new List <IFleetIntelligence>(64);
PositionScratchpad = new List <Vector3>(64);
ObstacleMode = avoidObstacleMode;
MoveReference = moveReference;
Cleared = false;
WaypointHelper.PlotPath(new Dictionary <MyTuple <IntelItemType, long>, IFleetIntelligence>(), TimeSpan.FromSeconds(1), Autopilot, Destination, IntelScratchpad, PositionScratchpad, Program, ObstacleMode);
}
// int targetLastPoweredRun = 0;
public HornetAttackTask(MyGridProgram program, HornetCombatSubsystem combatSystem, IAutopilot autopilot, IAgentSubsystem agentSubsystem, IMonitorSubsystem monitorSubsystem, IIntelProvider intelProvider)
{
Program = program;
CombatSystem = combatSystem;
Autopilot = autopilot;
AgentSubsystem = agentSubsystem;
MonitorSubsystem = monitorSubsystem;
IntelProvider = intelProvider;
Status = TaskStatus.Incomplete;
LeadTask = new WaypointTask(Program, Autopilot, new Waypoint(), WaypointTask.AvoidObstacleMode.Avoid);
}
public HoneybeeMiningTask(MyGridProgram program, HoneybeeMiningSystem miningSystem, IAutopilot autopilot, IAgentSubsystem agentSubsystem, Waypoint target, AsteroidIntel host, IIntelProvider intelProvider, IMonitorSubsystem monitorSubsystem, IDockingSubsystem dockingSubsystem, DockTaskGenerator dockTaskGenerator, UndockFirstTaskGenerator undockTaskGenerator)
{
Program = program;
MiningSystem = miningSystem;
Autopilot = autopilot;
AgentSubsystem = agentSubsystem;
MonitorSubsystem = monitorSubsystem;
Host = host;
MiningDepth = MiningSystem.MineDepth;
LowestExpectedOreDist = (float)MiningDepth;
DockingSubsystem = dockingSubsystem;
Status = TaskStatus.Incomplete;
double lDoc, det;
GetSphereLineIntersects(host.Position, host.Radius, target.Position, target.Direction, out lDoc, out det);
Perpendicular = GetPerpendicular(target.Direction);
CoPerp = Perpendicular.Cross(target.Direction);
if (det < 0)
{
Status = TaskStatus.Aborted;
state = -1;
return;
}
SurfaceDist = -lDoc + Math.Sqrt(det);
ApproachPoint = target.Position + target.Direction * SurfaceDist * 0.3;
ExitPoint = ApproachPoint;
EntryPoint = target.Position + target.Direction * miningSystem.CloseDist;
MiningEnd = target.Position - target.Direction * MiningDepth;
SurfacePoint = target.Position;
LeadTask = new WaypointTask(Program, Autopilot, new Waypoint(), WaypointTask.AvoidObstacleMode.SmartEnter);
MineTask = new WaypointTask(Program, Autopilot, new Waypoint(), WaypointTask.AvoidObstacleMode.DoNotAvoid);
LeadTask.Destination.Position = ApproachPoint;
LeadTask.Destination.Direction = target.Direction * -1;
LeadTask.Destination.DirectionUp = Perpendicular + CoPerp;
intelProvider.ReportFleetIntelligence(LeadTask.Destination, TimeSpan.FromSeconds(1));
MineTask.Destination.Direction = target.Direction * -1;
MineTask.Destination.DirectionUp = Perpendicular + CoPerp;
MineTask.Destination.Position = EntryPoint;
DockTaskGenerator = dockTaskGenerator;
UndockTaskGenerator = undockTaskGenerator;
}
public HoneybeeMiningTaskGenerator(MyGridProgram program, HoneybeeMiningSystem miningSystem, IAutopilot autopilot, IAgentSubsystem agentSubsystem, IDockingSubsystem dockingSubsystem, DockTaskGenerator dockTaskGenerator, UndockFirstTaskGenerator undockTaskGenerator, IIntelProvider intelProvder, IMonitorSubsystem monitorSubsystem)
{
Program = program;
MiningSystem = miningSystem;
Autopilot = autopilot;
AgentSubsystem = agentSubsystem;
DockTaskGenerator = dockTaskGenerator;
UndockTaskGenerator = undockTaskGenerator;
IntelProvider = intelProvder;
MonitorSubsystem = monitorSubsystem;
DockingSubsystem = dockingSubsystem;
Task = new HoneybeeMiningTask(Program, MiningSystem, Autopilot, AgentSubsystem, new Waypoint(), new AsteroidIntel(), IntelProvider, MonitorSubsystem, DockingSubsystem, DockTaskGenerator, UndockTaskGenerator);
Task.Do(new Dictionary <MyTuple <IntelItemType, long>, IFleetIntelligence>(), TimeSpan.Zero, null);
}
public DockTaskGenerator(MyGridProgram program, IAutopilot autopilot, IDockingSubsystem ds)
{
Program = program;
Autopilot = autopilot;
DockingSubsystem = ds;
holdTask = new WaypointTask(Program, Autopilot, new Waypoint(), WaypointTask.AvoidObstacleMode.Avoid, DockingSubsystem.Connector);
approachTask = new WaypointTask(Program, Autopilot, new Waypoint(), WaypointTask.AvoidObstacleMode.SmartEnter, DockingSubsystem.Connector);
enterTask = new WaypointTask(Program, Autopilot, new Waypoint(), WaypointTask.AvoidObstacleMode.DoNotAvoid, DockingSubsystem.Connector);
closeTask = new WaypointTask(Program, Autopilot, new Waypoint(), WaypointTask.AvoidObstacleMode.DoNotAvoid, DockingSubsystem.Connector);
dockTask = new DockTask(DockingSubsystem);
Task = new MoveToAndDockTask();
Task.Reset(holdTask, approachTask, enterTask, closeTask, dockTask, MyTuple.Create(IntelItemType.NONE, (long)1234), Program, MyCubeSize.Small, DockingSubsystem.Connector, DockingSubsystem.DirectionIndicator);
Task.Do(new Dictionary <MyTuple <IntelItemType, long>, IFleetIntelligence>(), TimeSpan.FromSeconds(1), null);
dockTask.Do(new Dictionary <MyTuple <IntelItemType, long>, IFleetIntelligence>(), TimeSpan.Zero, null);
holdTask.Do(new Dictionary <MyTuple <IntelItemType, long>, IFleetIntelligence>(), TimeSpan.Zero, null);
new WaitTask().Do(new Dictionary <MyTuple <IntelItemType, long>, IFleetIntelligence>(), TimeSpan.Zero, null);
}
public WaypointTaskGenerator(MyGridProgram program, IAutopilot autopilot)
{
Program = program;
Autopilot = autopilot;
}
public static Vector3D PlotPath(Dictionary <MyTuple <IntelItemType, long>, IFleetIntelligence> IntelItems, TimeSpan canonicalTime, IAutopilot Autopilot, Waypoint Destination, List <IFleetIntelligence> IntelScratchpad, List <Vector3> PositionScratchpad, MyGridProgram Program, WaypointTask.AvoidObstacleMode ObstacleMode)
{
if (Autopilot.Reference == null)
{
return(Vector3D.Zero);
}
Vector3D o = Autopilot.Reference.WorldMatrix.Translation;
Vector3D targetPosition = Destination.Position;
float SafetyRadius = (float)(Autopilot.Controller.CubeGrid.WorldAABB.Max - Autopilot.Controller.CubeGrid.WorldAABB.Min).Length();
float brakingDist = Autopilot.GetBrakingDistance();
IntelScratchpad.Clear();
PositionScratchpad.Clear();
bool type1 = false;
// Quick filter on intel items that might interfere with pathing at this time based on type and distance
foreach (var kvp in IntelItems)
{
// If it's us, don't care
if (kvp.Key.Item2 == Program.Me.CubeGrid.EntityId)
{
continue;
}
if (kvp.Value.Radius == 0)
{
continue;
}
// If it's an asteroid or a ship, we might be interested
if (kvp.Value.Type == IntelItemType.Asteroid || kvp.Value.Type == IntelItemType.Friendly || kvp.Value.Type == IntelItemType.Enemy)
{
Vector3D c = kvp.Value.GetPositionFromCanonicalTime(canonicalTime);
float r = kvp.Value.Radius + SafetyRadius;
double distTo = (c - o).Length();
// Check if distance is close enough. If so, shortlist this.
if (distTo < r + brakingDist + Autopilot.Controller.GetShipSpeed() * 0.16 + 100)
{
IntelScratchpad.Add(kvp.Value);
PositionScratchpad.Add(c);
// If distance is closer than, we are inside its bounding sphere and must escape unless our destination is also in the radius
if (distTo < r && (Destination.Position - c).Length() > r)
{
type1 = true;
break;
}
}
}
}
Vector3D target = Destination.Position;
if (type1)
{
// Escape maneuver - move directly away from center of bounding sphere
var dir = o - PositionScratchpad.Last();
dir.Normalize();
target = dir * (IntelScratchpad.Last().Radius + SafetyRadius * 2) + PositionScratchpad.Last();
}
else if (IntelScratchpad.Count > 0)
{
bool targetClear;
int iter = 0;
// Find a clear path around any obstacles:
do
{
iter += 1;
targetClear = true;
IFleetIntelligence closestObstacle = null;
float closestDist = float.MaxValue;
float closestApporoach = 0;
bool closestType3 = false;
var l = target - o;
double d = l.Length();
l.Normalize();
// Go through each intel item we shortlisted earlier
for (int i = 0; i < IntelScratchpad.Count; i++)
{
float lDoc = Vector3.Dot(l, o - PositionScratchpad[i]);
double det = lDoc * lDoc - ((o - PositionScratchpad[i]).LengthSquared() - (IntelScratchpad[i].Radius + SafetyRadius) * (IntelScratchpad[i].Radius + SafetyRadius));
// Check if we intersect the sphere at all
if (det > 0)
{
// Check if this is a type 2 obstacle - that is, we enter its bounding sphere and the closest approach is some point along our path.
if (-lDoc > 0 && -lDoc < d)
{
closestObstacle = IntelScratchpad[i];
var distIntersect = -lDoc - (float)Math.Sqrt(det);
// Only care about the closest one. Hopefully this works well enough in practice.
if (closestDist > distIntersect)
{
closestDist = distIntersect;
closestApporoach = -lDoc;
closestObstacle = IntelScratchpad[i];
closestType3 = false;
}
}
// Check if this is a type 3 obstacle - that is, we enter its bonding sphere and the destination is inside
else if ((target - PositionScratchpad[i]).Length() < IntelScratchpad[i].Radius + SafetyRadius)
{
var distIntersect = -lDoc - (float)Math.Sqrt(det);
if (closestDist > distIntersect)
{
closestDist = distIntersect;
closestApporoach = -lDoc;
closestObstacle = IntelScratchpad[i];
closestType3 = true;
}
}
}
}
// If there is a potential collision
if (closestDist != float.MaxValue)
{
targetClear = false;
Vector3D closestObstaclePos = closestObstacle.GetPositionFromCanonicalTime(canonicalTime);
Vector3D v;
if (!closestType3)
{
var c = l * closestApporoach + o;
Vector3D dir = c - closestObstaclePos;
dir.Normalize();
v = dir * (closestObstacle.Radius + SafetyRadius * 2) + closestObstaclePos;
var vdir = v - o;
vdir.Normalize();
target = o + vdir * (o - Destination.Position).Length();
}
else
{
Vector3D dirCenterToDest = target - closestObstaclePos;
dirCenterToDest.Normalize();
Vector3D dirCenterToMe = o - closestObstaclePos;
var distToMe = dirCenterToMe.Length();
dirCenterToMe.Normalize();
var angle = Math.Acos(Vector3.Dot(dirCenterToDest, dirCenterToMe));
if (angle < 0.2 && ObstacleMode == WaypointTask.AvoidObstacleMode.SmartEnter)
{
target = Destination.Position;
break;
}
else if (angle > 0.6 && distToMe < (closestObstacle.Radius + SafetyRadius))
{
target = dirCenterToMe * (closestObstacle.Radius + SafetyRadius * 2) + closestObstaclePos;
break;
}
else
{
target = dirCenterToDest * (closestObstacle.Radius + SafetyRadius * 2) + closestObstaclePos;
}
}
}
} while (!targetClear && iter < 5);
}
return(target);
}
public MACCombatAutopilotSubsystem(IAutopilot drive, IIntelProvider intelProvider)
{
Drive = drive;
IntelProvider = intelProvider;
}
public AutoPDCTask(MyGridProgram program, IAutopilot autopilot, IIntelProvider intelProvider)
{
Program = program;
Autopilot = autopilot;
IntelProvider = intelProvider;
}
