//many battlestats
public void Show(BattleArmy barmy)
{
string ArmyShow = "";
foreach (BattleUnitStack u in barmy.Description)
{
//battlestat
string stats = "";
double Alive = (double)u.curHitPoints / u.minion.HitPoints;
Alive = Math.Ceiling(Alive);
stats = $"ID: {u.ID}\n" +
$"Name: {u.minion.Type}\n" +
$"Amount: {Alive}\\{u.BasicAmount} HP: {u.curHitPoints - ((Alive - 1) * u.minion.HitPoints)}\\{u.minion.HitPoints}\n" +
$"Attack: {u.minion.Attack} ({u.curAttack}) \n" +
$"Damage: {u.minion.MinDamage} - {u.minion.MaxDamage}\n" +
$"Defence: {u.minion.Defence} ({u.curDefence})\n" +
$"Initiative: {u.minion.Initiative} ({u.curInitiative})\n" +
$"Description:\n" +
$"{u.minion.Description}\n";
//
ArmyShow = ArmyShow + $"///{u.minion.Type}:{u.BasicAmount}///\n" +
$"{stats}\n";
}
if (ArmyShow == "")
{
Console.WriteLine("Empty army");
}
else
{
Console.WriteLine(ArmyShow);
}
}
public void BattleArmy_GetStacks()
{
Unit angel = new UnitAngel();
Unit skeleton = new UnitSkeleton();
UnitsStack stack1 = new UnitsStack(angel, 10);
UnitsStack stack2 = new UnitsStack(skeleton, 42);
UnitsStack stack3 = new UnitsStack(angel, 42);
List <UnitsStack> stacks = new List <UnitsStack> {
stack1, stack2, stack3
};
Army baseArmy = new Army(stacks);
BattleArmy army = new BattleArmy(baseArmy, null);
army.GetStack(0).SetHitPoints(0);
IList <BattleUnitsStack> aliveStacks = army.GetAliveStacks();
IList <BattleUnitsStack> deadStacks = army.GetDeadStacks();
Assert.AreEqual(2, aliveStacks.Count);
Assert.AreEqual(stack2, aliveStacks[0].GetBaseStack());
Assert.AreEqual(stack3, aliveStacks[1].GetBaseStack());
Assert.AreEqual(1, deadStacks.Count);
Assert.AreEqual(stack1, deadStacks[0].GetBaseStack());
}
public void Battle_Side()
{
Unit angel = new UnitAngel();
Unit skeleton = new UnitSkeleton();
UnitsStack stack1 = new UnitsStack(angel, 10);
UnitsStack stack2 = new UnitsStack(skeleton, 42);
UnitsStack stack3 = new UnitsStack(angel, 2);
List <UnitsStack> stacks1 = new List <UnitsStack> {
stack1, stack2
};
List <UnitsStack> stacks2 = new List <UnitsStack> {
stack3
};
Army army1 = new Army(stacks1);
Army army2 = new Army(stacks2);
Battle battle = new Battle(army1, army2);
BattleArmy battleArmy1 = battle.GetAttacker();
BattleArmy battleArmy2 = battle.GetTarget();
Assert.IsTrue(battleArmy1.IsAttacker());
Assert.IsFalse(battleArmy1.IsTarget());
Assert.IsFalse(battleArmy2.IsAttacker());
Assert.IsTrue(battleArmy2.IsTarget());
}
public void BattleArmy_GetStacksByUnitType()
{
Unit angel = Units.Units.GetUnit("angel");
Unit skeleton = Units.Units.GetUnit("skeleton");
UnitsStack stack1 = new UnitsStack(angel, 10);
UnitsStack stack2 = new UnitsStack(angel, 5);
UnitsStack stack3 = new UnitsStack(skeleton, 42);
List <UnitsStack> stacks = new List <UnitsStack> {
stack1, stack2, stack3
};
Army baseArmy = new Army(stacks);
BattleArmy army = new BattleArmy(baseArmy, null);
IList <BattleUnitsStack> angels = army.GetStacksByUnit(angel);
IList <BattleUnitsStack> skeletons = army.GetStacksByUnit(skeleton);
Assert.AreEqual(2, angels.Count);
Assert.AreEqual(stack1, angels[0].GetBaseStack());
Assert.AreEqual(stack2, angels[1].GetBaseStack());
Assert.AreEqual(1, skeletons.Count);
Assert.AreEqual(stack3, skeletons[0].GetBaseStack());
}
public static void refreshState(BattleArmy battelArmy)
{
foreach (BattleTeam _team in battelArmy.ActorList)
{
refreshState(_team);
BattleRecordHelper.recordTeamBuffState(_team);
}
}
public void fill(BattleArmy a1)
{
a = a1;
for (int i = 0; i < a.Length(); i++)
{
gameObject.transform.GetChild(i).GetComponent <uBattleUnitsStack>().fill(a.getBUS(i));
}
}
public static void ShowArmies(BattleArmy a, BattleArmy b, Battle battle, BattleUnitsStack curstack)
{
Console.WriteLine("-------------------------------------------");
for (int i = 0; i < 9; i++)
{
BattleUnitsStack ast = null;
BattleUnitsStack bst = null;
string astack = "---";
if (a.StackCount > i)
{
ast = a.Stacks[i];
astack = ast.CurrentUnit.Name + " C:" + ast.Count + " HP:" + ast.HitPoint.ToString() + "/" + ast.CurrentUnit.HitPoint.ToString() + " R:" +
ast.CurrentUnit.Resistance;
}
string bstack = "---";
if (b.StackCount > i)
{
bst = b.Stacks[i];
bstack = bst.CurrentUnit.Name + " C:" + bst.Count + " HP:" + bst.HitPoint.ToString() + "/" + bst.CurrentUnit.HitPoint.ToString() + " R:" +
bst.CurrentUnit.Resistance;
}
if (ast != null && ast == curstack)
{
Console.ForegroundColor = ConsoleColor.Yellow;
}
Console.Write("{0}) {1,-50} ", i, astack);
Console.ForegroundColor = ConsoleColor.White;
if (bst != null && bst == curstack)
{
Console.ForegroundColor = ConsoleColor.Yellow;
}
Console.Write("{0}) {1}\n", i + 9, bstack);
Console.ForegroundColor = ConsoleColor.White;
}
Console.WriteLine("-------------------------------------------");
Console.WriteLine("{0,-5} {1,-40} {2,-5} {3}", "Ini", "active", "Ini", "waiting");
for (int i = 0; i < 9; i++)
{
string astack = "---";
double ai = -0;
if (battle.ActiveQueue.Count > i)
{
ai = battle.ActiveQueue[i].CurrentUnit.Initiative;
astack = battle.ActiveQueue[i].CurrentUnit.Name;
}
string bstack = "---";
double bi = -0;
if (battle.WaitingQueue.Count > i)
{
bi = battle.WaitingQueue[i].CurrentUnit.Initiative;
bstack = battle.WaitingQueue[i].CurrentUnit.Name;
}
Console.WriteLine("{0:0.00} {1,-40} {2:0.00} {3}", ai, astack, bi, bstack);
}
Console.WriteLine("-------------------------------------------");
}
public void DoAttackTurn(BattleArmy enemy)
{
this.enemy = enemy;
//enemy.overworldBattleView.PlayAttackAndCallbackWhenDone(EndAttack);
int damage = (int)((size * dangerRating) - enemy.defences);
enemy.size -= damage;
enemy.overworldBattleView.PlayAttackAndCallbackWhenDone(EndAttack, damage);
}
internal BattleHelper(Player firstPlayer, Player secondPlayer)
{
_firstPlayer = firstPlayer;
_secondPlayer = secondPlayer;
_firstArmy = new BattleArmy(_firstPlayer.Army);
_secondArmy = new BattleArmy(_secondPlayer.Army);
OnNextTurn();
}
public ArmyComponent(BattleArmy army, Microsoft.Xna.Framework.Game game)
: base(game)
{
_army = army;
SetChildren(army.GetStacks().Select(stack => new UnitsStackComponent(stack, game)));
UpdatePositionsAndSize();
}
public Army(BattleArmy army)
{
var list = new List <UnitStack>();
army.Stacks.ForEach(
stack =>
{
if (stack.IsStackAlive)
{
list.Add(new UnitStack(stack.Unit, stack.Number));
}
}
);
_stacks = list;
}
public void MainInfo(List <BattleUnitStack> queue, BattleArmy BLUE, BattleArmy RED)
{
Console.Clear();
int BLUEcount = BLUE.Description.Count;
int REDcount = RED.Description.Count;
int max = Math.Max(BLUEcount, REDcount);
string str1 = "";
string str2 = "";
string write = "";
double Alive;
for (int i = 0; i < max; i++)
{
str1 = "";
str2 = "";
if (i < BLUEcount)
{
Alive = (double)BLUE.Description[i].curHitPoints / BLUE.Description[i].minion.HitPoints;
Alive = Math.Ceiling(Alive);
str1 = $"{BLUE.Description[i].ID}:{BLUE.Description[i].minion.Type}:{Alive}";
}
if (i < REDcount)
{
Alive = (double)RED.Description[i].curHitPoints / RED.Description[i].minion.HitPoints;
Alive = Math.Ceiling(Alive);
str2 = $"{RED.Description[i].ID}:{RED.Description[i].minion.Type}:{Alive}";
}
write = String.Format("{0} {1}", str1.PadRight(20), str2.PadRight(20));
Console.WriteLine(write);
}
//Console.Clear();
Console.WriteLine("v - you're here");
ShowQueue(queue);
Console.WriteLine("//////////LOG//////////");
Log log = Log.getInstance();
string[] lines = log.sb.ToString().Split('\n');
Console.WriteLine(lines[lines.Length - 4]);
Console.WriteLine(lines[lines.Length - 3]);
Console.WriteLine(lines[lines.Length - 2]);
Console.WriteLine("///////////////////////");
Console.WriteLine();
}
public void BattleArmy_ContainsStack()
{
Unit angel = new UnitAngel();
Unit skeleton = new UnitSkeleton();
UnitsStack stack1 = new UnitsStack(angel, 10);
UnitsStack stack2 = new UnitsStack(skeleton, 42);
List <UnitsStack> stacks = new List <UnitsStack> {
stack1, stack2
};
Army baseArmy = new Army(stacks);
BattleArmy army = new BattleArmy(baseArmy, null);
BattleUnitsStack stack3 = new BattleUnitsStack(new UnitsStack(skeleton, 42), army);
army.AddStack(stack3);
Assert.IsTrue(army.ContainsStack(stack3));
}
public Form3(BattleArmy attackedArmy, bool wiz)
{
InitializeComponent();
if (!wiz)
{
foreach (var stack in attackedArmy.StacksList)
{
if (stack.IsAlive)
{
this.comboBox1.Items.Add(stack);
}
}
}
else
{
foreach (var stack in attackedArmy.StacksList)
{
this.comboBox1.Items.Add(stack);
}
}
}
public void CreateBattleArmy()
{
Unit angel = new UnitAngel();
Unit skeleton = new UnitSkeleton();
UnitsStack stack1 = new UnitsStack(angel, 10);
UnitsStack stack2 = new UnitsStack(skeleton, 42);
List <UnitsStack> stacks = new List <UnitsStack> {
stack1, stack2
};
Army baseArmy = new Army(stacks);
BattleArmy army = new BattleArmy(baseArmy, null);
Assert.AreEqual(baseArmy, army.GetBaseArmy());
Assert.IsNull(army.GetBattle());
Assert.AreEqual(stack1, army.GetBaseArmy().GetStacks()[0]);
Assert.AreEqual(stack2, army.GetBaseArmy().GetStacks()[1]);
Assert.AreEqual(stack1, army.GetStack(0).GetBaseStack());
Assert.AreEqual(stack2, army.GetStack(1).GetBaseStack());
}
public void BattleArmy_RemoveStack()
{
Unit angel = new UnitAngel();
Unit skeleton = new UnitSkeleton();
UnitsStack stack1 = new UnitsStack(angel, 10);
UnitsStack stack2 = new UnitsStack(skeleton, 42);
List <UnitsStack> stacks = new List <UnitsStack> {
stack1, stack2
};
Army baseArmy = new Army(stacks);
BattleArmy army = new BattleArmy(baseArmy, null);
BattleUnitsStack stack = army.GetStack(0);
Assert.AreEqual(2, army.GetStacks().Count);
Assert.IsTrue(army.RemoveStack(stack));
Assert.AreEqual(1, army.GetStacks().Count);
Assert.IsFalse(army.RemoveStack(stack));
}
public Battle(ArmyClass initBLUE, ArmyClass initRED)
{
Log log = Log.getInstance();
log.sb.AppendLine($"Begin construction of battle");
BLUE = new BattleArmy(initBLUE);
foreach (BattleUnitStack u in BLUE.Description)
{
u.setID(setID);
setID = setID + 1;
u.setSide("BLUE");
u.setCounter(1);
u.setIsWaited(0);
u.setSpell(u.minion.HasSpell);
}
log.sb.AppendLine($"Blue army created");
RED = new BattleArmy(initRED);
foreach (BattleUnitStack u in RED.Description)
{
u.setID(setID);
setID = setID + 1;
u.setSide("RED");
u.setCounter(1);
u.setIsWaited(0);
u.setSpell(u.minion.HasSpell);
}
log.sb.AppendLine($"Red army created");
SaveBLUE = initBLUE;
SaveRED = initRED;
ArmyQueue.AddRange(BLUE.Description);
ArmyQueue.AddRange(RED.Description);
ArmyQueue.Sort(Compare);
effect = new EffectTool(ArmyQueue, this);
log.sb.AppendLine($"Start game loop");
GameLoop();
log.sb.AppendLine($"Change armies");
ChangeArmies();
}
void CheckForInteraction()
{
RaycastHit2D rh2d = Physics2D.Raycast(((Vector2)transform.position + oM.raycastOffset), direction, .5f, mask);
if (rh2d.transform != null)
{
if (rh2d.transform.gameObject.layer == LayerMask.NameToLayer("BattlePC"))
{
BattleDef newBattle = GetComponent <EncounterRoller>().RollEncounter(tempArmyDangerZone);
if (newBattle != null)
{
//returnPosition = transform.position;
newBattle.pcsInBattle = PartyManager.curParty.partyMembers;
battleStarter.GetComponent <BattleStarter>().TurnOnBattleScene(newBattle);
}
EndTurn();
//Start special battle
}
else if (rh2d.transform.gameObject.layer == LayerMask.NameToLayer("Settlement"))
{
this.enabled = false;
BattleArmy enemyBattleArmy = rh2d.transform.gameObject.GetComponent <BattleArmy>();
BattleArmy thisBattleArmy = GetComponent <BattleArmy>();
thisBattleArmy.DoAttackTurn(enemyBattleArmy);
enemyBattleArmy.DoAttackTurn(thisBattleArmy);
EndTurn();
//Resolve 1 round of strategic battle
}
else if (rh2d.transform.gameObject.layer == army.value)
{
EndTurn();
//Resolve 1 round of strategic battle
}
}
}
public void OnNextTurn()
{
if (_currentPlayer == null || _currentPlayer.Equals(_secondPlayer))
{
_currentPlayer = _firstPlayer;
_currentArmy = _firstArmy;
_enemyStacks = _secondArmy.Stacks;
}
else
{
_currentPlayer = _secondPlayer;
_currentArmy = _secondArmy;
_enemyStacks = _firstArmy.Stacks;
}
Config.Logger.LogMessage($"{_currentPlayer.Name}'s turn");
foreach (var stack in _currentArmy.Stacks)
{
stack.OnNextTurn();
}
_queue = new BattleQueue(_currentArmy.Stacks);
}
public void BattleArmy_AddStack()
{
Unit angel = new UnitAngel();
Unit skeleton = new UnitSkeleton();
UnitsStack stack1 = new UnitsStack(angel, 10);
UnitsStack stack2 = new UnitsStack(angel, 5);
List <UnitsStack> stacks = new List <UnitsStack> {
stack1, stack2
};
Army baseArmy = new Army(stacks);
BattleArmy army = new BattleArmy(baseArmy, null);
BattleUnitsStack stack3 = new BattleUnitsStack(new UnitsStack(skeleton, 42), army);
BattleUnitsStack stack4 = new BattleUnitsStack(new UnitsStack(skeleton, 42), army);
BattleUnitsStack stack5 = new BattleUnitsStack(new UnitsStack(skeleton, 42), army);
BattleUnitsStack stack6 = new BattleUnitsStack(new UnitsStack(skeleton, 42), army);
BattleUnitsStack stack7 = new BattleUnitsStack(new UnitsStack(skeleton, 42), army);
BattleUnitsStack stack8 = new BattleUnitsStack(new UnitsStack(skeleton, 42), army);
BattleUnitsStack stack9 = new BattleUnitsStack(new UnitsStack(skeleton, 42), army);
BattleUnitsStack stack10 = new BattleUnitsStack(new UnitsStack(skeleton, 42), army);
Assert.AreEqual(2, army.GetStacks().Count);
army.AddStack(stack3);
Assert.AreEqual(3, army.GetStacks().Count);
Assert.AreEqual(stack3, army.GetStack(2));
army.AddStack(stack4);
army.AddStack(stack5);
army.AddStack(stack6);
army.AddStack(stack7);
army.AddStack(stack8);
army.AddStack(stack9);
Assert.AreEqual(9, army.GetStacks().Count);
Assert.Throws <ArgumentOutOfRangeException>(() => army.AddStack(stack10));
}
public void ArmyFromBattle(BattleArmy army) => Army = new Army(army);
public void UpdateStrengthDisplay(BattleArmy bA)
{
sizeTM.text = bA.size.ToString();
damageRatingTM.text = bA.dangerRating.ToString();
defencesTM.text = bA.defences.ToString();
}
public virtual bool Spell(BattleUnitStack me, BattleArmy red, BattleArmy blue)
{
return(true);
} //define your side yourself
public override BattleArmy createSceneBattleArmy()
{
BattleArmy _army = new BattleArmy(Battle);
_army.addActor(MonsterTeam);
_army.addActor(attackerTeam());
return _army;
}
public static void Main()
{
Army army1 = new Army();
BuildArmy(army1, "Army 1");
Army army2 = new Army();
BuildArmy(army2, "Army 2");
BattleArmy battleArmy0 = new BattleArmy(army1);
BattleArmy battleArmy1 = new BattleArmy(army2);
Battle battle = new Battle(battleArmy0, battleArmy1);
while (battle.CheckGameOver() != true)
{
BattleUnitsStack cur_stack = battle.GetNextStack();
ShowArmies(battleArmy0, battleArmy1, battle, cur_stack);
if (cur_stack.Army == battleArmy0)
{
Console.WriteLine("Next unit from {2}: {0} - {1}", cur_stack.CurrentUnit.Name, cur_stack.Count, "Army 1");
}
if (cur_stack.Army == battleArmy1)
{
Console.WriteLine("Next unit from {2}: {0} - {1}", cur_stack.CurrentUnit.Name, cur_stack.Count, "Army 2");
}
if (cur_stack.GetEffects().Count > 0)
{
foreach (var e in cur_stack.GetEffects())
{
Console.WriteLine(e.ToStr());
}
}
Console.WriteLine("You can do:");
Console.WriteLine("0 target - Attack");
Console.WriteLine("1 - Wait");
Console.WriteLine("2 - Defend");
if (cur_stack.GetSpells().Count > 0)
{
int i = 3;
foreach (var e in cur_stack.GetSpells())
{
Console.WriteLine("{0} - {1}", i++, e.ToStr());
}
}
Console.WriteLine("GIVEUP - Give Up");
string com = Console.ReadLine();
while (com == "")
{
com = Console.ReadLine();
}
Console.WriteLine("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
if (com[0] == '0')
{
string[] args = com.Split(' ');
int target_id = 0;
if (args.Length != 2 || !int.TryParse(args[1], out target_id) || target_id < 0 || target_id >= 18)
{
Error("Invalid format");
continue;
}
else
{
BattleUnitsStack target;
if (target_id >= 9 && battleArmy1.StackCount > (target_id - 9))
{
target = battleArmy1.Stacks[target_id - 9];
}
else if (target_id <= 8 && battleArmy0.StackCount > (target_id))
{
target = battleArmy0.Stacks[target_id];
}
else
{
Error("Invalid format");
continue;
}
battle.Attack(cur_stack, target, cur_stack.CurrentUnit.MeleeDamager);
}
}
else if (com[0] == '1')
{
battle.Wait(cur_stack);
}
else if (com[0] == '2')
{
battle.Defend(cur_stack);
}
else if (com == "giveup")
{
battle.GiveUp(cur_stack.Army);
}
else
{
int[] args = ParseComand(com);
if (args == null)
{
Error("Invalid format");
continue;
}
List <int> targs = new List <int>(args);
targs.RemoveAt(0);
BattleUnitsStack[] targets = getStackByID(targs.ToArray(), battle);
if (targets == null)
{
continue;
}
if (cur_stack.GetSpells().Count > args[0] - 3)
{
try {
IAbility ability = cur_stack.GetSpells()[args[0] - 3];
battle.ApplySpell(ability, cur_stack, targets);
}
catch (Exception e)
{
Error(e.Message);
}
}
else
{
Error("Invalid format");
}
}
battle.RemoveDead();
}
}
private void Awake()
{
Map m;
BattleArmy a1;
BattleArmy a2;
string[] MapBits = PlayerPrefs.GetString("Map").Split(' ');
string[] Army1Bits = PlayerPrefs.GetString("Army1").Split(' ');
string[] Army2Bits = PlayerPrefs.GetString("Army2").Split(' ');
int h = Convert.ToInt32(MapBits[0]);
int w = Convert.ToInt32(MapBits[1]);
int a1Size = Convert.ToInt32(Army1Bits[0]);
int a2Size = Convert.ToInt32(Army2Bits[0]);
UnitsStack[] A1 = new UnitsStack[a1Size];
UnitsStack[] A2 = new UnitsStack[a2Size];
for (int z = 1, i = 0; i < a1Size; i++, z++)
{
if (Army1Bits[z].Equals("0"))
{
A1[i] = null;
}
else
{
A1[i] = new UnitsStack(new Unit(Army1Bits[z + 1]), Convert.ToInt32(Army1Bits[z]));
z++;
}
}
for (int z = 1, i = 0; i < a2Size; i++, z++)
{
if (Army2Bits[z].Equals("0"))
{
A2[i] = null;
}
else
{
A2[i] = new UnitsStack(new Unit(Army2Bits[z + 1]), Convert.ToInt32(Army2Bits[z]));
z++;
}
}
a1 = new BattleArmy(true, A1);
a2 = new BattleArmy(false, A2);
m = new Map(h, w);
map = GameObject.FindWithTag("Map");
army1 = GameObject.FindWithTag("Units1");
army2 = GameObject.FindWithTag("Units2");
for (int i = 0; i < h; i++)
{
for (int j = 0; j < w; j++)
{
var cellClone = Instantiate(CellPrefab, map.transform);
cellClone.transform.name = "Cell(" + (i + 1) + "," + (j + 1) + ")";
char bit = MapBits[2][i * w + j];
m.setMapCell(i, j, bit == '1' ? CellContent.STONE : CellContent.FREE);
}
}
foreach (BattleUnitsStack bus in a1.getcArmy())
{
int i = bus.getcPos().getX;
int j = bus.getcPos().getY;
var busClone = Instantiate(BUSPrefab, army1.transform);
busClone.GetComponent <RectTransform>().localPosition = getPos(i, j);
m.setMapCell(i, j, CellContent.UNIT1);
}
foreach (BattleUnitsStack bus in a2.getcArmy())
{
int i = bus.getcPos().getX;
int j = bus.getcPos().getY;
var busClone = Instantiate(BUSPrefab, army2.transform);
busClone.GetComponent <RectTransform>().localPosition = getPos(i, j);
m.setMapCell(i, j, CellContent.UNIT2);
}
map.GetComponent <uMap>().fill(m);
army1.GetComponent <uBattleArmy>().fill(a1);
army2.GetComponent <uBattleArmy>().fill(a2);
battle = new Battle(a1, a2, m);
activeBUS = battle.Begin(true);
map.GetComponent <uMap>().Recolor();
activeSpell = -1;
SpellsMenu.GetComponent <BattleMenu>().RefreshSpells(activeBUS);
}
public SurrenderCommand(BattleArmy source)
{
_source = source;
}
