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