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); } }