public void GameInvalidReAssignmentTest()
{
WarPlayer target = new WarPlayer();
target.Game = new MockWarGame(WarGameState.AtBattle);
target.Game = new MockWarGame(WarGameState.AtBattle);
Assert.Fail();
}
public void CardsTest()
{
WarPlayer target = new WarPlayer(); // TODO: Initialize to an appropriate value
CardList actual = target.Cards;
Assert.IsNotNull(actual);
Assert.AreEqual(0, actual.Count);
}
public void CardsTest()
{
WarPlayer target = new WarPlayer(); // TODO: Initialize to an appropriate value
CardList actual = target.Cards;
Assert.IsNotNull(actual);
Assert.AreEqual(0, actual.Count);
}
public void GameInvalidReAssignmentTest()
{
WarPlayer target = new WarPlayer();
target.Game = new MockWarGame(WarGameState.AtBattle);
target.Game = new MockWarGame(WarGameState.AtBattle);
Assert.Fail();
}
public void GameProperReAssignmentTest()
{
WarPlayer target = new WarPlayer();
AbstractWarGame expected = new MockWarGame(WarGameState.AtBattle);
target.Game = new MockWarGame(WarGameState.AtBattle);
target.Game = null;
target.Game = expected;
Assert.AreEqual(expected, target.Game);
}
public void GameSimpleAssignmentTest()
{
WarPlayer target = new WarPlayer(); // TODO: Initialize to an appropriate value
AbstractWarGame expected = new MockWarGame(WarGameState.AtBattle);
AbstractWarGame actual = expected;
target.Game = expected;
actual = target.Game;
Assert.AreEqual(expected, actual);
}
public void NameTest()
{
WarPlayer target = new WarPlayer();
const string expected = "James";
target.Name = expected;
string actual = target.Name;
Assert.AreEqual(expected, actual);
}
public void GameProperReAssignmentTest()
{
WarPlayer target = new WarPlayer();
AbstractWarGame expected = new MockWarGame(WarGameState.AtBattle);
target.Game = new MockWarGame(WarGameState.AtBattle);
target.Game = null;
target.Game = expected;
Assert.AreEqual(expected, target.Game);
}
public void PlayGameOverTest()
{
WarPlayer target = new WarPlayer();
target.Cards.AddRange(CardList.CreateDeck());
MockWarGame warGame = new MockWarGame(WarGameState.GameOver);
target.Game = warGame;
target.Play();
warGame.AssertCallCounts();
}
public void PlayWarDeclaredTest()
{
WarPlayer target = new WarPlayer();
target.Cards.AddRange(CardList.CreateDeck());
MockWarGame warGame = new MockWarGame(WarGameState.WarDeclared);
target.Game = warGame;
target.Play();
warGame.AssertCallCounts(playerGoToWar: 1);
}
public void PlayAtBattleTest()
{
WarPlayer target = new WarPlayer(); // TODO: Initialize to an appropriate value
target.Cards.AddRange(CardList.CreateDeck());
MockWarGame warGame = new MockWarGame(WarGameState.AtBattle);
target.Game = warGame;
target.Play();
warGame.AssertCallCounts(playerBattle: 1);
}
public void PlayWithoutCardsTest()
{
WarPlayer target = new WarPlayer(); // TODO: Initialize to an appropriate value
MockWarGame warGame = new MockWarGame(WarGameState.AtBattle);
target.Game = warGame;
target.Play();
warGame.AssertCallCounts(
playerBattle: 1,
playerGoToWar: 0,
playerPickWarAttack: 0);
}
public void resetGame()
{
GameArea.Visibility = Visibility.Hidden;
player1 = null;
player2 = null;
player1Win = false;
player2Win = false;
warBattleCards.Clear();
deck = new Deck();
GameArea = grid;
GameModeSelection.Visibility = Visibility.Visible;
}
public void PlayAtWarBattleTest()
{
WarPlayer target = new WarPlayer();
target.Cards.AddRange(CardList.CreateDeck());
MockWarGame warGame = new MockWarGame(WarGameState.WarDeclared);
target.Game = warGame;
target.Play();
warGame.SetGameState(WarGameState.AtWar);
target.Play();
warGame.AssertCallCounts(playerGoToWar: 1, playerPickWarAttack: 1, lastAttackIndex: 2);
}
public void PlayerBattle_FailesWithoutCards()
{
WarPlayer[] players = new WarPlayer[] {
new WarPlayer()
{
Name = "Player 1"
}
};
var target = new WarGame(players);
target.PlayerBattle(players[0]);
Assert.Fail();
}
private void StartGameBtn_Click(object sender, RoutedEventArgs e)
{
GameModeSelection.Visibility = Visibility.Hidden;
GameArea.Visibility = Visibility.Visible;
player1 = new WarPlayer(Player1Name.Text, false);
if ((bool)AICheckBox.IsChecked)
{
player2 = new WarPlayer("Computer", true);
}
else
{
player2 = new WarPlayer(Player2Name.Text, false);
}
deck = new Deck();
deck.Shuffle();
DeckManager();
Player1Details.Content = player1.ToString();
Player2Details.Content = player2.ToString();
}
public void PlayerPickWarAttackTwiceTest()
{
WarPlayer[] players = new WarPlayer[] {
new WarPlayer()
{
Name = "Player 1"
}
};
players[0].Cards.Add(Card.TwoOfDiamonds);
players[0].Cards.Add(Card.ThreeOfDiamonds);
players[0].Cards.Add(Card.FourOfDiamonds);
WarGame target = new WarGame(players);
target.PlayerDeclareWar(players[0]);
target.PlayerPickWarAttack(players[0], 1);
target.PlayerPickWarAttack(players[0], 1);
Assert.Fail();
}
public void LoadGame(WarSave newGame)
{
player1 = newGame.Players[0];
player2 = newGame.Players[1];
for (int i = 0; i < player1.Hand.Count(); i++)
{
player1.Hand[i].LoadCard();
}
for (int i = 0; i < player2.Hand.Count(); i++)
{
player2.Hand[i].LoadCard();
}
deck = newGame.Deck;
Player1Details.Content = player1.ToString();
Player2Details.Content = player2.ToString();
GameModeSelection.Visibility = Visibility.Hidden;
GameArea.Visibility = Visibility.Visible;
Uri resourceUri = new Uri($"{player1.Hand[0].CardImage}", UriKind.Relative);
Player1CurrentCard.Source = new BitmapImage(resourceUri);
resourceUri = new Uri($"{player2.Hand[0].CardImage}", UriKind.Relative);
Player2CurrentCard.Source = new BitmapImage(resourceUri);
}
internal override Card PlayerBattle(WarPlayer player)
{
count_PlayerBattle++;
return player.Cards.DealTo(_DealtCards);
}
public void PlayGameOverTest()
{
WarPlayer target = new WarPlayer();
target.Cards.AddRange(CardList.CreateDeck());
MockWarGame warGame = new MockWarGame(WarGameState.GameOver);
target.Game = warGame;
target.Play();
warGame.AssertCallCounts();
}
public void GameSimpleAssignmentTest()
{
WarPlayer target = new WarPlayer(); // TODO: Initialize to an appropriate value
AbstractWarGame expected = new MockWarGame(WarGameState.AtBattle);
AbstractWarGame actual = expected;
target.Game = expected;
actual = target.Game;
Assert.AreEqual(expected, actual);
}
internal override Card PlayerPickWarAttack(WarPlayer player, int attackIndex)
{
//
// Pre conditions
if (!battleTracker.PlayerAttacks.Keys.Contains(player))
throw new InvalidOperationException("Cannot go to war without having attacked first.");
if (!battleTracker.ActiveWars.ContainsKey(player) || battleTracker.ActiveWars[player].Count == 0)
throw new InvalidOperationException(String.Format("{0} has not declared war.", player.Name));
if (battleTracker.ActiveAttacks.ContainsKey(player))
throw new InvalidOperationException(String.Format("{0} already has an active attack.", player.Name));
RequireGameState(WarGameState.AtWar);
//
// Validate attack index
const int maxIndex = NumberOfCardsToDealForWar - 1;
if ((attackIndex == -1) && (player.Cards.Count == 0))
//
// Player is out of cards, default to last attack.
{
var lastAttachIndex = battleTracker.PlayerAttacks[player].Count - 1;
var defactoResult = battleTracker.PlayerAttacks[player][lastAttachIndex];
battleTracker.ActiveAttacks[player] = defactoResult;
return defactoResult;
}
else if (attackIndex > maxIndex || attackIndex < 0)
throw new ArgumentOutOfRangeException("attackIndex",
String.Format("Index must be from 0 to {0} (was {1})", maxIndex, attackIndex));
//
// Activate the selected attack
var wars = battleTracker.ActiveWars[player];
var warCards = wars[wars.Count - 1];
var result = warCards[attackIndex];
battleTracker.ActiveAttacks[player] = result;
Debug.WriteLine(String.Format("{0} went to war with the {1}", player.Name, result));
return result;
}
internal override Card PlayerBattle(WarPlayer player)
{
Debug.Assert(battleTracker.PlayerAttacks.Keys.Contains(player), "Player is not part of game.");
this.RequireGameState(WarGameState.AtBattle, WarGameState.NewGame);
var result = player.Cards.DealTo(battleTracker.PlayerAttacks[player]);
battleTracker.ActiveAttacks[player] = result;
Debug.WriteLine(String.Format("{0} went to battle with the {1}", player.Name, result));
return result;
}
/// <summary>
/// Deals three cards (or players remaining cards, if fewer than three) for war.
/// </summary>
/// <param name="player">Specifies the player going to war.</param>
/// <returns>The number of cards dealt for the war.</returns>
internal override int PlayerDeclareWar(WarPlayer player)
{
//
// Pre conditions
if (!battleTracker.PlayerAttacks.Keys.Contains(player))
throw new InvalidOperationException("Cannot declare war without having attacked first.");
RequireGameState(WarGameState.WarDeclared);
//
// Deactivate active attack
battleTracker.ActiveAttacks.Remove(player);
if (!battleTracker.ActiveWars.ContainsKey(player))
battleTracker.ActiveWars[player] = new List<CardList>();
battleTracker.ActiveWars[player].Add(new CardList(NumberOfCardsToDealForWar));
var warIndex = battleTracker.ActiveWars[player].Count - 1;
//
// Deal cards to "declare war"
var result = 0;
for (var i = 1; i <= NumberOfCardsToDealForWar && player.Cards.Count > 0; i++)
{
var card = player.Cards.DealTo(battleTracker.PlayerAttacks[player]);
battleTracker.ActiveWars[player][warIndex].Add(card);
result++;
}
Debug.Assert(result <= NumberOfCardsToDealForWar, "Did not deal enough war cards.");
Debug.Assert(!battleTracker.ActiveAttacks.ContainsKey(player), "Player has invalid attack.");
Debug.WriteLine(player.Name + " declared war!");
return result;
}
internal override int PlayerDeclareWar(WarPlayer player)
{
count_PlayerGoToWar++;
return(3);
}
internal override Card PlayerPickWarAttack(WarPlayer player, int attackIndex)
{
count_PlayerPickWarAttack++;
value_lastAttackIndex = attackIndex;
return(Card.EightOfSpades);
}
internal override Card PlayerPickWarAttack(WarPlayer player, int attackIndex)
{
count_PlayerPickWarAttack++;
value_lastAttackIndex = attackIndex;
return Card.EightOfSpades;
}
internal override Card PlayerBattle(WarPlayer player)
{
count_PlayerBattle++;
return(player.Cards.DealTo(_DealtCards));
}
internal override int PlayerDeclareWar(WarPlayer player)
{
count_PlayerGoToWar++;
return 3;
}
public void PlayWarDeclaredTest()
{
WarPlayer target = new WarPlayer();
target.Cards.AddRange(CardList.CreateDeck());
MockWarGame warGame = new MockWarGame(WarGameState.WarDeclared);
target.Game = warGame;
target.Play();
warGame.AssertCallCounts(playerGoToWar: 1);
}
public void PlayAtWarBattleTest()
{
WarPlayer target = new WarPlayer();
target.Cards.AddRange(CardList.CreateDeck());
MockWarGame warGame = new MockWarGame(WarGameState.WarDeclared);
target.Game = warGame;
target.Play();
warGame.SetGameState(WarGameState.AtWar);
target.Play();
warGame.AssertCallCounts(playerGoToWar:1, playerPickWarAttack:1, lastAttackIndex:2);
}
public void PlayAtBattleTest()
{
WarPlayer target = new WarPlayer(); // TODO: Initialize to an appropriate value
target.Cards.AddRange(CardList.CreateDeck());
MockWarGame warGame = new MockWarGame(WarGameState.AtBattle);
target.Game = warGame;
target.Play();
warGame.AssertCallCounts(playerBattle:1);
}
internal abstract int PlayerDeclareWar(WarPlayer player);
internal abstract Card PlayerBattle(WarPlayer player);
public void PlayWithoutCardsTest()
{
WarPlayer target = new WarPlayer(); // TODO: Initialize to an appropriate value
MockWarGame warGame = new MockWarGame(WarGameState.AtBattle);
target.Game = warGame;
target.Play();
warGame.AssertCallCounts(
playerBattle: 1,
playerGoToWar: 0,
playerPickWarAttack: 0);
}
internal abstract Card PlayerPickWarAttack(WarPlayer player, int attackIndex);
public void NameTest()
{
WarPlayer target = new WarPlayer();
const string expected = "James";
target.Name = expected;
string actual = target.Name;
Assert.AreEqual(expected, actual);
}
