void Calculate(Actor self)
{
if (dest == null || dest.IsDead || Reservable.IsReserved(dest))
{
dest = ChooseResupplier(self, true);
}
if (dest == null)
{
return;
}
var landPos = dest.CenterPosition;
var altitude = aircraft.Info.CruiseAltitude.Length;
// Distance required for descent.
var landDistance = altitude * 1024 / aircraft.Info.MaximumPitch.Tan();
// Land towards the east
var approachStart = landPos + new WVec(-landDistance, 0, altitude);
// Add 10% to the turning radius to ensure we have enough room
var speed = aircraft.MovementSpeed * 32 / 35;
var turnRadius = CalculateTurnRadius(speed);
// Find the center of the turning circles for clockwise and counterclockwise turns
var angle = WAngle.FromFacing(aircraft.Facing);
var fwd = -new WVec(angle.Sin(), angle.Cos(), 0);
// Work out whether we should turn clockwise or counter-clockwise for approach
var side = new WVec(-fwd.Y, fwd.X, fwd.Z);
var approachDelta = self.CenterPosition - approachStart;
var sideTowardBase = new[] { side, -side }
.MinBy(a => WVec.Dot(a, approachDelta));
// Calculate the tangent line that joins the turning circles at the current and approach positions
var cp = self.CenterPosition + turnRadius * sideTowardBase / 1024;
var posCenter = new WPos(cp.X, cp.Y, altitude);
var approachCenter = approachStart + new WVec(0, turnRadius * Math.Sign(self.CenterPosition.Y - approachStart.Y), 0);
var tangentDirection = approachCenter - posCenter;
var tangentLength = tangentDirection.Length;
var tangentOffset = WVec.Zero;
if (tangentLength != 0)
{
tangentOffset = new WVec(-tangentDirection.Y, tangentDirection.X, 0) * turnRadius / tangentLength;
}
// TODO: correctly handle CCW <-> CW turns
if (tangentOffset.X > 0)
{
tangentOffset = -tangentOffset;
}
w1 = posCenter + tangentOffset;
w2 = approachCenter + tangentOffset;
w3 = approachStart;
isCalculated = true;
}
public void ResolveOrder(Actor self, Order order)
{
if (order.OrderString == "Move")
{
var cell = self.World.Map.Clamp(order.TargetLocation);
var explored = self.Owner.Shroud.IsExplored(cell);
if (!explored && !Info.MoveIntoShroud)
{
return;
}
UnReserve();
var target = Target.FromCell(self.World, cell);
self.SetTargetLine(target, Color.Green);
self.CancelActivity();
self.QueueActivity(new Fly(self, target));
self.QueueActivity(new FlyCircle());
}
else if (order.OrderString == "Enter")
{
if (Reservable.IsReserved(order.TargetActor))
{
return;
}
UnReserve();
self.SetTargetLine(Target.FromOrder(self.World, order), Color.Green);
self.CancelActivity();
self.QueueActivity(new ReturnToBase(self, order.TargetActor));
self.QueueActivity(new ResupplyAircraft());
}
else if (order.OrderString == "Stop")
{
UnReserve();
self.CancelActivity();
}
else if (order.OrderString == "ReturnToBase")
{
var airfield = ReturnToBase.ChooseAirfield(self, true);
if (airfield == null)
{
return;
}
UnReserve();
self.CancelActivity();
self.SetTargetLine(Target.FromActor(airfield), Color.Green);
self.QueueActivity(new ReturnToBase(self, airfield));
self.QueueActivity(new ResupplyAircraft());
}
else
{
// Game.Debug("Unreserve due to unhandled order: {0}".F(order.OrderString));
UnReserve();
}
}
public override Activity Tick(Actor self)
{
if (IsCanceled)
{
return(NextActivity);
}
if (dest == null || dest.IsDead || Reservable.IsReserved(dest))
{
dest = ChooseHelipad(self, true);
}
var initialFacing = heli.Info.InitialFacing;
if (dest == null || dest.IsDead)
{
var nearestHpad = ChooseHelipad(self, false);
if (nearestHpad == null)
{
return(ActivityUtils.SequenceActivities(new Turn(self, initialFacing), new HeliLand(self, true), NextActivity));
}
else
{
var distanceFromHelipad = (nearestHpad.CenterPosition - self.CenterPosition).HorizontalLength;
var distanceLength = heli.Info.WaitDistanceFromResupplyBase.Length;
// If no pad is available, move near one and wait
if (distanceFromHelipad > distanceLength)
{
var randomPosition = WVec.FromPDF(self.World.SharedRandom, 2) * distanceLength / 1024;
var target = Target.FromPos(nearestHpad.CenterPosition + randomPosition);
return(ActivityUtils.SequenceActivities(new HeliFly(self, target, WDist.Zero, heli.Info.WaitDistanceFromResupplyBase), this));
}
return(this);
}
}
var exit = dest.Info.TraitInfos <ExitInfo>().FirstOrDefault();
var offset = (exit != null) ? exit.SpawnOffset : WVec.Zero;
if (ShouldLandAtBuilding(self, dest))
{
heli.MakeReservation(dest);
return(ActivityUtils.SequenceActivities(
new HeliFly(self, Target.FromPos(dest.CenterPosition + offset)),
new Turn(self, initialFacing),
new HeliLand(self, false),
new ResupplyAircraft(self),
!abortOnResupply ? NextActivity : null));
}
return(ActivityUtils.SequenceActivities(
new HeliFly(self, Target.FromPos(dest.CenterPosition + offset)),
NextActivity));
}
public Actor ChooseHelipad(Actor self)
{
var rearmBuildings = heli.Info.RearmBuildings;
return(self.World.Actors.Where(a => a.Owner == self.Owner).FirstOrDefault(
a => rearmBuildings.Contains(a.Info.Name) && !Reservable.IsReserved(a)));
}
static Actor ChooseHelipad(Actor self)
{
var rearmBuildings = self.Info.Traits.Get <HelicopterInfo>().RearmBuildings;
return(self.World.Actors.Where(a => a.Owner == self.Owner).FirstOrDefault(
a => rearmBuildings.Contains(a.Info.Name) && !Reservable.IsReserved(a)));
}
void Calculate(Actor self)
{
if (dest == null || Reservable.IsReserved(dest))
{
dest = ChooseAirfield(self);
}
if (dest == null)
{
return;
}
var plane = self.Trait <Plane>();
var res = dest.TraitOrDefault <Reservable>();
if (res != null)
{
plane.UnReserve();
plane.reservation = res.Reserve(dest, self, plane);
}
var landPos = dest.CenterLocation;
var aircraft = self.Trait <Aircraft>();
var speed = .2f * aircraft.MovementSpeed;
var approachStart = landPos - new float2(aircraft.Altitude * speed, 0);
var turnRadius = (128f / self.Info.Traits.Get <AircraftInfo>().ROT) * speed / (float)Math.PI;
/* work out the center points */
var fwd = -float2.FromAngle(aircraft.Facing / 128f * (float)Math.PI);
var side = new float2(-fwd.Y, fwd.X); /* rotate */
var sideTowardBase = new[] { side, -side }
.OrderBy(a => float2.Dot(a, self.CenterLocation - approachStart))
.First();
var c1 = self.CenterLocation + turnRadius * sideTowardBase;
var c2 = approachStart + new float2(0,
turnRadius * Math.Sign(self.CenterLocation.Y - approachStart.Y)); // above or below start point
/* work out tangent points */
var d = c2 - c1;
var e = (turnRadius / d.Length) * d;
var f = new float2(-e.Y, e.X); /* rotate */
/* todo: support internal tangents, too! */
if (f.X > 0)
{
f = -f;
}
w1 = (c1 + f).ToInt2();
w2 = (c2 + f).ToInt2();
w3 = (approachStart).ToInt2();
plane.RTBPathHash = w1 + w2 + w3;
isCalculated = true;
}
public void When_Releasing_An_Already_Released_Object()
{
// Arrange
var reserved = new Reservable <int>(1);
// Act, Assert
Assert.Throws <InvalidOperationException>(() => reserved.TryRelease());
}
public Actor ChooseHelipad(Actor self, bool unreservedOnly)
{
var rearmBuildings = heli.Info.RearmBuildings;
return(self.World.Actors.Where(a => a.Owner == self.Owner &&
rearmBuildings.Contains(a.Info.Name) &&
(!unreservedOnly || !Reservable.IsReserved(self))).ClosestTo(self));
}
public static Actor ChooseAirfield(Actor self, bool unreservedOnly)
{
var rearmBuildings = self.Info.TraitInfo <AircraftInfo>().RearmBuildings;
return(self.World.ActorsHavingTrait <Reservable>()
.Where(a => a.Owner == self.Owner &&
rearmBuildings.Contains(a.Info.Name) &&
(!unreservedOnly || !Reservable.IsReserved(a)))
.ClosestTo(self));
}
public static Actor ChooseAirfield(Actor self, bool unreservedOnly)
{
var rearmBuildings = self.Info.Traits.Get <PlaneInfo>().RearmBuildings;
return(self.World.ActorsWithTrait <Reservable>()
.Where(a => a.Actor.Owner == self.Owner)
.Where(a => rearmBuildings.Contains(a.Actor.Info.Name) &&
(!unreservedOnly || !Reservable.IsReserved(a.Actor)))
.Select(a => a.Actor)
.ClosestTo(self));
}
public void ResolveOrder(Actor self, Order order)
{
if (order.OrderString == "Move")
{
UnReserve();
var target = self.World.ClampToWorld(order.TargetLocation);
self.SetTargetLine(Target.FromCell(target), Color.Green);
self.CancelActivity();
self.QueueActivity(Fly.ToCell(target));
self.QueueActivity(new FlyCircle());
}
else if (order.OrderString == "Enter")
{
if (Reservable.IsReserved(order.TargetActor))
{
return;
}
UnReserve();
self.SetTargetLine(Target.FromOrder(order), Color.Green);
self.CancelActivity();
self.QueueActivity(new ReturnToBase(self, order.TargetActor));
self.QueueActivity(new ResupplyAircraft());
}
else if (order.OrderString == "Stop")
{
UnReserve();
self.CancelActivity();
}
else if (order.OrderString == "ReturnToBase")
{
var airfield = ReturnToBase.ChooseAirfield(self);
if (airfield == null)
{
return;
}
UnReserve();
self.CancelActivity();
self.SetTargetLine(Target.FromActor(airfield), Color.Green);
self.QueueActivity(new ReturnToBase(self, airfield));
self.QueueActivity(new ResupplyAircraft());
}
else
{
// Game.Debug("Unreserve due to unhandled order: {0}".F(order.OrderString));
UnReserve();
}
}
public Actor ChooseResupplier(Actor self, bool unreservedOnly)
{
if (rearmable == null)
{
return(null);
}
return(self.World.Actors.Where(a => a.Owner == self.Owner &&
rearmable.Info.RearmActors.Contains(a.Info.Name) &&
(!unreservedOnly || !Reservable.IsReserved(a)))
.ClosestTo(self));
}
public static Actor ChooseResupplier(Actor self, bool unreservedOnly)
{
var rearmInfo = self.Info.TraitInfoOrDefault <RearmableInfo>();
if (rearmInfo == null)
{
return(null);
}
return(self.World.ActorsHavingTrait <Reservable>()
.Where(a => a.Owner == self.Owner &&
rearmInfo.RearmActors.Contains(a.Info.Name) &&
(!unreservedOnly || !Reservable.IsReserved(a)))
.ClosestTo(self));
}
public void Releases_Correctly_And_Return_True_If_Fully_Released()
{
// Arrange
var item = new Reservable <object>(new object());
item.Reserve();
item.Reserve();
// Act, Assert
Assert.Equal(2, item.Reservations);
Assert.False(item.TryRelease());
Assert.Equal(1, item.Reservations);
Assert.True(item.TryRelease());
Assert.Equal(0, item.Reservations);
}
public void Will_Increase_Reservation_By_One()
{
// Arrange
var item = new Reservable <object>(new object());
// Act
var preReserve = item.Reservations;
item.Reserve();
var midReserveCount = item.Reservations;
item.Reserve();
var postReserveCount = item.Reservations;
// Assert
Assert.Equal(0, preReserve);
Assert.Equal(1, midReserveCount);
Assert.Equal(2, postReserveCount);
}
static void Main(string[] args)
{
// Create book
Book book = new Book("Worley", "Inside ASP.NET", 10);
book.Display();
// Create video
Video video = new Video("Spielberg", "Jaws", 23, 92);
video.Display();
//Create audio tape
AudioTape audioTape = new AudioTape("Morgan Freeman", "The Wish Giver", "Bill Brittain", 24, 600);
audioTape.Display();
// Make video borrowable, then borrow and display
Console.WriteLine("\nMaking video rentable:");
Rentable rentedVideo = new Rentable(video);
rentedVideo.RentItem("Customer #1");
rentedVideo.RentItem("Customer #2");
rentedVideo.Display();
Console.WriteLine("\nMaking audio tape reservable");
Reservable reservedAudioTape = new Reservable(audioTape);
reservedAudioTape.ReserveItem("Customer #3");
reservedAudioTape.ReserveItem("Customer #4");
reservedAudioTape.Display();
// Wait for user
Console.ReadKey();
}
public override Activity Tick(Actor self)
{
var host = aircraft.GetActorBelow();
if (host == null)
{
return(NextActivity);
}
if (aircraft.IsPlane)
{
return(ActivityUtils.SequenceActivities(
aircraft.GetResupplyActivities(host)
.Append(new CallFunc(() => aircraft.UnReserve()))
.Append(new WaitFor(() => NextActivity != null || Reservable.IsReserved(host)))
.Append(new TakeOff(self))
.Append(NextActivity).ToArray()));
}
// If is helicopter move away as soon as the resupply ends
return(ActivityUtils.SequenceActivities(
aircraft.GetResupplyActivities(host).Append(new TakeOff(self)).Append(NextActivity).ToArray()));
}
public void ResolveOrder(Actor self, Order order)
{
if (reservation != null)
{
reservation.Dispose();
reservation = null;
}
if (order.OrderString == "Move")
{
var target = self.World.ClampToWorld(order.TargetLocation);
self.SetTargetLine(Target.FromCell(target), Color.Green);
self.CancelActivity();
self.QueueActivity(new HeliFly(Util.CenterOfCell(target)));
if (Info.LandWhenIdle)
{
self.QueueActivity(new Turn(Info.InitialFacing));
self.QueueActivity(new HeliLand(true));
}
}
if (order.OrderString == "Enter")
{
if (Reservable.IsReserved(order.TargetActor))
{
self.CancelActivity();
self.QueueActivity(new HeliReturn());
}
else
{
var res = order.TargetActor.TraitOrDefault <Reservable>();
if (res != null)
{
reservation = res.Reserve(order.TargetActor, self, this);
}
var exit = order.TargetActor.Info.Traits.WithInterface <ExitInfo>().FirstOrDefault();
var offset = exit != null ? exit.SpawnOffset : int2.Zero;
self.SetTargetLine(Target.FromActor(order.TargetActor), Color.Green);
self.CancelActivity();
self.QueueActivity(new HeliFly(order.TargetActor.Trait <IHasLocation>().PxPosition + offset));
self.QueueActivity(new Turn(Info.InitialFacing));
self.QueueActivity(new HeliLand(false));
self.QueueActivity(new ResupplyAircraft());
}
}
if (order.OrderString == "ReturnToBase")
{
self.CancelActivity();
self.QueueActivity(new HeliReturn());
}
if (order.OrderString == "Stop")
{
self.CancelActivity();
if (Info.LandWhenIdle)
{
self.QueueActivity(new Turn(Info.InitialFacing));
self.QueueActivity(new HeliLand(true));
}
}
}
public override bool Tick(Actor self)
{
// Refuse to take off if it would land immediately again.
// Special case: Don't kill other deploy hotkey activities.
if (aircraft.ForceLanding)
{
return(true);
}
if (IsCanceling || self.IsDead)
{
return(true);
}
if (dest == null || dest.IsDead || !Reservable.IsAvailableFor(dest, self))
{
dest = ChooseResupplier(self, true);
}
if (dest == null)
{
var nearestResupplier = ChooseResupplier(self, false);
if (nearestResupplier != null)
{
if (aircraft.Info.CanHover)
{
var distanceFromResupplier = (nearestResupplier.CenterPosition - self.CenterPosition).HorizontalLength;
var distanceLength = aircraft.Info.WaitDistanceFromResupplyBase.Length;
// If no pad is available, move near one and wait
if (distanceFromResupplier > distanceLength)
{
var randomPosition = WVec.FromPDF(self.World.SharedRandom, 2) * distanceLength / 1024;
var target = Target.FromPos(nearestResupplier.CenterPosition + randomPosition);
QueueChild(new Fly(self, target, WDist.Zero, aircraft.Info.WaitDistanceFromResupplyBase, targetLineColor: Color.Green));
}
return(false);
}
QueueChild(new Fly(self, Target.FromActor(nearestResupplier), WDist.Zero, aircraft.Info.WaitDistanceFromResupplyBase, targetLineColor: Color.Green));
QueueChild(new FlyIdle(self, aircraft.Info.NumberOfTicksToVerifyAvailableAirport));
return(false);
}
// Prevent an infinite loop in case we'd return to the activity that called ReturnToBase in the first place. Go idle instead.
self.CancelActivity();
return(true);
}
if (ShouldLandAtBuilding(self, dest))
{
var exit = dest.FirstExitOrDefault();
var offset = exit != null ? exit.Info.SpawnOffset : WVec.Zero;
if (aircraft.Info.TurnToDock || !aircraft.Info.VTOL)
{
facing = WAngle.FromFacing(aircraft.Info.InitialFacing);
}
aircraft.MakeReservation(dest);
QueueChild(new Land(self, Target.FromActor(dest), offset, facing, Color.Green));
QueueChild(new Resupply(self, dest, WDist.Zero, alwaysLand));
return(true);
}
QueueChild(new Fly(self, Target.FromActor(dest), targetLineColor: Color.Green));
return(true);
}
public void ResolveOrder(Actor self, Order order)
{
if (Reservation != null)
{
Reservation.Dispose();
Reservation = null;
}
if (order.OrderString == "Move")
{
var cell = self.World.Map.Clamp(order.TargetLocation);
var explored = self.Owner.Shroud.IsExplored(cell);
if (!explored && !Info.MoveIntoShroud)
{
return;
}
var target = Target.FromCell(self.World, cell);
self.SetTargetLine(target, Color.Green);
self.CancelActivity();
self.QueueActivity(new HeliFly(self, target));
if (Info.LandWhenIdle)
{
if (Info.TurnToLand)
{
self.QueueActivity(new Turn(self, Info.InitialFacing));
}
self.QueueActivity(new HeliLand(true));
}
}
if (order.OrderString == "Enter")
{
if (Reservable.IsReserved(order.TargetActor))
{
self.CancelActivity();
self.QueueActivity(new HeliReturn());
}
else
{
var res = order.TargetActor.TraitOrDefault <Reservable>();
if (res != null)
{
Reservation = res.Reserve(order.TargetActor, self, this);
}
var exit = order.TargetActor.Info.Traits.WithInterface <ExitInfo>().FirstOrDefault();
var offset = (exit != null) ? exit.SpawnOffset : WVec.Zero;
self.SetTargetLine(Target.FromActor(order.TargetActor), Color.Green);
self.CancelActivity();
self.QueueActivity(new HeliFly(self, Target.FromPos(order.TargetActor.CenterPosition + offset)));
self.QueueActivity(new Turn(self, Info.InitialFacing));
self.QueueActivity(new HeliLand(false));
self.QueueActivity(new ResupplyAircraft());
self.QueueActivity(new TakeOff());
}
}
if (order.OrderString == "ReturnToBase")
{
self.CancelActivity();
self.QueueActivity(new HeliReturn());
}
if (order.OrderString == "Stop")
{
self.CancelActivity();
if (Info.LandWhenIdle)
{
if (Info.TurnToLand)
{
self.QueueActivity(new Turn(self, Info.InitialFacing));
}
self.QueueActivity(new HeliLand(true));
}
}
}
public override Activity Tick(Actor self)
{
if (ChildActivity != null)
{
ChildActivity = ActivityUtils.RunActivityTick(self, ChildActivity);
if (ChildActivity != null)
{
return(this);
}
}
// Refuse to take off if it would land immediately again.
// Special case: Don't kill other deploy hotkey activities.
if (aircraft.ForceLanding)
{
return(NextActivity);
}
// If a Cancel was triggered at this point, it's unlikely that previously queued child activities finished,
// so 'resupplied' needs to be set to false, else it + abortOnResupply might cause another Cancel
// that would cancel any other activities that were queued after the first Cancel was triggered.
// TODO: This is a mess, we need to somehow make the activity cancelling a bit less tricky.
if (resupplied && IsCanceling)
{
resupplied = false;
}
if (resupplied && abortOnResupply)
{
Cancel(self);
}
if (resupplied || IsCanceling || self.IsDead)
{
return(NextActivity);
}
if (dest == null || dest.IsDead || !Reservable.IsAvailableFor(dest, self))
{
dest = ReturnToBase.ChooseResupplier(self, true);
}
if (!isCalculated)
{
Calculate(self);
}
if (dest == null)
{
var nearestResupplier = ChooseResupplier(self, false);
if (nearestResupplier != null)
{
if (aircraft.Info.CanHover)
{
var distanceFromResupplier = (nearestResupplier.CenterPosition - self.CenterPosition).HorizontalLength;
var distanceLength = aircraft.Info.WaitDistanceFromResupplyBase.Length;
// If no pad is available, move near one and wait
if (distanceFromResupplier > distanceLength)
{
var randomPosition = WVec.FromPDF(self.World.SharedRandom, 2) * distanceLength / 1024;
var target = Target.FromPos(nearestResupplier.CenterPosition + randomPosition);
QueueChild(self, new HeliFly(self, target, WDist.Zero, aircraft.Info.WaitDistanceFromResupplyBase, targetLineColor: Color.Green), true);
}
return(this);
}
else
{
QueueChild(self,
new Fly(self, Target.FromActor(nearestResupplier), WDist.Zero, aircraft.Info.WaitDistanceFromResupplyBase, targetLineColor: Color.Green),
true);
QueueChild(self, new FlyCircle(self, aircraft.Info.NumberOfTicksToVerifyAvailableAirport), true);
return(this);
}
}
else if (nearestResupplier == null && aircraft.Info.VTOL && aircraft.Info.LandWhenIdle)
{
// Using Queue instead of QueueChild here is intentional, as we want VTOLs with LandWhenIdle to land and stay there in this situation
Cancel(self);
if (aircraft.Info.TurnToLand)
{
Queue(self, new Turn(self, aircraft.Info.InitialFacing));
}
Queue(self, new Land(self));
return(NextActivity);
}
else
{
// Prevent an infinite loop in case we'd return to the activity that called ReturnToBase in the first place. Go idle instead.
Cancel(self);
return(NextActivity);
}
}
var exit = dest.FirstExitOrDefault(null);
var offset = exit != null ? exit.Info.SpawnOffset : WVec.Zero;
if (aircraft.Info.CanHover)
{
QueueChild(self, new HeliFly(self, Target.FromPos(dest.CenterPosition + offset)), true);
}
else if (aircraft.Info.VTOL)
{
QueueChild(self, new Fly(self, Target.FromPos(dest.CenterPosition + offset)), true);
}
else
{
var turnRadius = Fly.CalculateTurnRadius(aircraft.Info.Speed, aircraft.Info.TurnSpeed);
QueueChild(self, new Fly(self, Target.FromPos(w1), WDist.Zero, new WDist(turnRadius * 3)), true);
QueueChild(self, new Fly(self, Target.FromPos(w2)), true);
// Fix a problem when the airplane is sent to resupply near the airport
QueueChild(self, new Fly(self, Target.FromPos(w3), WDist.Zero, new WDist(turnRadius / 2)), true);
}
if (ShouldLandAtBuilding(self, dest))
{
aircraft.MakeReservation(dest);
if (aircraft.Info.VTOL && aircraft.Info.TurnToDock)
{
QueueChild(self, new Turn(self, aircraft.Info.InitialFacing), true);
}
QueueChild(self, new Land(self, Target.FromActor(dest), offset), true);
QueueChild(self, new Resupply(self, dest, WDist.Zero), true);
resupplied = true;
}
return(this);
}
public override Activity Tick(Actor self)
{
// Refuse to take off if it would land immediately again.
// Special case: Don't kill other deploy hotkey activities.
if (heli.ForceLanding)
{
return(NextActivity);
}
if (IsCanceled)
{
return(NextActivity);
}
if (dest == null || dest.IsDead || Reservable.IsReserved(dest))
{
dest = ChooseHelipad(self, true);
}
var initialFacing = heli.Info.InitialFacing;
if (dest == null || dest.IsDead)
{
var nearestHpad = ChooseHelipad(self, false);
// If a heli was told to return and there's no (available) RearmBuilding, going to the probable next queued activity (HeliAttack)
// would be pointless (due to lack of ammo), and possibly even lead to an infinite loop due to HeliAttack.cs:L79.
if (nearestHpad == null && heli.Info.LandWhenIdle)
{
if (heli.Info.TurnToLand)
{
return(ActivityUtils.SequenceActivities(new Turn(self, initialFacing), new HeliLand(self, true)));
}
return(new HeliLand(self, true));
}
else if (nearestHpad == null && !heli.Info.LandWhenIdle)
{
return(null);
}
else
{
var distanceFromHelipad = (nearestHpad.CenterPosition - self.CenterPosition).HorizontalLength;
var distanceLength = heli.Info.WaitDistanceFromResupplyBase.Length;
// If no pad is available, move near one and wait
if (distanceFromHelipad > distanceLength)
{
var randomPosition = WVec.FromPDF(self.World.SharedRandom, 2) * distanceLength / 1024;
var target = Target.FromPos(nearestHpad.CenterPosition + randomPosition);
return(ActivityUtils.SequenceActivities(new HeliFly(self, target, WDist.Zero, heli.Info.WaitDistanceFromResupplyBase), this));
}
return(this);
}
}
var exit = dest.Info.FirstExitOrDefault(null);
var offset = (exit != null) ? exit.SpawnOffset : WVec.Zero;
if (ShouldLandAtBuilding(self, dest))
{
heli.MakeReservation(dest);
return(ActivityUtils.SequenceActivities(
new HeliFly(self, Target.FromPos(dest.CenterPosition + offset)),
new Turn(self, initialFacing),
new HeliLand(self, false),
new ResupplyAircraft(self),
!abortOnResupply ? NextActivity : null));
}
return(ActivityUtils.SequenceActivities(
new HeliFly(self, Target.FromPos(dest.CenterPosition + offset)),
NextActivity));
}
void Calculate(Actor self)
{
if (dest == null || Reservable.IsReserved(dest))
{
dest = ChooseAirfield(self, true);
}
if (dest == null)
{
return;
}
var plane = self.Trait <Plane>();
var planeInfo = self.Info.Traits.Get <PlaneInfo>();
var res = dest.TraitOrDefault <Reservable>();
if (res != null)
{
plane.UnReserve();
plane.Reservation = res.Reserve(dest, self, plane);
}
var landPos = dest.CenterPosition;
var altitude = planeInfo.CruiseAltitude.Range;
// Distance required for descent.
var landDistance = altitude * 1024 / plane.Info.MaximumPitch.Tan();
// Land towards the east
var approachStart = landPos + new WVec(-landDistance, 0, altitude);
// Add 10% to the turning radius to ensure we have enough room
var speed = plane.MovementSpeed * 32 / 35;
var turnRadius = (int)(141 * speed / planeInfo.ROT / (float)Math.PI);
// Find the center of the turning circles for clockwise and counterclockwise turns
var angle = WAngle.FromFacing(plane.Facing);
var fwd = -new WVec(angle.Sin(), angle.Cos(), 0);
// Work out whether we should turn clockwise or counter-clockwise for approach
var side = new WVec(-fwd.Y, fwd.X, fwd.Z);
var approachDelta = self.CenterPosition - approachStart;
var sideTowardBase = new[] { side, -side }
.MinBy(a => WVec.Dot(a, approachDelta));
// Calculate the tangent line that joins the turning circles at the current and approach positions
var cp = self.CenterPosition + turnRadius * sideTowardBase / 1024;
var posCenter = new WPos(cp.X, cp.Y, altitude);
var approachCenter = approachStart + new WVec(0, turnRadius * Math.Sign(self.CenterPosition.Y - approachStart.Y), 0);
var tangentDirection = approachCenter - posCenter;
var tangentOffset = new WVec(-tangentDirection.Y, tangentDirection.X, 0) * turnRadius / tangentDirection.Length;
// TODO: correctly handle CCW <-> CW turns
if (tangentOffset.X > 0)
{
tangentOffset = -tangentOffset;
}
w1 = posCenter + tangentOffset;
w2 = approachCenter + tangentOffset;
w3 = approachStart;
plane.RTBPathHash = w1 + (WVec)w2 + (WVec)w3;
isCalculated = true;
}
public void ResolveOrder(Actor self, Order order)
{
if (order.OrderString == "Move")
{
var cell = self.World.Map.Clamp(self.World.Map.CellContaining(order.Target.CenterPosition));
if (!Info.MoveIntoShroud && !self.Owner.Shroud.IsExplored(cell))
{
return;
}
if (!order.Queued)
{
UnReserve();
}
var target = Target.FromCell(self.World, cell);
self.SetTargetLine(target, Color.Green);
if (!Info.CanHover)
{
self.QueueActivity(order.Queued, new Fly(self, target));
}
//else
// self.QueueActivity(order.Queued, new HeliFlyAndLandWhenIdle(self, target, Info));
}
else if (order.OrderString == "Enter" || order.OrderString == "Repair")
{
// Enter and Repair orders are only valid for own/allied actors,
// which are guaranteed to never be frozen.
if (order.Target.Type != TargetType.Actor)
{
return;
}
if (!order.Queued)
{
UnReserve();
}
var targetActor = order.Target.Actor;
// We only want to set a target line if the order will (most likely) succeed
if (Reservable.IsAvailableFor(targetActor, self))
{
self.SetTargetLine(Target.FromActor(targetActor), Color.Green);
}
self.QueueActivity(order.Queued, new ReturnToBase(self, Info.AbortOnResupply, targetActor));
}
else if (order.OrderString == "Stop")
{
self.CancelActivity();
// HACK: If the player accidentally pressed 'Stop', we don't want this to cancel reservation.
// If unreserving is actually desired despite an actor below, it should be triggered from OnBecomingIdle.
UnReserve();
}
else if (order.OrderString == "ReturnToBase" && rearmable != null && rearmable.Info.RearmActors.Any())
{
// Don't restart activity every time deploy hotkey is triggered
if (self.CurrentActivity is ReturnToBase)
{
return;
}
if (!order.Queued)
{
UnReserve();
}
// Aircraft with TakeOffOnResupply would immediately take off again, so there's no point in forcing them to land
// on a resupplier. For aircraft without it, it makes more sense to land than to idle above a free resupplier, though.
self.QueueActivity(order.Queued, new ReturnToBase(self, Info.AbortOnResupply, null, !Info.TakeOffOnResupply));
}
else if (order.OrderString == "Scatter")
{
Nudge(self);
}
}
