12 Commits

  1. 2
      BlazorSolution/MiniGames/Client/ViewModel/ITicTacToe.cs
  2. 31
      BlazorSolution/MiniGames/Client/ViewModel/TicTacToe.cs
  3. 4
      BlazorSolution/MiniGames/Shared/Models/TicTacToeBrett.cs
  4. 2
      BlazorSolution/MiniGames/Shared/Models/TicTacToeModel.cs
  5. 140
      BlazorSolution/MiniGamesTests/TicTacToeBrettTest.cs
  6. 107
      BlazorSolution/MiniGamesTests/TicTacToeTest.cs

2
BlazorSolution/MiniGames/Client/ViewModel/ITicTacToe.cs

@ -2,6 +2,6 @@
{ {
public interface ITicTacToe public interface ITicTacToe
{ {
bool SpielerInput(int spielerIndex, int posIndex);
void SpielerInput(int posIndex);
} }
} }

31
BlazorSolution/MiniGames/Client/ViewModel/TicTacToe.cs

@ -17,9 +17,36 @@ namespace MiniGames.Client.ViewModel
set { Model.Brett = value; } set { Model.Brett = value; }
} }
public bool SpielerInput(int spielerIndex, int posIndex)
public int AktiverSpielerIndex
{ {
return true;
get { return Model.AktiverSpielerIndex; }
set { Model.AktiverSpielerIndex = value; }
}
public int GewinnerIndex
{
get { return Model.GewinnerIndex; }
set {
if (Model.GewinnerIndex < 0)
{
Model.GewinnerIndex = value;
}
}
}
public void SpielerInput(int posIndex)
{
if (Brett.Set(posIndex, AktiverSpielerIndex))
{
SpielerWechsel();
}
GewinnerIndex = Brett.Gewinner();
}
public void SpielerWechsel()
{
AktiverSpielerIndex = 1 - AktiverSpielerIndex;
} }
} }
} }

4
BlazorSolution/MiniGames/Shared/Models/TicTacToeBrett.cs

