public Game Construct()
{
Initialize();
GameObject gameHolder = new GameObject();
gameHolder.name = gameName;
gameHolder.transform.position = gameSetting.GridPosition;
List<IGroupPattern> groupPatterns = groupPatternConverter.Convert();
GameBuilder gameBuilder = new GameBuilder(gameHolder,
gameSetting,
particleSpawner,
blockColorRepository,
groupPatterns,
backgroundFactory,
cameraManager,
blockViewSpawner,
floatingTextRenderer);
Game game = gameBuilder.Build();
game.InitializeGrid();
return game;
}
static void Main(string[] args)
{
bool save = false;
GameBuilder builder = new GameBuilder();
if (save)
{
builder.AddPlayer("Roger", "INFO");
builder.AddPlayer("Bernard", "EII");
builder.SetSize("Small");
builder.UseDefaultFrequencies();
Game game = builder.Build();
game.Save("save01.dat");
}
else
{
Game game = builder.LoadGame("save01.dat");
//Console.Write(game.Map);
Console.WriteLine(game.CurrentPlayer);
Console.WriteLine(game.CurrentPlayer.Cities[0]);
game.NextTurn();
Console.WriteLine(game.CurrentPlayer);
Console.WriteLine(game.CurrentPlayer.Cities[0]);
game.Save("save01.dat");
}
}
public void Build_PopulatesMaxLives()
{
var builder = new GameBuilder();
var state = builder.Build(5, 6, 3, 5);
Assert.AreEqual(3, state.MaxLives);
}
public void GivenGameHasSnakeAtFourteen_WhenUserReachesFourteen_ThenUserShouldMoveToSeven()
{
//given
var gameBuilder = new GameBuilder();
var player = new Player
{
Place = 10
};
gameBuilder.AddPlayer(player);
var snake = new Snake(14, 7);
gameBuilder.AddJumper(snake);
var dice = new Mock <IDice>();
dice.Setup(d => d.Throw()).Returns(4);
gameBuilder.SetDice(dice.Object);
var game = gameBuilder.Build();
//when
var diceThrow = game.Play();
//then
game.Players.ToList()[0].Place.Should().Be(7);
}
public Game Construct()
{
Initialize();
GameObject gameHolder = new GameObject();
gameHolder.name = gameName;
gameHolder.transform.position = gameSetting.GridPosition;
List <IGroupPattern> groupPatterns = groupPatternConverter.Convert();
GameBuilder gameBuilder = new GameBuilder(gameHolder,
gameSetting,
particleSpawner,
blockColorRepository,
groupPatterns,
backgroundFactory,
cameraManager,
blockViewSpawner,
floatingTextRenderer);
Game game = gameBuilder.Build();
game.InitializeGrid();
return(game);
}
public void GivenPlayerHitsGreensSnakes_WhenPlayerAgainHitsSameSnake_ThenSnakeIsPowerless()
{
//given
var gameBuilder = new GameBuilder();
var player = new Player
{
Place = 10
};
gameBuilder.AddPlayer(player);
var snake = new GreenSnake(14, 10);
gameBuilder.AddJumper(snake);
var dice = new Mock <IDice>();
dice.Setup(d => d.Throw()).Returns(4);
gameBuilder.SetDice(dice.Object);
var game = gameBuilder.Build();
var diceThrow = game.Play();
//when
diceThrow = game.Play();
//then
player.Place.Should().Be(14);
}
public void GivenPrimeNumberRuleApplied_WhenPlayerLandsOnPrimeNumber_ThenPlayerSkipsATurn()
{
//given
var gameBuilder = new GameBuilder();
var player1 = new Player("p1")
{
Place = 10
};
var player2 = new Player("p2")
{
Place = 11
};
gameBuilder.AddPlayer(player1);
gameBuilder.AddPlayer(player2);
var dice = new Mock <IDice>();
dice.Setup(d => d.Throw()).Returns(3);
gameBuilder.SetDice(dice.Object);
gameBuilder.SetStrategy(new SkipOnPrimeNumberStrategy(new List <Player> {
player1, player2
}));
var game = gameBuilder.Build();
//when
game.CurrentPlayer.Id.Should().Be(player1.Id, "First player at game start");
game.Play();
game.CurrentPlayer.Id.Should().Be(player2.Id, "Player2 after player1");
game.Play();
game.CurrentPlayer.Id.Should().Be(player2.Id, "Player1 is on skip");
game.Play();
game.CurrentPlayer.Id.Should().Be(player1.Id, "player1 after player2");
//then
}
public void GetSummary_SomeGamesInProgress_ReturnedInProperOrder()
{
// Arrange
var game1 = GameBuilder.Build("Mexico", 0, "Canada", 5, 1);
service.ActiveGames.Add(game1);
var game2 = GameBuilder.Build("Spain", 10, "Brazil", 2, 2);
service.ActiveGames.Add(game2);
var game3 = GameBuilder.Build("Germany", 2, "France", 2, 3);
service.ActiveGames.Add(game3);
var game4 = GameBuilder.Build("Uruguay", 6, "Italy", 6, 4);
service.ActiveGames.Add(game4);
var game5 = GameBuilder.Build("Argentina", 3, "Australia", 1, 5);
service.ActiveGames.Add(game5);
// Act
var games = service.GetSummary().ToList();
// Assert
Assert.Equal(game4.Id, games[0].Id);
Assert.Equal(game2.Id, games[1].Id);
Assert.Equal(game1.Id, games[2].Id);
Assert.Equal(game5.Id, games[3].Id);
Assert.Equal(game3.Id, games[4].Id);
}
public void Build_InitializePlayerRow()
{
var builder = new GameBuilder();
var state = builder.Build(5, 6, 3, 5);
Assert.AreEqual(2, state.Player.Row);
}
public void Build_InitializePlayerColumn()
{
var builder = new GameBuilder();
var state = builder.Build(5, 6, 3, 5);
Assert.AreEqual(0, state.Player.Column);
}
public void TestEnemyAmongUsInitStrategy([Range(3, 15, 2)] int size)
{
var builder = new GameBuilder {
BoardSize = size,
Scenario = GameScenario.EnemyAmongUs
};
builder.PlayerBuilder1.Color = Colors.Black;
builder.PlayerBuilder2.Color = Colors.White;
var game = builder.Build();
var positionsTuple = game.State.PositionsPair.Map(x => x.ToList());
positionsTuple.ForEach(ps => Assert.AreEqual(size, ps.Count));
positionsTuple.Zip((size - 1, 0))
.ForEach(t => {
var(ps, row) = t;
Assert.AreEqual(size - 2, ps.Count(p => p.X == row)); // friend row
Assert.AreEqual(2, ps.Count(p => p.X == size - 1 - row)); // enemy row
});
// ball carriers are middle pieces, in friend row
game.State.BallCarrierPair
.Zip((size - 1, 0))
.ForEach(t => {
var(ball, row) = t;
Assert.AreEqual(size / 2, ball.Y);
Assert.AreEqual(row, ball.X);
});
}
public void TestGameSave()
{
gameBuilder = new GameBuilderUnsaved();
Player[] tabPlayer = new Player[2];
tabPlayer[0] = new Player("Joueur1", "cyclops");
tabPlayer[1] = new Player("Joueur2", "centaur");
gameBuilder.AddStrategy("demo");
gameBuilder.AddPlayer(tabPlayer);
Game game = gameBuilder.Build();
Assert.AreEqual(game.NbJoueur, 2);
Assert.AreEqual(game.ListPlayer.Count, 2);
Assert.AreEqual(game.ListPlayer[0].Name, "Joueur1");
Assert.AreEqual(game.ListPlayer[0].RaceString, "cyclops");
Assert.AreEqual(game.ListPlayer[0].EntityList.Count, 4);
Assert.AreEqual(game.ListPlayer[1].Name, "Joueur2");
Assert.AreEqual(game.ListPlayer[1].RaceString, "centaur");
Assert.AreEqual(game.ListPlayer[1].EntityList.Count, 4);
if (game.CurrEntity.Pos == 0)
{
game.Move(1);
}
else if (game.CurrEntity.Pos == 35)
{
game.Move(34);
}
else if (game.CurrEntity.Pos == 5)
{
game.Move(4);
}
else if (game.CurrEntity.Pos == 29)
{
game.Move(30);
}
//On enregistre une sauvegarde du game dans un fichier SaveFile
game.Save("SaveFile.txt", -1);
Assert.IsTrue(game.VerifEndGame() == -1);
//On charge la sauvegarde
gameBuilder = new GameBuilderSaved("C:\\Users\\agimenez\\Documents\\SaveFile.txt");
Game gameLoad = gameBuilder.Build();
Assert.AreEqual(gameLoad.NbJoueur, 2);
Assert.AreEqual(gameLoad.ListPlayer.Count, 2);
Assert.AreEqual(gameLoad.ListPlayer[0].Name, "Joueur1");
Assert.AreEqual(gameLoad.ListPlayer[0].RaceString, "cyclops");
//Assert.AreEqual(game.ListPlayer[0].EntityList.Count, 4);
Assert.AreEqual(gameLoad.ListPlayer[1].Name, "Joueur2");
Assert.AreEqual(gameLoad.ListPlayer[1].RaceString, "centaur");
Assert.AreEqual(gameLoad.ListPlayer[1].EntityList.Count, 4);
}
public void Build_CreatesPlayer()
{
var builder = new GameBuilder();
var state = builder.Build(5, 6, 3, 5);
Assert.IsNotNull(state.Player);
Assert.IsInstanceOf <PlayerState>(state.Player);
}
public GameHost()
{
var fieldManager = new FieldManager();
var gameBuilder = new GameBuilder(fieldManager);
Game = gameBuilder.Build();
GameManager = new GameManager(fieldManager);
}
public void Build_CreatesGrid(int rows, int columns, int mines)
{
var builder = new GameBuilder();
var state = builder.Build(rows, columns, 3, mines);
Assert.IsNotNull(state.GameGrid);
Assert.AreEqual(rows, state.GameGrid.Count);
Assert.AreEqual(columns, state.GameGrid.First().Count);
Assert.AreEqual(mines, GetMineCount(state));
}
public void GivenBoardWithOneUser_WhenNewGameCreated_ThenUserPlaceShouldBeOne()
{
//given
var gameBuilder = new GameBuilder();
var player = gameBuilder.AddPlayer(new Player());
//when
var game = gameBuilder.Build();
//then
player.Place.Should().Be(1);
}
/// <summary>
/// Creates the game's window.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void NextButtonClick(object sender, RoutedEventArgs e)
{
_builder.SetSize(_mapSize.Text);
_builder.UseDefaultFrequencies();
var main = Application.Current.MainWindow;
var game = new GameWindow(_builder.Build());
Application.Current.MainWindow = game;
main.Close();
game.Show();
}
public void GivenNewBoardWithOneUser_WhenGamePlayed_ThenUserIsAdvanced()
{
//given
var gameBuilder = new GameBuilder();
var player = gameBuilder.AddPlayer(new Player());
var game = gameBuilder.Build();
//when
var diceThrow = game.Play();
//then
game.Players.ToList()[0].Place.Should().Be(diceThrow + 1);
}
public void TestSetSize([Range(1, 15)] int size)
{
var builder = new GameBuilder();
builder.PlayerBuilder1.Color = Colors.Black;
builder.PlayerBuilder2.Color = Colors.White;
if (size % 2 == 0 || size < 2)
{
Assert.That(() => {
builder.BoardSize = size;
builder.Build();
}, Throws.ArgumentException);
}
else
{
builder.BoardSize = size;
var game = builder.Build();
Assert.AreEqual(size, game.State.BoardSize);
}
}
public void FinishGame_WrongGameId_GameIsNotRemoved()
{
// Arrange
var game = GameBuilder.Build("Team1", 4, "Team2", 3, 1);
service.ActiveGames.Add(game);
// Act
var result = service.FinishGame(game.Id + 1);
// Assert
Assert.False(result);
Assert.Single(service.ActiveGames);
}
public void FinishGame_ValidGameId_GameIsRemoved()
{
// Arrange
var game = GameBuilder.Build("Team1", 4, "Team2", 3, 1);
service.ActiveGames.Add(game);
// Act
var result = service.FinishGame(game.Id);
// Assert
Assert.True(result);
Assert.Empty(service.ActiveGames);
}
static void Main(string[] args)
{
var gameBuilder = new GameBuilder();
gameBuilder.AddScene <Introduction>();
gameBuilder.AddScene <Chapter1>();
gameBuilder.AddScene <Chapter2>();
gameBuilder.AddScene <Chapter3>();
gameBuilder.AddScene <End>();
var game = gameBuilder.Build();
game.Launch();
}
public void UpdateGame_NegativeScore_ExceptionIsThrown(int newHomeScore, int newAwayScore)
{
// Arrange
var homeScore = 0;
var awayScore = 0;
var game = GameBuilder.Build("Team1", homeScore, "Team2", awayScore, 1);
service.ActiveGames.Add(game);
// Act
var exception = Record.Exception(() => service.UpdateScore(game.Id + 1, newHomeScore, newAwayScore));
// Assert
Assert.IsType <ArgumentOutOfRangeException>(exception);
}
public void TestAttackDefense()
{
gameBuilder = new GameBuilderUnsaved();;
Player[] tabPlayer = new Player[2];
tabPlayer[0] = new Player("Joueur1", "cyclops");
tabPlayer[1] = new Player("Joueur2", "centaur");
gameBuilder.AddStrategy("demo");
gameBuilder.AddPlayer(tabPlayer);
Game game = gameBuilder.Build();
game.StartTurn();
game.CurrEntity.Pos = 2;
//les movePoints ne sont sencés changer après un Skip() car ils sont au max
double Oldpoint = game.CurrEntity.MovePoint;
Assert.IsTrue(game.Skip());
Assert.AreEqual(Oldpoint, game.CurrEntity.MovePoint);
//On passe la main a l'enemy
game.EndMyTurn();
game.CurrEntity.Pos = 3;
game.EndMyTurn();
//c'est la seul entity dans la position 3 donc c'est la meilluer defense
Assert.AreEqual(game.CurrEntity, game.Map.GetBestDefenser(2));
game.Map.GetDistance(game.CurrEntity, 3);
//Le move va decalancher un combat vu que il ya l'enemy est dans la case suivante
//l'entité courante gagne et cela retourne true
Assert.IsTrue(game.Move(3));
Assert.AreEqual(game.GetActionNumber(), 1);
//On met tout ses LifePoint à 0 pour que l'autre joueur gagne
// FAUX ! On sort l'unité du plateau en lui mettant pour position -1
foreach (Entity e in game.ListPlayer[0].EntityList)
{
//e.LifePoint = 0;
game.Map.Remove(e.Pos, e);
}
//On passe la main à l'autre joueur
game.EndMyTurn();
Assert.AreEqual(game.VerifEndGame(), game.CurrPlayerNumber);
}
public void UpdateGame_WrongNameIdValidScore_ScoreDoesNotGetUpdated()
{
// Arrange
var homeScore = 0;
var awayScore = 0;
var newAwayScore = 1;
var game = GameBuilder.Build("Team1", homeScore, "Team2", awayScore, 1);
service.ActiveGames.Add(game);
// Act
service.UpdateScore(game.Id + 1, game.HomeTeam.Score, newAwayScore);
// Assert
Assert.Equal(homeScore, service.ActiveGames[0].HomeTeam.Score);
Assert.NotEqual(newAwayScore, service.ActiveGames[0].AwayTeam.Score);
}
public void TestBallRandomInitStrategy([Range(3, 15, 2)] int size)
{
var builder = new GameBuilder {
BoardSize = size,
Scenario = GameScenario.BallRandom
};
builder.PlayerBuilder1.Color = Colors.Black;
builder.PlayerBuilder2.Color = Colors.White;
var game = builder.Build();
var(p1Pos, p2Pos) = game.State.PositionsPair.Map(x => x.ToList());
game.State.PositionsPair.ForEach(ps => Assert.AreEqual(size, ps.Count()));
p1Pos.ForEach(x => Assert.AreEqual(size - 1, x.X)); // bottom row
p2Pos.ForEach(x => Assert.AreEqual(0, x.X)); // top row
// ball carriers can be any piece in the line
}
public void GivenPlayerIsAt70_WhenGameRolls4_ThenPlaceIs74()
{
//given
var gameBuilder = new GameBuilder();
var player = new Player()
{
Place = 70
};
gameBuilder.AddPlayer(player);
var dice = new Mock <IDice>();
dice.Setup(d => d.Throw()).Returns(4);
gameBuilder.SetDice(dice.Object);
var game = gameBuilder.Build();
//when
game.Play();
//then
game.Players.ToList()[0].Place.Should().Be(74);
}
void TryCreateGame(Session session, string botUserName = null)
{
if (session.Awaiting)
{
return;
}
var rand = new Random(DateTime.Now.Millisecond);
var turnOwnerIndex = rand.Next(session.Users.Count);
var turnOwner = session.Users[turnOwnerIndex];
var gameBuilder =
new GameBuilder(session.Id, session.Users, GameRules.StartHealth, GameRules.StartPower)
.WithTurnOwner(turnOwner);
if (!string.IsNullOrEmpty(botUserName))
{
gameBuilder.WithBot(botUserName);
}
if (!_games.TryAdd(gameBuilder.Build()))
{
_logger.LogError("Can't create game for session: '{0}'", session.Id);
}
}
public void TestStandardInitStrategy([Range(3, 15, 2)] int size)
{
var builder = new GameBuilder {
BoardSize = size,
Scenario = GameScenario.Standard
};
builder.PlayerBuilder1.Color = Colors.Black;
builder.PlayerBuilder2.Color = Colors.White;
var game = builder.Build();
var(p1Pos, p2Pos) = game.State.PositionsPair.Map(x => x.ToList());
Assert.AreEqual(size, p1Pos.Count);
Assert.AreEqual(size, p2Pos.Count);
p1Pos.ForEach(x => Assert.AreEqual(size - 1, x.X)); // bottom row
p2Pos.ForEach(x => Assert.AreEqual(0, x.X)); // top row
// ball carriers are middle pieces
game.State.BallCarrierPair.ForEach(x => Assert.AreEqual(size / 2, x.Y));
}
static void Main(string[] args)
{
Console.WriteLine("Menu diaballik (entrer le numéro de l'action) :");
Console.WriteLine("\t 1 : Nouvelle Partie (standard)");
Console.WriteLine("\t 2 : Charger une partie (standard)");
Console.WriteLine("\t 3 : exit");
bool validation = true;
while (validation)
{
string action = Console.ReadLine();
switch (action)
{
case "1":
Console.WriteLine("Le nom du joueur 1:");
string nom1 = Console.ReadLine();
Console.WriteLine("La couleur du joueur 1:");
string color1 = Console.ReadLine();
Console.WriteLine("Le nom du joueur 2:");
string nom2 = Console.ReadLine();
Console.WriteLine("La couleur du joueur 2:");
string color2 = Console.ReadLine();
Console.WriteLine("Type de Board souhaiter (standard/ballrandom/enemyamongus):");
BoardStrategy strat;
string boardStrat = Console.ReadLine();
switch (boardStrat)
{
case "standrard":
strat = BoardStrategy.Standard;
break;
case "ballrandom":
strat = BoardStrategy.BallRandom;
break;
case "enemyamongus":
strat = BoardStrategy.EnemyAmongUs;
break;
default:
strat = BoardStrategy.Standard;
break;
}
Console.WriteLine("Taille de Board souhaiter (entrer un entier impair):");
int size;
while ((size = int.Parse(Console.ReadLine())) % 2 != 1)
{
Console.WriteLine("Veuillez entrer un entier impair:");
}
GameBuilder gb = new GameBuilder().SetPlayer0(nom1, color1).SetPlayer1(nom2, color2).SetBoard(size, strat);
Game g = gb.Build();
bool valid = true;
while (valid)
{
Console.WriteLine(g.ToString());
Console.WriteLine("Nombre de déplacement de pièce restant :" + (2 - g.MovePieceCount));
Console.WriteLine("Nombre de déplacement de pièce restant :" + (1 - g.MoveBallCount));
Console.WriteLine("Choississez votre action :");
Console.WriteLine("1: Déplacer Pièce");
Console.WriteLine("2: Déplacer Ball");
Console.WriteLine("3: Fin du tour");
Console.WriteLine("4: Undo");
Console.WriteLine("5: Redo");
Console.WriteLine("6: Exit");
string rep = Console.ReadLine();
switch (rep)
{
case "1": // Move Piece
Console.WriteLine("which piece ? (x)");
string repx = Console.ReadLine();
Console.WriteLine("which piece ? (y)");
string repy = Console.ReadLine();
Console.WriteLine("where to ? (x)");
string wherex = Console.ReadLine();
Console.WriteLine("where to ? (y)");
string wherey = Console.ReadLine();
g.Update(new MovePiece(int.Parse(repx), int.Parse(repy), int.Parse(wherex), int.Parse(wherey)));
break;
case "2": // Move Ball
Console.WriteLine("which piece ? (x)");
string pbx = Console.ReadLine();
Console.WriteLine("which piece ? (y)");
string pby = Console.ReadLine();
Console.WriteLine("where to ? (x)");
string nbx = Console.ReadLine();
Console.WriteLine("where to ? (y)");
string nby = Console.ReadLine();
g.Update(new MoveBall(int.Parse(pbx), int.Parse(pby), int.Parse(nbx), int.Parse(nby)));
break;
case "3": // End Turn
g.Update(new EndTurn());
break;
case "4": //Undo
g.UndoLastCommand();
break;
case "5": //Redo
g.RedoLastCommand();
break;
case "6":
return;
}
if (g.IsWin())
{
valid = false;
Console.WriteLine("Le jeu est fini. Le joueur victorieux est :");
Console.WriteLine(g.VictoriousPlayer.ToString());
}
}
break;
case "2": // Charger une partie
string filename = Console.ReadLine();
filename = @"C:\Temp\diaballik_loadgamebuildertest.save";
Game g2 = GameSaveManager.Load(filename);
bool valid1 = true;
while (valid1)
{
Console.WriteLine(g2.ToString());
Console.WriteLine("Nombre de déplacement de pièce restant :" + (2 - g2.MovePieceCount));
Console.WriteLine("Nombre de déplacement de pièce restant :" + (1 - g2.MoveBallCount));
Console.WriteLine("Choississez votre action :");
Console.WriteLine("1: move piece");
Console.WriteLine("2: move ball");
Console.WriteLine("3: end turn");
Console.WriteLine("4: exit");
string rep = Console.ReadLine();
switch (rep)
{
case "1":
Console.WriteLine("which piece ? (x)");
string repx = Console.ReadLine();
Console.WriteLine("which piece ? (y)");
string repy = Console.ReadLine();
Console.WriteLine("where to ? (x)");
string wherex = Console.ReadLine();
Console.WriteLine("where to ? (y)");
string wherey = Console.ReadLine();
g2.Update(new MovePiece(int.Parse(repx), int.Parse(repy), int.Parse(wherex), int.Parse(wherey)));
break;
case "2":
Console.WriteLine("which piece ? (x)");
string pbx = Console.ReadLine();
Console.WriteLine("which piece ? (y)");
string pby = Console.ReadLine();
Console.WriteLine("where to ? (x)");
string nbx = Console.ReadLine();
Console.WriteLine("where to ? (y)");
string nby = Console.ReadLine();
g2.Update(new MoveBall(int.Parse(pbx), int.Parse(pby), int.Parse(nbx), int.Parse(nby)));
break;
case "3":
g2.Update(new EndTurn());
break;
case "4":
return;
}
if (g2.IsWin())
{
valid = false;
Console.WriteLine("Le jeu est fini. Le joueur victorieux est :");
Console.WriteLine(g2.VictoriousPlayer.ToString());
}
}
break;
case "3":
break;
}
}
return;
}
public void TestMovePointTurn()
{
//construire le gameBuilder
gameBuilder = new GameBuilderUnsaved();
//declarer un tableau de Player
Player[] tabPlayer = new Player[2];
tabPlayer[0] = new Player("Joueur1", "cyclops");
tabPlayer[1] = new Player("Joueur2", "centaur");
//Ajouter la strategie au gameBuilder
gameBuilder.AddStrategy("demo");
//Ajouter les joueurs au gameBuilder
gameBuilder.AddPlayer(tabPlayer);
//declarer et construire le game
Game game = gameBuilder.Build();
//Debut des tours
game.StartTurn();
//recuperer les points de mouvement de l'netité courante du premier player
double pt1 = game.CurrEntity.MovePoint;
//faire un movement a la case 2
//Et si il commence pas en 0 ?
//game.Move(2);
if (game.CurrEntity.Pos == 0)
{
game.Move(2);
}
if (game.CurrEntity.Pos == 35)
{
game.Move(33);
}
if (game.CurrEntity.Pos == 5)
{
game.Move(3);
}
if (game.CurrEntity.Pos == 30)
{
game.Move(32);
}
//recuperer les points de mouvement apres le move
double pt2 = game.CurrEntity.MovePoint;
//les points de mouvements doivent baisser
Assert.IsTrue(pt1 > pt2);
//passer la main à l'autre joueur
game.NextPlayer();
game.StartTurn();
//recuperer la position de l'entité courante
int pos1 = game.CurrEntity.Pos;
//deplacer l'entité courante
game.CurrEntity.Move(10, game.Map);
//recuperer la nouvelle position
int pos2 = game.CurrEntity.Pos;
//tester si la position a changé
Assert.IsTrue(pos1 != pos2);
//faire un move qui teste si on peut
game.Move(10);
//recuperer la nouvelle position
int pos3 = game.CurrEntity.Pos;
//tester si la position n'a pas changé car on a que 3 points de mouvement
Assert.IsTrue(pos3 == pos2);
}
