public HearthstoneBoard copy()
{
HearthstoneBoard board = new HearthstoneBoard();
copyValuesTo(board);
return(board);
}
public HearthstoneBoard simulateResult()
{
HearthstoneBoard newBoard = this.copy();
newBoard.simulateResultNoCopy();
return(newBoard);
}
public static void performTest(Func <BoardSide, BoardSide, string> setUp)
{
ConsoleColor defaults = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Yellow;
HearthstoneBoard b = new HearthstoneBoard();
BoardSide b1 = new BoardSide();
BoardSide b2 = new BoardSide();
string testname = setUp(b1, b2);
Console.WriteLine("Starting test: " + testname + "!--------------------------------------------------");
Console.ForegroundColor = defaults;
b.p1Board = b1;
b.p2Board = b2;
try
{
b.printState();
Console.WriteLine("#####");
// b.printEvents = true;
List <HearthstoneBoard> res = b.simulateResults(10000);
var dmgdist = StatisticsManager.calculateDmgDistributions(res);
StatisticsManager.printReadableResult(dmgdist);
}
catch (ExceptionWithMessageWhyDoesntCSharpHaveItDeafaultComeOne e)
{
Console.WriteLine("An error occured when performing test " + testname + ". Message: " + e.message);
Console.ReadLine();
}
}
public override void doAction(Action cause, Card user, HearthstoneBoard board, List <Card> alwaysUse)
{
board.printDebugMessage("Performing action: make extra summon: " + user, HearthstoneBoard.OutputPriority.EFFECTTRIGGERS);
BoardSide userboard = board.getBoardFromMinion(user);
for (int i = 0; i < userboard.IndexOf(user); i++)
{
if (userboard[i].hasEffect(this))
{
return;
}
}
if (current < 1)
{
current = count;
}
else
{
Card c = ((CardSpawnedAction)cause).spawnedCard();
if (c == user)
{
return;
}
current--;
board.printDebugMessage("khadgar effect used, count is now " + current, HearthstoneBoard.OutputPriority.INTENSEDEBUG);
board.addNewMinionToBoard(board.getPlayerFromMinion(user), c.copy().setId(board.getRandomNumber(1, 9999)), board.getPositionFromMinion(c), true);
}
}
//0 = not dead, 1 = dead, 2 = overkill
public int dealDamage(int damage, HearthstoneBoard board)
{
if (divineShield)
{
foreach (Card c in board.getBoardFromMinion(this))
{
c.performedAction(new DivineShieldLossAction(this), board);
}
divineShield = false;
board.printDebugMessage("Damage taken: 0 (divine shield pop) on " + getReadableName(), HearthstoneBoard.OutputPriority.DAMAGES);
return(0);
}
hp = hp - damage;
board.printDebugMessage("Damage taken: " + damage + " on " + getReadableName(), HearthstoneBoard.OutputPriority.DAMAGES);
performedAction(new DamageTakenAction(), board);
if (hp <= 0)
{
board.addToPendingDeath(this);
if (hp < 0)
{
return(2);
}
else
{
return(1);
}
}
return(0);
}
public void makeUpForReaderError(HearthstoneBoard board)
{
foreach (Effect e in effects)
{
e.makeUpForReaderError(this, board);
}
}
public override void doAction(Action cause, Card user, HearthstoneBoard board, List <Card> alwaysUse)
{
board.printDebugMessage("Performing action: bomb deathrattle: " + user, HearthstoneBoard.OutputPriority.EFFECTTRIGGERS);
BoardSide opponentBoard = board.getOpponentBoardFromMinion(user);
List <Card> targets = new List <Card>();
for (int i = 0; i < times; i++)
{
if (opponentBoard.Count == 0)
{
return;
}
Card target = opponentBoard.getRandomCardAlive(board);
if (target == null)
{
return;
}
user.causeDamageToTarget(target, board, 4);
targets.Add(target);
}
foreach (Card c in targets)
{
c.deathCheck(board);
}
}
public bool doStartOfTurnEffect(HearthstoneBoard board)
{
board.printDebugMessage("Doing start of turn effect on board with count " + Count, HearthstoneBoard.OutputPriority.INTENSEDEBUG);
if (Count == 0)
{
return(false);
}
int c = 0;
while (c < Count)
{
if (this[c].attackPriority != Card.MAX_PRIORITY)
{
this[c].attackPriority = Card.MAX_PRIORITY;
if (this[c].hasStartofTurnEffect())
{
this[c].performedAction(new StartofCombatAction(), board);
board.deathCheck();
return(true);
}
}
c++;
}
return(false);
}
public static string testZapp(BoardSide b1, BoardSide b2, List <HearthstoneBoard> expected)
{
b1.Add(CardCreatorFactory.createFromName(CardCreatorFactory.Cards.ZappSlywick));
b2.Add(CardCreatorFactory.createFromName(CardCreatorFactory.Cards.DragonspawnLieutenant));
b2.Add(CardCreatorFactory.createFromName(CardCreatorFactory.Cards.DragonspawnLieutenant));
b2.Add(CardCreatorFactory.createFromName(CardCreatorFactory.Cards.BaronRivendare));
b2.Add(CardCreatorFactory.createFromName(CardCreatorFactory.Cards.BaronRivendare).setPoisonous(true));
HearthstoneBoard exp1 = new HearthstoneBoard();
exp1.p2Board = new BoardSide {
CardCreatorFactory.createFromName(CardCreatorFactory.Cards.DragonspawnLieutenant), CardCreatorFactory.createFromName(CardCreatorFactory.Cards.BaronRivendare)
};
expected.Add(exp1);
HearthstoneBoard exp2 = new HearthstoneBoard();
exp2.p2Board = new BoardSide {
CardCreatorFactory.createFromName(CardCreatorFactory.Cards.DragonspawnLieutenant)
};
expected.Add(exp2);
return("test zapp targeting");
}
public override void makeUpForReaderError(Card user, HearthstoneBoard board)
{
foreach (Card c in board.getAdjacents(user))
{
c.addAttack(-1);
}
}
public override void doAction(Action cause, Card user, HearthstoneBoard board, List <Card> alwaysUse)
{
board.printDebugMessage("Performing action: deathrattle dmg bonus: " + user, HearthstoneBoard.OutputPriority.EFFECTTRIGGERS);
BoardSide userBoard = board.getBoardFromMinion(user);
if (userBoard.Count == 1)
{
return;
}
for (int i = 0; i < times; i++)
{
while (true)
{
int target = board.getRandomNumber(0, userBoard.Count);
if (userBoard[target] != user)
{
board.printDebugMessage("Giving damage bonus to " + userBoard[target].getReadableName(), HearthstoneBoard.OutputPriority.INTENSEDEBUG);
userBoard[target].addAttack(user.getAttack(board));
break;;
}
}
}
}
public override void doAction(Action cause, Card user, HearthstoneBoard board, List <Card> alwaysUse)
{
board.printDebugMessage("Performing action: deathrattledivine: " + user, HearthstoneBoard.OutputPriority.EFFECTTRIGGERS);
BoardSide userBoard = board.getBoardFromMinion(user);
for (int i = 0; i < times; i++)
{
bool stop = true;
foreach (Card c in userBoard)
{
if (c != user && !c.divineShield)
{
board.printDebugMessage("Found minion without divine shield " + c.getReadableName(), HearthstoneBoard.OutputPriority.INTENSEDEBUG);
stop = false;
}
}
if (stop)
{
return;
}
while (true)
{
int target = board.getRandomNumber(0, userBoard.Count);
if (!userBoard[target].divineShield && userBoard[target] != user)
{
board.printDebugMessage("Giving divine shield to " + userBoard[target].getReadableName(), HearthstoneBoard.OutputPriority.INTENSEDEBUG);
userBoard[target].setDivineShield(true);
break;
}
}
}
}
public override void doAction(Action cause, Card user, HearthstoneBoard board, List <Card> alwaysUse)
{
board.printDebugMessage("Performing action: Adjacent + 1 from: " + user, HearthstoneBoard.OutputPriority.EFFECTTRIGGERS);
foreach (Card c in alwaysUse)
{
c.tempAttackBonus += 1;
}
}
public void performedAction(Action a, Card user, HearthstoneBoard board, List <Card> alwaysUse)
{
// board.printDebugMessage("Determining if action triggers effect (" +a.getName()+") on card: "+user.getReadableName(), HearthstoneBoard.OutputPriority.ALL);
if (triggerFromAction(a))
{
doAction(a, user, board, alwaysUse);
}
}
public bool compare(HearthstoneBoard board)
{
if (p1Board.Compare(board.p1Board, this, board) && p2Board.Compare(board.p2Board, this, board))
{
return(true);
}
return(false);
}
public void performedAction(Action a, HearthstoneBoard hearthstoneBoard)
{
hearthstoneBoard.printDebugMessage("Received action " + a.getName() + " on " + this.getReadableName(), HearthstoneBoard.OutputPriority.COMMUNICATION);
foreach (Effect e in effects)
{
e.performedAction(a, this, hearthstoneBoard, null);
}
}
public override void doAction(Action cause, Card user, HearthstoneBoard board, List <Card> alwaysUse)
{
board.printDebugMessage("Performing action: random dr summon: " + user, HearthstoneBoard.OutputPriority.EFFECTTRIGGERS);
for (int i = 0; i < times; i++)
{
board.addNewMinionToBoard(board.getPlayerFromMinion(user), getRandomCard(board).setAttackPriority(user.attackPriority), board.getPositionFromMinion(user) + i, true);
}
}
public override void doAction(Action cause, Card user, HearthstoneBoard board, List <Card> alwaysUse)
{
board.printDebugMessage("Performing action: deathrattlebuff: " + user.getReadableName(), HearthstoneBoard.OutputPriority.EFFECTTRIGGERS);
foreach (Card c in board.getBoardFromMinion(user))
{
c.addStats(buff, buff);
}
}
public override void doAction(Action cause, Card user, HearthstoneBoard board, List <Card> alwaysUse)
{
board.printDebugMessage("Performing action: deathrattlesummon: " + user, HearthstoneBoard.OutputPriority.EFFECTTRIGGERS);
for (int i = 0; i < count; i++)
{
board.addNewMinionToBoard(board.getPlayerFromMinion(user), CardCreatorFactory.createFromName(summon).setAttackPriority(user.attackPriority), board.getPositionFromMinion(user) + i, true);
}
}
public void deathCheck(HearthstoneBoard board)
{
board.printDebugMessage("Performing death check on " + getReadableName(), HearthstoneBoard.OutputPriority.COMMUNICATION);
if (!isAlive() && board.containsCard(this))
{
this.performedAction(new DeadAction(), board);
board.killOf(this);
}
}
public void performAdjacantEffects(Card middle, HearthstoneBoard hearthstoneBoard)
{
foreach (Effect e in effects)
{
e.performedAction(new AdjacentAction(), this, hearthstoneBoard, new List <Card> {
middle
});
}
}
public void performAttack(Card target, HearthstoneBoard board)
{
board.printDebugMessage("attacker: " + this.getReadableName() + " defender: " + target.getReadableName(), HearthstoneBoard.OutputPriority.ATTACKERS);
if (board.turnbyturn)
{
Console.WriteLine("--------------------------------------");
Console.WriteLine("Attacker: " + this.getReadableName());
Console.WriteLine("Defender: " + target.getReadableName());
Console.ReadLine();
}
if (board.stopFlag)
{
board.attacker = this;
board.defender = target;
board.finishedWorkFlag = true;
while (board.stopFlag)
{
Thread.Sleep(100);
}
board.finishedWorkFlag = false;
board.stopFlag = true;
}
this.performedAction(new AttackingAction(target), board);
int returnAttack = target.poisonous ? 9999999 : target.getAttack(board);
//target.dealDamage(getAttack(board), board);
causeDamageToTarget(target, board, getAttack(board));
if (this.dealDamage(returnAttack, board) > 0)
{
foreach (Card c in board.getBoardFromMinion(target))
{
c.performedAction(new GotKillAction(target), board);
}
}
board.deathCheck();
//target.deathCheck(board);
//this.deathCheck(board);
attackPriority = Card.MAX_PRIORITY;
board.printDebugMessage("attack perform finished from " + this.getReadableName() + " to " + target.getReadableName(), HearthstoneBoard.OutputPriority.ATTACKERS);
if (board.printPriority >= HearthstoneBoard.OutputPriority.ATTACKERS)
{
board.printState();
}
if (board.turnbyturn)
{
Console.WriteLine("--------------------------------------");
board.printState();
Console.ReadLine();
}
}
public static string testMinibotDivine(BoardSide b1, BoardSide b2, List <HearthstoneBoard> expected)
{
b1.Add(CardCreatorFactory.createFromName(CardCreatorFactory.Cards.ShieldedMinibot));
b2.Add(CardCreatorFactory.createFromName(CardCreatorFactory.Cards.VulgarHomunculus));
HearthstoneBoard exp1 = new HearthstoneBoard();
expected.Add(exp1);
return("test minibot divine");
}
public static string testCase2(BoardSide b1, BoardSide b2, List <HearthstoneBoard> expected)
{
b1.Add(CardCreatorFactory.createFromName(CardCreatorFactory.Cards.Mecharoo));
b2.Add(CardCreatorFactory.createFromName(CardCreatorFactory.Cards.DireWolfAlpha));
HearthstoneBoard exp1 = new HearthstoneBoard();
expected.Add(exp1);
return("Test 1");
}
public override void makeUpForReaderError(Card user, HearthstoneBoard board)
{
foreach (Card c in board.getBoardFromMinion(user))
{
if (c.typeMatches(type) && c != user)
{
c.addAttack(-dmg);
}
}
}
public bool hasAvailableAttackers(HearthstoneBoard board)
{
foreach (Card c in this)
{
if (c.getAttack(board) > 0)
{
return(true);
}
}
return(false);
}
public override void doAction(Action cause, Card user, HearthstoneBoard board, List <Card> alwaysUse)
{
board.printDebugMessage("Performing action: Mal'ganis hacky SoT effect " + user.getReadableName(), HearthstoneBoard.OutputPriority.EFFECTTRIGGERS);
foreach (Card c in board.getBoardFromMinion(user))
{
if (c != user && c.typeMatches(Card.Type.Demon))
{
c.addStats(buff, buff);
}
}
}
public override void doAction(Action cause, Card user, HearthstoneBoard board, List <Card> alwaysUse)
{
board.printDebugMessage("Performing action: cleave attack: " + user, HearthstoneBoard.OutputPriority.EFFECTTRIGGERS);
Card target = ((AttackingAction)cause).target;
var adj = board.getAdjacents(target);
foreach (Card c in adj)
{
user.causeDamageToTarget(c, board, user.getAttack(board));
}
}
public static string testJuggler(BoardSide b1, BoardSide b2, List <HearthstoneBoard> expected)
{
b1.Add(CardCreatorFactory.createFromName(CardCreatorFactory.Cards.Voidwalker));
b1.Add(CardCreatorFactory.createFromName(CardCreatorFactory.Cards.SoulJuggler));
b2.Add(CardCreatorFactory.createFromName(CardCreatorFactory.Cards.KaboomBot).setStats(3, 3));
HearthstoneBoard exp1 = new HearthstoneBoard();
expected.Add(exp1);
return("test soul juggler");
}
public static string testPoison(BoardSide b1, BoardSide b2, List <HearthstoneBoard> expected)
{
b1.Add(CardCreatorFactory.createFromName(CardCreatorFactory.Cards.Maexxna));
b2.Add(CardCreatorFactory.createFromName(CardCreatorFactory.Cards.Maexxna));
HearthstoneBoard exp1 = new HearthstoneBoard();
expected.Add(exp1);
return("test poison");
}
