public void SetVictoryCondition(VictoryCondition Condition, Army ForArmy, Match Match)
{
_Display.Clear();
foreach (var objective in Condition.Scorers)
{
_Display.Add(
new Button("objective-header")
{
DisplayedString =
string.Format(
"{0}/{1}",
objective.CalculateScore(ForArmy, Match, new Dictionary <Objective, int>()),
Condition.GetMaximumScore(objective, ForArmy, Match))
});
_Display.Add(
new Button("objective-regular")
{
DisplayedString =
ObjectDescriber.Sentencify(
ObjectiveDescriber.RemoveScore(ObjectiveDescriber.Describe(objective)))
});
}
}
void UpdateControl(IEnumerable <Unit> Units)
{
var armies = Units.Where(i => i.Configuration.CanControl()).Select(i => i.Army).Distinct().ToList();
if (armies.Count == 0)
{
_ControllingArmy = null;
}
else if (armies.Count == 1)
{
_ControllingArmy = armies.First();
// Capture area control captureable units.
foreach (Unit unit in Units.ToList().Where(
i => i.Army != _ControllingArmy && i.Configuration.AreaControlCapture))
{
unit.Capture(_ControllingArmy);
}
}
else
{
_ControllingArmy = null;
}
}
public virtual OrderInvalidReason Validate()
{
OrderInvalidReason r;
if (_OddsCalculations.Count == 0)
{
if (TargetTile.Units.Count() == 0)
{
return(OrderInvalidReason.TARGET_EMPTY);
}
return(TargetTile.Units.First().CanBeAttackedBy(Army, AttackMethod));
}
if (Army.HasAttackedTile(TargetTile))
{
return(OrderInvalidReason.TARGET_ALREADY_ATTACKED);
}
foreach (SingleAttackOrder order in _Attackers)
{
r = order.Validate();
if (r != OrderInvalidReason.NONE)
{
return(r);
}
}
r = TargetTile.CanBeAttacked(AttackMethod);
if (r != OrderInvalidReason.NONE)
{
return(r);
}
if (_Attackers.Select(i => i.AttackTile).Distinct().Count() > 1)
{
return(OrderInvalidReason.ILLEGAL);
}
return(OrderInvalidReason.NONE);
}
public override int CalculateScore(Army ForArmy, Match Match, Dictionary <Objective, int> Cache)
{
switch (Direction)
{
case Direction.NORTH_WEST:
case Direction.NORTH_EAST:
case Direction.NORTH:
return(Match.Map.Height - ForArmy.Units.Max(i => i.Position != null ? 0 : i.Position.Coordinate.Y));
case Direction.SOUTH_WEST:
case Direction.SOUTH_EAST:
case Direction.SOUTH:
return(ForArmy.Units.Max(i => i.Position != null ? 0 : i.Position.Coordinate.Y) + 1);
case Direction.EAST:
return(ForArmy.Units.Max(i => i.Position != null ? 0 : i.Position.Coordinate.X) + 1);
case Direction.WEST:
return(Match.Map.Width - ForArmy.Units.Max(i => i.Position != null ? 0 : i.Position.Coordinate.Y));
default:
throw new ArgumentException(string.Format("Direction not supported: {0}", Direction));
}
}
public override int?GetMaximumScore(Objective Objective, Army ForArmy, Match Match)
{
if (Objective != this)
{
return(null);
}
switch (Direction)
{
case Direction.NORTH:
case Direction.NORTH_EAST:
case Direction.NORTH_WEST:
case Direction.SOUTH:
case Direction.SOUTH_EAST:
case Direction.SOUTH_WEST:
return(Match.Map.Height);
case Direction.EAST:
case Direction.WEST:
return(Match.Map.Width);
default:
throw new ArgumentException(string.Format("Direction not supported: {0}", Direction));
}
}
public override int?GetMaximumScore(Objective Objective, Army ForArmy, Match Match)
{
return(Objective == this ? (int?)Match.Map.TilesEnumerable.Count(Matcher.MatchesTransient) : null);
}
public override int CalculateScore(Army ForArmy, Match Match, Dictionary <Objective, int> Cache)
{
return(ScoreWithMatcher(Matcher.Matches, ForArmy, Match));
}
protected Deployment(Army Army, IEnumerable <Unit> Units, IdGenerator IdGenerator)
{
this.Army = Army;
this.Units = Units.ToList();
_Id = IdGenerator.GenerateId();
}
public IEnumerable <Unit> GenerateUnits(Army Army, IdGenerator IdGenerator)
{
return(UnitConfigurations.Select(i => new Unit(Army, i, IdGenerator)));
}
public Deployment GenerateDeployment(Army Army, IdGenerator IdGenerator)
{
return(new ConvoyDeployment(Army, UnitGroup.GenerateUnits(Army, IdGenerator), this, IdGenerator));
}
void SetVictoryConditions(Army Army)
{
_VictoryConditionDisplay.SetVictoryCondition(
Army.Configuration.VictoryCondition, Army, Army.Match);
}
public override int CalculateScore(Army ForArmy, Match Match, Dictionary <Objective, int> Cache)
{
return(Match.Armies.Where(i => i.Configuration.Team != ForArmy.Configuration.Team)
.All(i => i.GetObjectiveSuccessLevel() < ObjectiveSuccessLevel.VICTORY) ? 1 : 0);
}
public override int CalculateScore(Army ForArmy, Match Match, Dictionary <Objective, int> Cache)
{
return(Objectives.Sum(i => i.GetScore(ForArmy, Match, Cache)));
}
public void Control(Unit Unit)
{
_ControllingArmy = Unit.Army;
}
public override int CalculateScore(Army ForArmy, Match Match, Dictionary <Objective, int> Cache)
{
return(Match.Map.TilesEnumerable.Count(
i => Friendly == (i.ControllingArmy == ForArmy) && Matcher.Matches(i)));
}
public IndirectFireAttackOrder(Army Army, Tile TargetTile)
: base(Army, TargetTile)
{
}
public override int?GetMaximumScore(Objective Objective, Army ForArmy, Match Match)
{
return(Objective == this
? Match.Scenario.TurnConfiguration.Turns
: this.Objective.GetMaximumScore(Objective, ForArmy, Match));
}
public Deployment GenerateDeployment(Army Army, IdGenerator IdGenerator)
{
return(new PositionalDeployment(Army, UnitGroup.GenerateUnits(Army, IdGenerator), this, IdGenerator));
}
public override int CalculateScore(Army ForArmy, Match Match, Dictionary <Objective, int> Cache)
{
return(Points * Objective.GetScore(ForArmy, Match, Cache));
}
public ResetOrder(Army Army, bool CompleteReset)
{
this.Army = Army;
this.CompleteReset = CompleteReset;
}
public static string Describe(Army Army)
{
return(Describe(Army.Configuration));
}
public void HandleCombatResult(CombatResult CombatResult, AttackMethod AttackMethod, Army AttackingArmy)
{
if (Position == null)
{
return;
}
if (Passenger != null)
{
Passenger.HandleCombatResult(CombatResult, AttackMethod, AttackingArmy);
}
foreach (var unit in Position.Units.Where(i => Covers(i)).ToList())
{
unit.HandleCombatResult(CombatResult, AttackMethod, AttackingArmy);
}
switch (CombatResult)
{
case CombatResult.MISS:
return;
case CombatResult.DESTROY:
if (Army.Match.Scenario.Rules.AllowCloseAssaultCapture &&
AttackMethod == AttackMethod.CLOSE_ASSAULT &&
Configuration.CloseAssaultCapture)
{
Capture(AttackingArmy);
}
else
{
Status = UnitStatus.DESTROYED;
OnDestroy?.Invoke(this, EventArgs.Empty);
Remove();
}
return;
case CombatResult.DAMAGE:
Status = UnitStatus.DAMAGED;
Remove();
return;
case CombatResult.DISRUPT:
Status = UnitStatus.DISRUPTED;
if (Configuration.UnloadsWhenDisrupted && Passenger != null)
{
Unload(false);
}
OnDisrupt?.Invoke(this, EventArgs.Empty);
return;
case CombatResult.DOUBLE_DISRUPT:
if (Status == UnitStatus.DISRUPTED)
{
HandleCombatResult(CombatResult.DESTROY, AttackMethod, AttackingArmy);
}
else
{
Status = UnitStatus.DISRUPTED;
if (Configuration.UnloadsWhenDisrupted && Passenger != null)
{
Unload(false);
}
OnDisrupt?.Invoke(this, EventArgs.Empty);
}
return;
}
}
public NextPhaseOrder(Army Army, TurnComponent TurnComponent)
{
this.Army = Army;
this.TurnComponent = TurnComponent;
}
public override int CalculateScore(Army ForArmy, Match Match, Dictionary <Objective, int> Cache)
{
return(Numerator.GetScore(ForArmy, Match, Cache) / Denominator.GetScore(ForArmy, Match, Cache));
}
public AirAttackOrder(Army Army, Tile TargetTile)
: base(Army, TargetTile)
{
}
public AntiAirAttackOrder(Army Army, Tile TargetTile)
: base(Army, TargetTile)
{
SetAttackTarget(AttackTarget.EACH);
}
public override int?GetMaximumScore(Objective Objective, Army ForArmy, Match Match)
{
return(Objective == this ? (int?)1 : null);
}
public TurnInfo(Army Army, TurnComponent TurnComponent)
{
this.Army = Army;
this.TurnComponent = TurnComponent;
}
public bool IsSatisfied(Army ForArmy, Match Match, Dictionary <Objective, int> Cache)
{
return(Invert ? Objective.GetScore(ForArmy, Match, Cache) <= Threshold
: Objective.GetScore(ForArmy, Match, Cache) >= Threshold);
}
public MinefieldAttackOrder(Army Army, Tile TargetTile)
: base(Army, TargetTile)
{
}
