public void GelijkSpelField()
{
var superFieldService = new SuperFieldService();
var superField = new SuperField();
superFieldService.DoMove(superField, 0, 0, 0, 0);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 0, 0, 1);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 0, 0, 2);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 0, 1, 1);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 0, 1, 0);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 0, 2, 0);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 0, 1, 2);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 0, 2, 2);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 0, 2, 1);
superField.TurnRestrictedToField = false;
Assert.True(superField.Fields[0][0].winner == FieldState.Draw);
}
public bool IsMovePossible(SuperField superField, int fieldY, int fieldX, int squareY, int squareX)
{
//check of veld vol is
if (superField.Winner != FieldState.None)
{
return(false);
}
if (superField.Fields[fieldY][fieldX].winner != FieldState.None)
{
return(false);
}
if (superField.Fields[fieldY][fieldX].Squares[squareY][squareX] != SquareState.Empty)
{
return(false);
}
if (superField.TurnRestrictedToField)
{
if (fieldY != superField.RestrictedToFieldY)
{
return(false);
}
if (fieldX != superField.RestrictedToFieldX)
{
return(false);
}
}
return(true);
}
public Score EvaluateSuperField(SuperField superField, Bot bot)
{
int[][] fieldScore = new int[3][] {
new int[3],
new int[3],
new int[3],
};
int superFieldScore = 0;
for (int y = 0; y < 3; y++)
{
for (int x = 0; x < 3; x++)
{
fieldScore[y][x] = EvaluateField(superField.Fields[y][x], bot);
if (y == 1 && x == 1)
{
fieldScore[y][x] = fieldScore[y][x] * bot.fieldCenterMultiplier;
}
else if ((x + y) % 2 == 0)
{
fieldScore[y][x] = fieldScore[y][x] * bot.fieldCornerMultiplier;
}
else
{
fieldScore[y][x] = fieldScore[y][x] * bot.fieldMiddleMultiplier;
}
}
}
superFieldScore = EvaluateSuperFieldScore(superField, fieldScore, bot) * bot.superFieldMultiplier;
return(new Score(fieldScore, superFieldScore));
}
private bool HasSuperFieldThreeInARow(SuperField superField)
{
foreach (var fieldRow in superField.Fields)
{
if (AreThreeInARowField(fieldRow[0], fieldRow[1], fieldRow[2]))
{
return(true);
}
}
for (int i = 0; i < 3; i++)
{
if (AreThreeInARowField(superField.Fields[0][i], superField.Fields[1][i], superField.Fields[2][i]))
{
return(true);
}
}
if (AreThreeInARowField(superField.Fields[0][0], superField.Fields[1][1], superField.Fields[2][2]))
{
return(true);
}
if (AreThreeInARowField(superField.Fields[2][0], superField.Fields[1][1], superField.Fields[0][2]))
{
return(true);
}
return(false);
}
public void OnGet()
{
superField = new SuperField();
score = superFieldEvalutionService.EvaluateSuperField(superField, bot);
HttpContext.Session.Set <SuperField>(SuperFieldKey, superField);
}
public SquarePosition FindMove(SuperField superField, Bot bot, int iterations)
{
var bestScore = -100000000;
SquarePosition bestPosition = new SquarePosition(0, 0, 0, 0);
for (int fieldY = 0; fieldY < 3; fieldY++)
{
for (int fieldX = 0; fieldX < 3; fieldX++)
{
for (int squareY = 0; squareY < 3; squareY++)
{
for (int squareX = 0; squareX < 3; squareX++)
{
if (superFieldService.IsMovePossible(superField, fieldY, fieldX, squareY, squareX))
{
var tempSuperField = new SuperField(superField);
superFieldService.DoMove(tempSuperField, fieldY, fieldX, squareY, squareX);
var score = findScoreForBestMove(tempSuperField, bot, iterations, 1);
if (score >= bestScore)
{
bestScore = score;
bestPosition = new SquarePosition(fieldY, fieldX, squareY, squareX);
}
}
}
}
}
}
return(bestPosition);
}
public SuperField DoMove(SuperField superField, Bot bot)
{
var squarePosition = FindMove(superField, bot, 6);
superFieldService.DoMove(superField, squarePosition.FieldY, squarePosition.FieldX, squarePosition.SquareY, squarePosition.SquareX);
return(superField);
}
public void DoMove(SuperField superField, int fieldY, int fieldX, int squareY, int squareX)
{
if (IsMovePossible(superField, fieldY, fieldX, squareY, squareX))
{
superField.Fields[fieldY][fieldX].Squares[squareY][squareX] = superField.PlayersTurn;
if (HasFieldThreeInARow(superField.Fields[fieldY][fieldX]))
{
superField.Fields[fieldY][fieldX].winner = SquareStateToFieldState(superField.PlayersTurn);
if (HasSuperFieldThreeInARow(superField))
{
superField.Winner = SquareStateToFieldState(superField.PlayersTurn);
}
}
else
{
if (IsFieldFull(superField.Fields[fieldY][fieldX]))
{
superField.Fields[fieldY][fieldX].winner = FieldState.Draw;
if (IsSuperFieldFull(superField))
{
superField.Winner = FieldState.Draw;
}
}
}
if (superField.Fields[squareY][squareX].winner != FieldState.None)
{
superField.TurnRestrictedToField = false;
}
else
{
superField.TurnRestrictedToField = true;
superField.RestrictedToFieldY = squareY;
superField.RestrictedToFieldX = squareX;
}
superField.HighlightMove = true;
superField.HighlightMoveFieldY = fieldY;
superField.HighlightMoveFieldX = fieldX;
superField.HighlightMoveSquareY = squareY;
superField.HighlightMoveSquareX = squareX;
if (superField.PlayersTurn == SquareState.X)
{
superField.PlayersTurn = SquareState.O;
}
else
{
superField.PlayersTurn = SquareState.X;
}
}
else
{
superField.HighlightMove = false;
}
}
public void GewonnenSpelSuperField()
{
var superFieldService = new SuperFieldService();
var superField = new SuperField();
//field 1
superFieldService.DoMove(superField, 0, 0, 0, 0);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 0, 0, 1);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 0, 1, 0);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 0, 1, 1);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 0, 2, 0);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 1, 0, 0, 0);
superField.TurnRestrictedToField = false;
//field 2
superFieldService.DoMove(superField, 0, 1, 0, 0);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 1, 0, 1);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 1, 1, 0);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 1, 1, 1);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 1, 2, 0);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 1, 1, 0, 0);
superField.TurnRestrictedToField = false;
//field 3
superFieldService.DoMove(superField, 0, 2, 0, 0);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 2, 0, 1);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 2, 1, 0);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 2, 1, 1);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 2, 2, 0);
superField.TurnRestrictedToField = false;
Assert.True(superField.Winner == FieldState.X);
}
private bool IsSuperFieldFull(SuperField superField)
{
foreach (var fieldRow in superField.Fields)
{
foreach (var field in fieldRow)
{
if (field.winner == FieldState.None)
{
return(false);
}
}
}
return(true);
}
public int findScoreForBestMove(SuperField superField, Bot bot, int iterations, int step)
{
if (step >= iterations)
{
return(superFieldEvalutionService.EvaluateSuperField(superField, bot).Totaal());
}
else
{
var isScorePositive = step % 2 == 0;
var bestScore = isScorePositive ? -100000000 : 100000000;
SquarePosition bestPosition = new SquarePosition(0, 0, 0, 0);
for (int fieldY = 0; fieldY < 3; fieldY++)
{
for (int fieldX = 0; fieldX < 3; fieldX++)
{
for (int squareY = 0; squareY < 3; squareY++)
{
for (int squareX = 0; squareX < 3; squareX++)
{
if (superFieldService.IsMovePossible(superField, fieldY, fieldX, squareY, squareX))
{
var tempSuperField = new SuperField(superField);
superFieldService.DoMove(tempSuperField, fieldY, fieldX, squareY, squareX);
var newIterations = iterations;
if (!tempSuperField.TurnRestrictedToField)
{
newIterations--;
}
var score = findScoreForBestMove(tempSuperField, bot, newIterations, step + 1);
if (isScorePositive && score >= bestScore || !isScorePositive && score <= bestScore)
{
bestScore = score;
}
}
}
}
}
}
if (bestScore == (isScorePositive ? -100000000 : 100000000))
{
return(superFieldEvalutionService.EvaluateSuperField(superField, bot).Totaal());
}
else
{
return(bestScore);
}
}
}
private int EvaluateSuperFieldScore(SuperField superField, int[][] fieldScore, Bot bot)
{
if (superField.Winner == FieldState.Draw)
{
return(0);
}
if (superField.Winner == FieldState.O)
{
return(bot.winnerReversed ? 8000 : -8000);
}
if (superField.Winner == FieldState.X)
{
return(bot.winnerReversed ? -8000 : 8000);
}
var score = 0;
FieldScoreState[][] fieldScoreStates = new FieldScoreState[][]
{
new FieldScoreState[3],
new FieldScoreState[3],
new FieldScoreState[3],
};
for (int y = 0; y < 3; y++)
{
for (int x = 0; x < 3; x++)
{
fieldScoreStates[y][x] = FieldScoreStateFromfield(superField.Fields[y][x], fieldScore[y][x], bot);
}
}
score += bot.superFieldRowsEdge[(int)fieldScoreStates[0][0], (int)fieldScoreStates[0][1], (int)fieldScoreStates[0][2]];
score += bot.superFieldRowsMiddle[(int)fieldScoreStates[1][0], (int)fieldScoreStates[1][1], (int)fieldScoreStates[1][2]];
score += bot.superFieldRowsEdge[(int)fieldScoreStates[2][0], (int)fieldScoreStates[2][1], (int)fieldScoreStates[2][2]];
score += bot.superFieldRowsEdge[(int)fieldScoreStates[0][0], (int)fieldScoreStates[1][0], (int)fieldScoreStates[2][0]];
score += bot.superFieldRowsMiddle[(int)fieldScoreStates[0][1], (int)fieldScoreStates[1][1], (int)fieldScoreStates[2][1]];
score += bot.superFieldRowsEdge[(int)fieldScoreStates[0][2], (int)fieldScoreStates[1][2], (int)fieldScoreStates[2][2]];
score += bot.superFieldRowsDiagonal[(int)fieldScoreStates[0][0], (int)fieldScoreStates[1][1], (int)fieldScoreStates[2][2]];
score += bot.superFieldRowsDiagonal[(int)fieldScoreStates[2][0], (int)fieldScoreStates[1][1], (int)fieldScoreStates[0][2]];
return(score);
}
public void GewonnenSpelField()
{
var superFieldService = new SuperFieldService();
var superField = new SuperField();
superFieldService.DoMove(superField, 0, 0, 0, 0);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 0, 0, 1);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 0, 1, 0);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 0, 1, 1);
superField.TurnRestrictedToField = false;
superFieldService.DoMove(superField, 0, 0, 2, 0);
superField.TurnRestrictedToField = false;
Assert.True(superField.Fields[0][0].winner == FieldState.X);
Assert.True(superField.Winner == FieldState.None);
}
public static int test()
{
var obj = new SuperField();
return(obj.method());
}
public static int test() {
var obj = new SuperField();
return obj.method();
}