@ -65,8 +65,8 @@ namespace MiniGames.Shared.Models
public bool Set(int pos, int wert) public bool Set(int pos, int wert)
{ {
int x = pos / 3;
int y = pos % 3;
int x = pos % 3;
int y = pos / 3;
try try
{ {

2
BlazorSolution/MiniGames/Shared/Models/TicTacToeModel.cs

@ -9,6 +9,8 @@ namespace MiniGames.Shared.Models
public class TicTacToeModel public class TicTacToeModel
{ {
public SpielerModel[] Spieler { get; set; } public SpielerModel[] Spieler { get; set; }
public int AktiverSpielerIndex { get; set; } = 0;
public int GewinnerIndex { get; set; } = -1;
public TicTacToeBrett Brett { get; set; } public TicTacToeBrett Brett { get; set; }
} }
} }

140
BlazorSolution/MiniGamesTests/TicTacToeBrettTest.cs

@ -5,36 +5,56 @@ namespace MiniGamesTests
{ {
public class TicTacToeBrettTest public class TicTacToeBrettTest
{ {
const int LEER = TicTacToeBrett.LEER;
public TicTacToeBrett TestBrett( public TicTacToeBrett TestBrett(
int a = TicTacToeBrett.LEER, int b = TicTacToeBrett.LEER, int c = TicTacToeBrett.LEER,
int d = TicTacToeBrett.LEER, int e = TicTacToeBrett.LEER, int f = TicTacToeBrett.LEER,
int g = TicTacToeBrett.LEER, int h = TicTacToeBrett.LEER, int i = TicTacToeBrett.LEER
int f00 = LEER, int f10 = LEER, int f20 = LEER,
int f01 = LEER, int f11 = LEER, int f21 = LEER,
int f02 = LEER, int f12 = LEER, int f22 = LEER
) )
{ {
return new( return new(
new int[,] new int[,]
{ {
{ a, b, c, },
{ d, e, f, },
{ g, h, i, },
{ f00, f01, f02, },
{ f10, f11, f12, },
{ f20, f21, f22, },
} }
); );
} }
[Fact]
public void Set_FreiesFeldBelegenTest()
[Theory]
[InlineData(4, 0,
LEER, LEER, LEER,
LEER, 0
)]
[InlineData(0, 1,
1
)]
[InlineData(8, 2,
LEER, LEER, LEER,
LEER, LEER, LEER,
LEER, LEER, 2
)]
[InlineData(6, 3,
LEER, LEER, LEER,
LEER, LEER, LEER,
3, LEER, LEER
)]
[InlineData(3, 4,
LEER, LEER, LEER,
4, LEER, LEER,
LEER, LEER, LEER
)]
public void Set_FreiesFeldBelegenTest(int pos, int wert,
int a = LEER, int b = LEER, int c = LEER,
int d = LEER, int e = LEER, int f = LEER,
int g = LEER, int h = LEER, int i = LEER
)
{ {
// arrange // arrange
TicTacToeBrett brett = new(); TicTacToeBrett brett = new();
TicTacToeBrett erwartetesBrett = TestBrett(
TicTacToeBrett.LEER,
TicTacToeBrett.LEER,
TicTacToeBrett.LEER,
TicTacToeBrett.LEER,
0
);
int pos = 4;
int wert = 0;
TicTacToeBrett erwartetesBrett = TestBrett(a, b, c, d, e, f, g, h, i);
bool erwartetGesetzt = true; bool erwartetGesetzt = true;
// act // act
@ -189,7 +209,7 @@ namespace MiniGamesTests
{ {
// arrange // arrange
TicTacToeBrett brett = TestBrett(); TicTacToeBrett brett = TestBrett();
int erwarteterGewinner = TicTacToeBrett.LEER;
int erwarteterGewinner = LEER;
// act // act
int erhaltenerGewinner = brett.Gewinner(); int erhaltenerGewinner = brett.Gewinner();
@ -201,56 +221,56 @@ namespace MiniGamesTests
[Theory] [Theory]
// Vertikale Reihe 1 // Vertikale Reihe 1
[InlineData(0, [InlineData(0,
0, 0, 0,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER
0, LEER, LEER,
0, LEER, LEER,
0, LEER, LEER
)] )]
// Vertikale Reihe 2 // Vertikale Reihe 2
[InlineData(1, [InlineData(1,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
1, 1, 1,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER
LEER, 1, LEER,
LEER, 1, LEER,
LEER, 1, LEER
)] )]
// Vertikale Reihe 3 // Vertikale Reihe 3
[InlineData(2, [InlineData(2,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
2, 2, 2
LEER, LEER, 2,
LEER, LEER, 2,
LEER, LEER, 2
)] )]
// Horizontale Reihe 1 // Horizontale Reihe 1
[InlineData(3, [InlineData(3,
3, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
3, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
3, TicTacToeBrett.LEER, TicTacToeBrett.LEER
3, 3, 3,
LEER, LEER, LEER,
LEER, LEER, LEER
)] )]
// Horizontale Reihe 2 // Horizontale Reihe 2
[InlineData(4, [InlineData(4,
TicTacToeBrett.LEER, 4, TicTacToeBrett.LEER,
TicTacToeBrett.LEER, 4, TicTacToeBrett.LEER,
TicTacToeBrett.LEER, 4, TicTacToeBrett.LEER
LEER, LEER, LEER,
4, 4, 4,
LEER, LEER, LEER
)] )]
// Horizontale Reihe 3 // Horizontale Reihe 3
[InlineData(5, [InlineData(5,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, 5,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, 5,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, 5
LEER, LEER, LEER,
LEER, LEER, LEER,
5, 5, 5
)] )]
// Diagonale Reihe links oben nach rechts unten // Diagonale Reihe links oben nach rechts unten
[InlineData(6, [InlineData(6,
6, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
TicTacToeBrett.LEER, 6, TicTacToeBrett.LEER,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, 6
6, LEER, LEER,
LEER, 6, LEER,
LEER, LEER, 6
)] )]
// Diagonale Reihe rechts oben nach links unten // Diagonale Reihe rechts oben nach links unten
[InlineData(7, [InlineData(7,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, 7,
TicTacToeBrett.LEER, 7, TicTacToeBrett.LEER,
7, TicTacToeBrett.LEER, TicTacToeBrett.LEER
LEER, LEER, 7,
LEER, 7, LEER,
7, LEER, LEER
)] )]
public void Gewinner_VolleReihenTest(int gewinner, public void Gewinner_VolleReihenTest(int gewinner,
int a = TicTacToeBrett.LEER, int b = TicTacToeBrett.LEER, int c = TicTacToeBrett.LEER,
int d = TicTacToeBrett.LEER, int e = TicTacToeBrett.LEER, int f = TicTacToeBrett.LEER,
int g = TicTacToeBrett.LEER, int h = TicTacToeBrett.LEER, int i = TicTacToeBrett.LEER
int a = LEER, int b = LEER, int c = LEER,
int d = LEER, int e = LEER, int f = LEER,
int g = LEER, int h = LEER, int i = LEER
) )
{ {
// arrange // arrange
@ -266,34 +286,34 @@ namespace MiniGamesTests
[Theory] [Theory]
[InlineData( [InlineData(
0, TicTacToeBrett.LEER, 0,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
0, TicTacToeBrett.LEER, 0
0, LEER, 0,
LEER, LEER, LEER,
0, LEER, 0
)] )]
[InlineData( [InlineData(
1, 1, TicTacToeBrett.LEER,
1, 1, TicTacToeBrett.LEER,
TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER
1, 1, LEER,
1, 1, LEER,
LEER, LEER, LEER
)] )]
[InlineData( [InlineData(
2, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
2, TicTacToeBrett.LEER, 2,
TicTacToeBrett.LEER, 2, 2
2, 2, LEER,
LEER, LEER, 2,
LEER, 2, 2
)] )]
[InlineData( [InlineData(
1, 1, 2, 1, 1, 2,
1, 3, 2,
2, 3, 3
1, 3, 3,
2, 2, 3
)] )]
public void Gewinner_NichtVolleReihenTest( public void Gewinner_NichtVolleReihenTest(
int a = TicTacToeBrett.LEER, int b = TicTacToeBrett.LEER, int c = TicTacToeBrett.LEER,
int d = TicTacToeBrett.LEER, int e = TicTacToeBrett.LEER, int f = TicTacToeBrett.LEER,
int g = TicTacToeBrett.LEER, int h = TicTacToeBrett.LEER, int i = TicTacToeBrett.LEER
int a = LEER, int b = LEER, int c = LEER,
int d = LEER, int e = LEER, int f = LEER,
int g = LEER, int h = LEER, int i = LEER
) )
{ {
// arrange // arrange
TicTacToeBrett brett = TestBrett(a, b, c, d, e, f, g, h, i); TicTacToeBrett brett = TestBrett(a, b, c, d, e, f, g, h, i);
int erwarteterGewinner = TicTacToeBrett.LEER;
int erwarteterGewinner = LEER;
// act // act
int erhaltenerGewinner = brett.Gewinner(); int erhaltenerGewinner = brett.Gewinner();

107
BlazorSolution/MiniGamesTests/TicTacToeTest.cs

@ -1,4 +1,5 @@
using MiniGames.Shared.Models;
using MiniGames.Client.ViewModel;
using MiniGames.Shared.Models;
using Xunit; using Xunit;
namespace MiniGamesTests namespace MiniGamesTests
@ -35,5 +36,109 @@ namespace MiniGamesTests
Brett = StandardBrett(), Brett = StandardBrett(),
}; };
} }
TicTacToe StandardSpiel()
{
return new(StandardModel());
}
[Theory]
[InlineData(0, 1)]
[InlineData(1, 0)]
public void SpielerWechselTest(int vorher, int nachher)
{
// arrange
TicTacToe spiel = StandardSpiel();
spiel.AktiverSpielerIndex = vorher;
int erwarteterIndex = nachher;
// act
spiel.SpielerWechsel();
// assert
Assert.Equal(erwarteterIndex, spiel.AktiverSpielerIndex);
}
[Fact]
public void SpielerInput_ValidesInputTest()
{
// arrange
TicTacToe spiel = StandardSpiel();
spiel.AktiverSpielerIndex = 0;
int erwarteterSpielerIndex = 1;
int pos = 2;
TicTacToeBrett erwartetesBrett = new(new int[,]
{
{ TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER, },
{ TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER, },
{ spiel.AktiverSpielerIndex, TicTacToeBrett.LEER, TicTacToeBrett.LEER, },
});
// act
spiel.SpielerInput(pos);
// assert
Assert.True(spiel.Brett.Gleich(erwartetesBrett));
Assert.Equal(erwarteterSpielerIndex, spiel.AktiverSpielerIndex);
}
[Fact]
public void SpielerInput_InvalidesInputTest()
{
// arrange
TicTacToe spiel = StandardSpiel();
spiel.AktiverSpielerIndex = 0;
int erwarteterSpielerIndex = 0;
int pos = -1;
TicTacToeBrett erwartetesBrett = StandardBrett();
// act
spiel.SpielerInput(pos);
// assert
Assert.True(spiel.Brett.Gleich(erwartetesBrett));
Assert.Equal(erwarteterSpielerIndex, spiel.AktiverSpielerIndex);
}
[Theory]
[InlineData(0, 0, 3, 1, 4, 2)]
[InlineData(0, 3, 0, 4, 1, 5, 2)]
public void SpielerInput_GewinnerTest(int gewinnerIndex, params int[] inputs)
{
// arrange
TicTacToe spiel = StandardSpiel();
int erwarteterGewinnerIndex = gewinnerIndex;
// act
foreach (int input in inputs)
{
spiel.SpielerInput(input);
}
// assert
Assert.Equal(spiel.GewinnerIndex, erwarteterGewinnerIndex);
}
[Fact]
public void SpielerInput_KeinGewinnerTest()
{
// arrange
TicTacToe spiel = StandardSpiel();
spiel.AktiverSpielerIndex = 0;
int erwarteterGewinnerIndex = -1;
// act
spiel.SpielerInput(0);
spiel.SpielerInput(3);
spiel.SpielerInput(1);
spiel.SpielerInput(4);
spiel.SpielerInput(5);
spiel.SpielerInput(2);
// assert
Assert.Equal(spiel.GewinnerIndex, erwarteterGewinnerIndex);
}
} }
} }
Loading…
Cancel
Save