/// <summary>
/// Combine the whole flank with an ally and removes all units from current flank
/// </summary>
/// <param name="other"></param>
public void CombineWithFlank(Flank other)
{
other.sideA.UnionWith(sideA);
sideA.Clear();
other.sideB.UnionWith(sideB);
sideB.Clear();
}
public Army(int[] v)
{
left = new Flank(v[0], v[3], v[6]);
centre = new Flank(v[1], v[4], v[7]);
right = new Flank(v[2], v[5], v[8]);
morale = this.GetMorale();
}
public HashSet <AbstractCard> GetActiveCardsFromFlank(CurrentPlayer player, Flank flank)
{
HashSet <AbstractCard> cards = new HashSet <AbstractCard>();
foreach (AbstractCard card in fields[player].flanks[flank])
{
if (card.active)
{
cards.Add(card);
}
}
return(cards);
}
public void hitToDeffender(uint hp, Flank flank, SquadCard card)
{
foreach (SquadCard _card in deffender[flank])
{
if (card == null)
{
continue;
}
if (card == _card)
{
card.stamina -= (int)hp;
}
}
}
public override bool IsOnFlank(int x, int y, Unit unit, Flank flank)
{
var northFacing = AIUtils.VectorFromCenterRotated(unit.RallyPoint, x, y, unit.UnitFacing);
if (flank == Flank.LEFT)
{
return(northFacing.Item1 <= -10);
}
else if (flank == Flank.RIGHT)
{
return(northFacing.Item1 >= 9);
}
else
{
throw new NotImplementedException();
}
}
private void applyInspiration(Skills skills, bool isAttacker, Flank flank)
{
if (isAttacker)
{
foreach (SquadCard card in attacker[flank])
{
if (card == null || card.isDeaf)
{
continue;
}
if (card.skills != skills)
{
card.addAttack += card.skills.inspiration;
card.addProtection += card.skills.inspiration;
if (skills.brotherhood)
{
card.addAttack += card.skills.brotherhood ? 1 : 0;
card.addProtection += card.skills.brotherhood ? 1 : 0;
card.addStamina += card.skills.brotherhood ? 1 : 0;
}
}
}
}
else
{
foreach (SquadCard card in deffender[flank])
{
if (card == null || card.isDeaf)
{
continue;
}
if (card.skills != skills)
{
card.addAttack += card.skills.inspiration;
card.addProtection += card.skills.inspiration;
if (skills.brotherhood)
{
card.addAttack += card.skills.brotherhood ? 1 : 0;
card.addProtection += card.skills.brotherhood ? 1 : 0;
card.addStamina += card.skills.brotherhood ? 1 : 0;
}
}
}
}
}
public void DetermineFlank()
{
var followedByWhitespace = this.following?.IsWhitespace() ?? true;
var followedByPunctuation = this.following?.IsAsciiPunctuation() ?? false;
var precededByWhitespace = this.preceding?.IsWhitespace() ?? true;
var precededByPunctuation = this.preceding?.IsAsciiPunctuation() ?? false;
var isLeft = false;
var isRight = false;
// A left-flanking delimiter run is a delimiter run that is (1) not followed by Unicode whitespace, and
// either (2a) not followed by a punctuation character, or (2b) followed by a punctuation character and
// preceded by Unicode whitespace or a punctuation character. For purposes of this definition, the beginning
// and the end of the line count as Unicode whitespace.
if (!followedByWhitespace && (!followedByPunctuation || (followedByPunctuation && (precededByWhitespace || precededByPunctuation))))
{
isLeft = true;
}
// A right-flanking delimiter run is a delimiter run that is (1) not preceded by Unicode whitespace, and
// either (2a) not preceded by a punctuation character, or (2b) preceded by a punctuation character and
// followed by Unicode whitespace or a punctuation character. For purposes of this definition, the beginning
// and the end of the line count as Unicode whitespace.
if (!precededByWhitespace && (!precededByPunctuation || (precededByPunctuation && (followedByWhitespace || followedByPunctuation))))
{
isRight = true;
}
if (isLeft && isRight)
{
this.flank = Flank.Both;
}
else if (isLeft)
{
this.flank = Flank.Left;
}
else if (isRight)
{
this.flank = Flank.Right;
}
}
public void SetAttackerFortificationCard(FortificationCard card, Flank flank)
{
attackerFortification[flank] = card;
}
// TODO: A more accurate algorithm than "is your position on the flank"
public static bool IsOnFlank(int x, int y, Unit unit, Flank flank)
{
//return AIUtils.FormationDictionary[unit.UnitFormation].IsOnFlank(x, y, unit, flank);
return(true); // Let's just restrict units to their exact lane
}
public abstract bool IsOnFlank(int x, int y, Unit unit, Flank flank);
public void ApplyFortificationCard(CurrentPlayer player, FortificationCard card, Flank flank)
{
attacks[player].SetAttackerFortificationCard(card, flank);
attacks[player == CurrentPlayer.FIRST ? CurrentPlayer.SECOND : CurrentPlayer.FIRST].SetDeffenderFortificationCard(card, flank);
}
public void ApplySkillsDeffender(Flank flank, Skills skills)
{
this.deffenderSkills[flank] = skills;
}
public void AddDeffenders(List <SquadCard> squad, Flank flank)
{
deffender[flank] = squad;
}
public FortificationCard GetDeffenderFortificationCard(Flank flank)
{
return(deffenderFortification[flank]);
}
public void SetDeffenderFortificationCard(FortificationCard card, Flank flank)
{
deffenderFortification[flank] = card;
}
public void DropFortification(CurrentPlayer player, Flank flank)
{
fields[player].DropCard(attacks[player].GetDeffenderFortificationCard(flank));
attacks[player].SetDeffenderFortificationCard(null, flank);
}
public int GetCardsCount(CurrentPlayer player, Flank flank)
{
return(fields[player].flanks[flank].Count);
}
public void SetDeffenders(CurrentPlayer player, List <SquadCard> cards, Flank flank)
{
attacks[player == CurrentPlayer.FIRST ? CurrentPlayer.SECOND : CurrentPlayer.FIRST].AddDeffenders(cards, flank);
}
public void SetAttackers(CurrentPlayer player, List <SquadCard> cards, Flank flank)
{
attacks[player].AddAttackers(cards, flank);
}
public void AddCardsToFlank(CurrentPlayer player, HashSet <SquadCard> cards, Flank flank)
{
fields[player].flanks[flank].UnionWith(cards);
}
public FortificationCard GetAttackerFortificationCard(Flank flank)
{
return(attackerFortification[flank]);
}
public bool IsOnFlank(FactionName faction, Flank flank)
{
return(true);
}
public void AddAttackers(List <SquadCard> squad, Flank flank)
{
attacker[flank] = squad;
}
public CommandorCard GetCommandor(Flank flank)
{
return(flank == Flank.Left ? commandorLeft : commandorRight);
}
public void ApplySkillsAttacker(Flank flank, Skills skills)
{
this.attackerSkills[flank] = skills;
}
/// <summary>
/// Runs a full combat turn between two squads
/// </summary>
/// <param name="attacker"></param>
/// <param name="defender"></param>
public static void CombatTurn(Squad attacker, Squad defender)
{
//Squads make initial formation
//TODO: FRONTLINE AND BACKLINE DIFFERENCIATION
//FOR NOW: Seperate in 3 groups as equal as possible
Flank[] flanks;
FormInitialFlanks(attacker, defender, out flanks);
//BEGIN LOOP
//Initiative is rolled
while (!CombatIsOver(attacker, defender))
{
Debug.Log("NEW TURN");
List <IUnit> turnOrder = TurnOrder(attacker, defender);
//Units attack from possible targets depending on formation
for (int i = 0; i < turnOrder.Count; i++)
{
IUnit unit = turnOrder[i];
//Skip if unit is dead
if (!unit.isAlive || unit.isHarmless)
{
continue;
}
//Find in which flank the unit is
Flank current = null;
bool isSideA = false;
for (int j = 0; j < 3 && current == null; j++)
{
if (flanks[j].FindUnit(unit, out isSideA))
{
current = flanks[j];
}
}
//Error case?
if (current == null)
{
Debug.LogWarning("Current could not be found");
continue;
}
//Acquire random target
IUnit target = current.RandomTarget(isSideA);
//Skip if flank was defeated
if (target == null)
{
continue;
}
//Resolve attack
if (ResolveAttack(unit, target))
{
//Remove dead soldiers
current.FlankMemberDied(target);
//turnOrder.Remove(target);
}
}
//Flanks with no more targets join another flank for next round
RearrangeFlanks(flanks);
}
Debug.Log("BATTLE OVER");
}
static void FormInitialFlanks(Squad squadA, Squad squadB, out Flank[] flanks)
{
flanks = new Flank[3];
for (int i = 0; i < 3; i++)
{
flanks[i] = new Flank();
}
//////////////////////////
//First squad
//////////////////////////
List <IUnit> remaining = new List <IUnit>();
remaining.AddRange(squadA.members);
Debug.Log(squadA.members[0] + " - " + remaining[0]);
//Leaders in the middle
flanks[1].AddMember(squadA.leader, true);
remaining.Remove(squadA.leader);
//Flanks are chosen by preferences if present, else by combat skill
//TODO: Preferences
remaining = remaining.OrderByDescending(x => x.s_combat).ToList();
//Add units in this following order: Left, right, middle
while (true)
{
flanks[0].AddMember(remaining[0], true);
remaining.RemoveAt(0);
if (remaining.Count == 0)
{
break;
}
flanks[2].AddMember(remaining[0], true);
remaining.RemoveAt(0);
if (remaining.Count == 0)
{
break;
}
flanks[1].AddMember(remaining[0], true);
remaining.RemoveAt(0);
if (remaining.Count == 0)
{
break;
}
}
//////////////////////////
//Second squad
//////////////////////////
remaining.Clear();
remaining.AddRange(squadB.members);
//Leaders in the middle
flanks[1].AddMember(squadB.leader, false);
remaining.Remove(squadB.leader);
//Flanks are chosen by preferences if present, else by combat skill
//TODO: Preferences
remaining = remaining.OrderByDescending(x => x.s_combat).ToList();
//Add units in this following order: Left, right, middle
while (true)
{
flanks[0].AddMember(remaining[0], false);
remaining.RemoveAt(0);
if (remaining.Count == 0)
{
break;
}
flanks[2].AddMember(remaining[0], false);
remaining.RemoveAt(0);
if (remaining.Count == 0)
{
break;
}
flanks[1].AddMember(remaining[0], false);
remaining.RemoveAt(0);
if (remaining.Count == 0)
{
break;
}
}
Debug.Log("Final flank size " +
flanks[0].sideA.Count + " - " + flanks[0].sideB.Count +
flanks[1].sideA.Count + " - " + flanks[1].sideB.Count +
flanks[2].sideA.Count + " - " + flanks[2].sideB.Count);
}
public FortificationCard GetFortificationCard(CurrentPlayer player, Flank flank)
{
return(attacks[player].GetAttackerFortificationCard(flank));
}
