public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID == "DeliverSupplies") return new Order(order.OrderID, self, queued) { TargetActor = target.Actor }; return null; }
public Order IssueOrder( Actor self, IOrderTargeter order, Target target ) { if( order.OrderID == "Disguise" ) return new Order( order.OrderID, self, target.Actor ); return null; }
public Order IssueOrder( Actor self, IOrderTargeter order, Target target, bool queued ) { if( order.OrderID == "Unload" ) return new Order( order.OrderID, self, queued ); return null; }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID == "SetRallyPoint") return new Order(order.OrderID, self, false) { TargetLocation = self.World.Map.CellContaining(target.CenterPosition), SuppressVisualFeedback = true }; return null; }
public Order IssueOrder( Actor self, IOrderTargeter order, Target target, bool queued ) { if( order.OrderID == "EnterTransport" ) return new Order( order.OrderID, self, target.Actor, queued ); return null; }
public Order IssueOrder( Actor self, IOrderTargeter order, Target target, bool queued ) { if( order.OrderID == "SetRallyPoint" ) return new Order(order.OrderID, self, false) { TargetLocation = target.CenterPosition.ToCPos() }; return null; }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID == "DeployTransform") return new Order(order.OrderID, self, queued); return null; }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID == "ChronoshiftJump" && chargeTick <= 0) self.World.OrderGenerator = new ChronoTankOrderGenerator(self); return new Order("ChronoshiftJump", self, false); // Hack until we can return null }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID == "RepairBridge") return new Order(order.OrderID, self, queued) { TargetActor = target.Actor }; return null; }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (!(order is BeginMinefieldOrderTargeter)) return null; var start = target.CenterPosition.ToCPos(); self.World.OrderGenerator = new MinefieldOrderGenerator(self, start); return new Order("BeginMinefield", self, false) { TargetLocation = start }; }
public Order IssueOrder( Actor self, IOrderTargeter order, Target target, bool queued ) { if( order.OrderID == "Enter" ) return new Order(order.OrderID, self, queued) { TargetActor = target.Actor }; if( order.OrderID == "Move" ) return new Order(order.OrderID, self, queued) { TargetLocation = Util.CellContaining(target.CenterLocation) }; return null; }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID == "PortableChronoDeploy" && CanTeleport) self.World.OrderGenerator = new PortableChronoOrderGenerator(self, Info); if (order.OrderID == "PortableChronoTeleport") return new Order(order.OrderID, self, queued) { TargetLocation = self.World.Map.CellContaining(target.CenterPosition) }; return new Order(order.OrderID, self, queued) { TargetActor = target.Actor }; }
public Order IssueOrder( Actor self, IOrderTargeter order, Target target ) { if( order.OrderID == "Enter" ) return new Order( order.OrderID, self, target.Actor ); if( order.OrderID == "Move" ) return new Order( order.OrderID, self, Util.CellContaining( target.CenterLocation ) ); return null; }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID != "CaptureActor") return null; if (target.Type == TargetType.FrozenActor) return new Order(order.OrderID, self, queued) { ExtraData = target.FrozenActor.ID }; return new Order(order.OrderID, self, queued) { TargetActor = target.Actor }; }
public Order IssueOrder( Actor self, IOrderTargeter order, Target target, bool queued ) { if( order is BeginMinefieldOrderTargeter ) { var start = Traits.Util.CellContaining( target.CenterLocation ); self.World.OrderGenerator = new MinefieldOrderGenerator( self, start ); return new Order("BeginMinefield", self, false) { TargetLocation = start }; } return null; }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { switch (order.OrderID) { case "BeginMinefield": var start = self.World.Map.CellContaining(target.CenterPosition); self.World.OrderGenerator = new MinefieldOrderGenerator(self, start); return new Order("BeginMinefield", self, false) { TargetLocation = start }; case "PlaceMine": return new Order("PlaceMine", self, false) { TargetLocation = self.Location }; default: return null; } }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID == "PortableChronoDeploy" && CanTeleport) { self.World.OrderGenerator = new PortableChronoOrderGenerator(self); } if (order.OrderID == "PortableChronoTeleport") { return new Order(order.OrderID, self, queued) { TargetLocation = self.World.Map.CellContaining(target.CenterPosition) } } ; return(new Order(order.OrderID, self, queued) { TargetActor = target.Actor }); }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID != "EnterTunnel") { return(null); } if (target.Type == TargetType.FrozenActor) { return new Order(order.OrderID, self, queued) { ExtraData = target.FrozenActor.ID, SuppressVisualFeedback = true } } ; return(new Order(order.OrderID, self, queued) { TargetActor = target.Actor, SuppressVisualFeedback = true }); }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID != "C4") { return(null); } if (target.Type == TargetType.FrozenActor) { return new Order(order.OrderID, self, queued) { ExtraData = target.FrozenActor.ID } } ; return(new Order(order.OrderID, self, queued) { TargetActor = target.Actor }); }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID == "PortableChronoDeploy") { // HACK: Switch the global order generator instead of actually issuing an order if (CanTeleport) { self.World.OrderGenerator = new PortableChronoOrderGenerator(self, Info); } // HACK: We need to issue a fake order to stop the game complaining about the bodge above return(new Order(order.OrderID, self, Target.Invalid, queued)); } if (order.OrderID == "PortableChronoTeleport") { return(new Order(order.OrderID, self, target, queued)); } return(null); }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID == "Repair") { return new Order(order.OrderID, self, queued) { TargetActor = target.Actor } } ; return(null); } bool CanRepairAt(Actor target) { return(info.RepairBuildings.Contains(target.Info.Name)); } bool CanRearmAt(Actor target) { return(info.RepairBuildings.Contains(target.Info.Name)); } bool CanRepair() { return(health.DamageState > DamageState.Undamaged); } bool CanRearm() { if (ammoPools != null) { return(ammoPools.Any(x => !x.Info.SelfReloads && !x.FullAmmo())); } else { return(false); } }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order is AttackOrderTargeter) { if (target.IsActor) { return new Order("Attack", self, queued) { TargetActor = target.Actor } } ; else { return new Order("Attack", self, queued) { TargetLocation = Util.CellContaining(target.CenterLocation) } }; } return(null); }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID == "Deliver") { return new Order(order.OrderID, self, queued) { TargetActor = target.Actor } } ; if (order.OrderID == "Harvest") { return new Order(order.OrderID, self, queued) { TargetLocation = target.CenterPosition.ToCPos() } } ; return(null); }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { switch (order.OrderID) { case "BeginMinefield": var start = self.World.Map.CellContaining(target.CenterPosition); self.World.OrderGenerator = new MinefieldOrderGenerator(self, start); return(new Order("BeginMinefield", self, false) { TargetLocation = start }); case "PlaceMine": return(new Order("PlaceMine", self, false) { TargetLocation = self.Location }); default: return(null); } }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID == "Deliver") { return new Order(order.OrderID, self, queued) { TargetActor = target.Actor } } ; if (order.OrderID == "Harvest") { return new Order(order.OrderID, self, queued) { TargetLocation = self.World.Map.CellContaining(target.CenterPosition) } } ; return(null); }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID == "Enter") { return new Order(order.OrderID, self, queued) { TargetActor = target.Actor } } ; if (order.OrderID == "Move") { return new Order(order.OrderID, self, queued) { TargetLocation = Util.CellContaining(target.CenterLocation) } } ; return(null); }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID == "RepairNear") { return new Order(order.OrderID, self, queued) { TargetActor = target.Actor } } ; return(null); } bool CanRepairAt(Actor target) { return(info.Buildings.Contains(target.Info.Name)); } bool ShouldRepair() { return(self.GetDamageState() > DamageState.Undamaged); }
Order IIssueOrder.IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { switch (order.OrderID) { case "BeginMinefield": var start = self.World.Map.CellContaining(target.CenterPosition); if (self.World.OrderGenerator is MinefieldOrderGenerator) { ((MinefieldOrderGenerator)self.World.OrderGenerator).AddMinelayer(self, start); } else { self.World.OrderGenerator = new MinefieldOrderGenerator(self, start); } return(new Order("BeginMinefield", self, Target.FromCell(self.World, start), false)); case "PlaceMine": return(new Order("PlaceMine", self, Target.FromCell(self.World, self.Location), false)); default: return(null); } }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID == "Deliver") return new Order(order.OrderID, self, queued) { TargetActor = target.Actor }; if (order.OrderID == "Harvest") return new Order(order.OrderID, self, queued) { TargetLocation = target.CenterLocation.ToCPos() }; return null; }
Order IIssueOrder.IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { return(order.OrderID == ResearchOrderTargeter.Id ? new Order(order.OrderID, self, target, queued) : null); }
public Order IssueOrder( Actor self, IOrderTargeter order, Target target ) { if( order.OrderID == "Unload" ) return new Order( order.OrderID, self ); if( order.OrderID == "ReverseEnterTransport" ) return new Order( order.OrderID, self, target.Actor ); return null; }
public UnitOrderResult( Actor self, IOrderTargeter iot, IIssueOrder trait, string cursor, Target target ) { this.self = self; this.iot = iot; this.trait = trait; this.cursor = cursor; this.target = target; }
static Order CheckSameOrder( IOrderTargeter iot, Order order ) { if( order == null && iot.OrderID != null ) Game.Debug( "BUG: in order targeter - decided on {0} but then didn't order", iot.OrderID ); else if( iot.OrderID != order.OrderString ) Game.Debug( "BUG: in order targeter - decided on {0} but ordered {1}", iot.OrderID, order.OrderString ); return order; }
Order IIssueOrder.IssueOrder(Actor self, IOrderTargeter order, in Target target, bool queued)
public Order IssueOrder( Actor self, IOrderTargeter order, Target target ) { if( order is AttackOrderTargeter ) { if( target.IsActor ) return new Order( IsHeal ? "Heal" : "Attack", self, target.Actor ); else return new Order( IsHeal ? "Heal" : "Attack", self, Util.CellContaining( target.CenterLocation ) ); } return null; }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID == "Deliver") return new Order(order.OrderID, self, queued) { TargetActor = target.Actor }; if (order.OrderID == "Harvest") return new Order(order.OrderID, self, queued) { TargetLocation = self.World.Map.CellContaining(target.CenterPosition) }; return null; }
public UnitOrderResult(Actor actor, IOrderTargeter order, IIssueOrder trait, string cursor, Target target) { Actor = actor; Order = order; Trait = trait; Cursor = cursor; Target = target; }
Order IIssueOrder.IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID == "PickupUnit") { if (target.Type == TargetType.FrozenActor) { return new Order(order.OrderID, self, queued) { ExtraData = target.FrozenActor.ID } } ; return(new Order(order.OrderID, self, queued) { TargetActor = target.Actor }); } else if (order.OrderID == "DeliverUnit") { return(new Order(order.OrderID, self, queued) { TargetLocation = self.World.Map.CellContaining(target.CenterPosition) }); } else if (order.OrderID == "Unload") { return(new Order(order.OrderID, self, queued) { TargetLocation = self.World.Map.CellContaining(target.CenterPosition) }); } return(null); } void IResolveOrder.ResolveOrder(Actor self, Order order) { if (State == CarryallState.Carrying) { if (order.OrderString == "DeliverUnit") { var cell = self.World.Map.Clamp(order.TargetLocation); if (!aircraftInfo.MoveIntoShroud && !self.Owner.Shroud.IsExplored(cell)) { return; } var targetLocation = move.NearestMoveableCell(order.TargetLocation); self.SetTargetLine(Target.FromCell(self.World, targetLocation), Color.Yellow); self.QueueActivity(order.Queued, new DeliverUnit(self, targetLocation)); } else if (order.OrderString == "Unload") { var targetLocation = move.NearestMoveableCell(self.Location); self.SetTargetLine(Target.FromCell(self.World, targetLocation), Color.Yellow); self.QueueActivity(order.Queued, new DeliverUnit(self, targetLocation)); } } else { if (order.OrderString == "PickupUnit") { var target = self.ResolveFrozenActorOrder(order, Color.Yellow); if (target.Type != TargetType.Actor) { return; } if (!ReserveCarryable(self, target.Actor)) { return; } if (!order.Queued) { self.CancelActivity(); } self.SetTargetLine(target, Color.Yellow); self.QueueActivity(order.Queued, new PickupUnit(self, target.Actor, Info.LoadingDelay)); } } } string IOrderVoice.VoicePhraseForOrder(Actor self, Order order) { switch (order.OrderString) { case "DeliverUnit": case "Unload": case "PickupUnit": return(Info.Voice); default: return(null); } }
Order IIssueOrder.IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { return(order.OrderID == TechnicianEnterOrderTargeter.Id ? new Order(order.OrderID, self, target, queued) : null); }
public Order IssueOrder( Actor self, IOrderTargeter order, Target target, bool queued ) { if( order is AttackOrderTargeter ) { if( target.IsActor ) return new Order("Attack", self, queued) { TargetActor = target.Actor }; else return new Order( "Attack", self, queued ) { TargetLocation = target.CenterLocation.ToCPos() }; } return null; }
// Note: Returns a valid order even if the unit can't move to the target public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order is MoveOrderTargeter) { if (Info.OnRails) return null; return new Order("Move", self, queued) { TargetLocation = Util.CellContaining(target.CenterLocation) }; } return null; }
// Note: Returns a valid order even if the unit can't move to the target public Order IssueOrder( Actor self, IOrderTargeter order, Target target ) { if( order is MoveOrderTargeter ) { if( Info.OnRails ) return null; return new Order( "Move", self, Util.CellContaining( target.CenterLocation ), false ); } return null; }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { return(order.OrderID == SaboteurEnterOrderTargeter.Id ? new Order(order.OrderID, self, target, queued) : null); }
public UnitOrderResult(Actor actor, IOrderTargeter order, IIssueOrder trait, string cursor, in Target target)
public UnitOrderResult(Actor actor, IOrderTargeter order, IIssueOrder trait, string cursor, Target target) { this.Actor = actor; this.Order = order; this.Trait = trait; this.Cursor = cursor; this.Target = target; }
public Order IssueOrder( Actor self, IOrderTargeter order, Target target, bool queued ) { if( order is AttackOrderTargeter ) { if( target.IsActor ) return new Order( "Attack", self, target.Actor, queued ); else return new Order( "Attack", self, Util.CellContaining( target.CenterLocation ), queued ); } return null; }
public Order?IssueOrder(Actor self, IOrderTargeter order, in Target target, bool queued)
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order is AttackOrderTargeter) { switch (target.Type) { case TargetType.Actor: return new Order("Attack", self, queued) { TargetActor = target.Actor }; case TargetType.FrozenActor: return new Order("Attack", self, queued) { ExtraData = target.FrozenActor.ID }; case TargetType.Terrain: return new Order("Attack", self, queued) { TargetLocation = self.World.Map.CellContaining(target.CenterPosition) }; } } return null; }
public Order IssueOrder( Actor self, IOrderTargeter order, Target target, bool queued ) { if( order.OrderID == "Unload" ) return new Order( order.OrderID, self, queued ); if( order.OrderID == "ReverseEnterTransport" ) return new Order(order.OrderID, self, queued) { TargetActor = target.Actor }; return null; }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { return(order is DeployOnActorOrderTargeter ? new Order("Move", self, Target.FromCell(self.World, self.World.Map.CellContaining(target.CenterPosition)), queued) : null); }
public Order IssueOrder(Actor self, IOrderTargeter order, Target target, bool queued) { if (order.OrderID != "Infiltrate") { return(null); } if (target.Type == TargetType.FrozenActor) { return new Order(order.OrderID, self, queued) { ExtraData = target.FrozenActor.ID } } ; return(new Order(order.OrderID, self, queued) { TargetActor = target.Actor }); } bool IsValidOrder(Actor self, Order order) { if (IsTraitDisabled) { return(false); } // Not targeting an actor if (order.ExtraData == 0 && order.TargetActor == null) { return(false); } IEnumerable <string> targetTypes; if (order.ExtraData != 0) { // Targeted an actor under the fog var frozenLayer = self.Owner.PlayerActor.TraitOrDefault <FrozenActorLayer>(); if (frozenLayer == null) { return(false); } var frozen = frozenLayer.FromID(order.ExtraData); if (frozen == null) { return(false); } targetTypes = frozen.TargetTypes; } else { targetTypes = order.TargetActor.GetEnabledTargetTypes(); } return(Info.Types.Overlaps(targetTypes)); }