public Snake()
{
this.Pool = new FieldType[xSize, ySize];
this.tail = new LinkedList <Point>();
InitRandom();
InitPool();
}
public Board(int width, int height, int foodInterval, int foodDensity, int seed)
{
_board = new FieldType[width, height];
_width = width;
_height = height;
_foodInterval = foodInterval;
_foodDensity = foodDensity;
_snake = new List <Point>();
_random = new Random(seed);
Dead = false;
Turn = 1;
Direction = Direction.None;
for (var i = 0; i < _width; i++)
{
_board[i, 0] = FieldType.Wall;
_board[i, _height - 1] = FieldType.Wall;
}
for (var i = 0; i < _height; i++)
{
_board[0, i] = FieldType.Wall;
_board[_width - 1, i] = FieldType.Wall;
}
_snake.Add(new Point(_width / 2, _height / 2));
_board[_snake[0].X, _snake[0].Y] = FieldType.Head;
}
// Constructor
public WhiteQueen(int row, int column, FieldType[,] board, Node node = null)
{
this.column = column;
this.row = row;
boardStatus = board;
parent = node;
listNode = new List <Node>();
}
public void Render(FieldType[,] changedRenderFields)
{
unsafe
{
for (int x = 0; x < changedRenderFields.GetLength(0); x++)
{
for (int y = 0; y < changedRenderFields.GetLength(1); y++)
{
var f = changedRenderFields[x, y];
var rect = new Rect();
rect.Height = this.blockSize;
rect.Width = this.blockSize;
rect.X = this.blockSize * x;
rect.Y = this.blockSize * y;
switch (f)
{
case FieldType.None:
{
SDL.SetRenderDrawColor(_renderer, 230, 230, 230, 205);
SDL.RenderFillRect(_renderer, &rect);
break;
}
case FieldType.Fruit1:
{
SDL.SetRenderDrawColor(_renderer, 255, 255, 0, 205);
SDL.RenderFillRect(_renderer, &rect);
break;
}
case FieldType.Border:
{
SDL.SetRenderDrawColor(_renderer, 0, 255, 0, 205);
SDL.RenderFillRect(_renderer, &rect);
break;
}
case FieldType.Snake1:
{
SDL.SetRenderDrawColor(_renderer, 255, 0, 0, 205);
SDL.RenderFillRect(_renderer, &rect);
break;
}
case FieldType.Snake2:
{
SDL.SetRenderDrawColor(_renderer, 0, 0, 255, 205);
SDL.RenderFillRect(_renderer, &rect);
break;
}
}
}
}
SDL.RenderPresent(_renderer);
}
}
public FieldState(bool passable)
{
isPassable = passable;
RoomSize = FieldManager.Instance.RoomSize;
RoadSize = FieldManager.Instance.RoadSize;
int s = FieldManager.Instance.SectionSize;
State = new FieldType[s, s];
}
public Field()
{
m = new FieldType[N, N];
for (int i = 0; i < N; i++)
{
for (int j = 0; j < N; j++)
{
m[i, j] = FieldType.Empty;
}
}
}
public FieldType[,] fieldValues; //mezőértékek
#endregion
#region Constructor
public MinefieldTable()
{
fieldValues = new FieldType[10, 10];
for (int i = 0; i < 10; ++i)
{
for (int j = 0; j < 10; ++j)
{
fieldValues[i, j] = FieldType.Empty;
}
}
fieldValues[9, 9] = FieldType.Player;
}
private Int32 _tableSize; // táblaméret
#endregion Fields
#region Constructors
public RobotGameTable(Int32 tableSize)
{
if (tableSize <= 0 || tableSize % 2 != 1)
throw new Exception("Invalid tablesize!");
_tableSize = tableSize;
_table = new FieldType[tableSize, tableSize];
_tableLock = new Boolean[tableSize, tableSize];
GetFixedPositions();
SetCenter();
SpawnRobot();
}
private void TestResult(FieldType[,] solution, FieldType[,] solved)
{
Assert.AreEqual(solution.GetLength(0), solved.GetLength(0), "Diff Lengths: Rows");
Assert.AreEqual(solution.GetLength(1), solved.GetLength(1), "Diff Lengths: Columns");
for (int i = 0; i < solution.GetLength(0); i++)
{
for (int j = 0; j < solution.GetLength(1); j++)
{
Assert.AreEqual(solution[i, j], solved[i, j], "Matrix Value diff: " + "[" + i + ", " + j + "]");
}
}
}
public BlackHoleGameTable(Int32 tableSize)
{
if (tableSize != 5 && tableSize != 7 && tableSize != 9)
throw new ArgumentException("Not supported table size.", "tableSize");
gameTable = new FieldType[tableSize, tableSize];
IsGameActive = false;
GameStatus = GameStatus.PlayerAChoose;
PlayerAScore = 0;
PlayerBScore = 0;
CoordinatesOfChosenField = Tuple.Create(-1, -1);
}
public ProximitySensor(Room room)
{
Room = room;
roomMtx = new FieldType[room.MaxX, room.MaxY];
for (int i = 0; i < room.MaxX; ++i)
{
for (int j = 0; j < room.MaxY; ++j)
{
roomMtx[i, j] = FieldType.UNKNOWN;
}
}
}
public MineField(int width, int height, IList <Point> mines, Point exit)
{
ValidateDimensions(width, height);
_grid = new FieldType[width, height];
foreach (var mine in mines)
{
ValidatePoint(mine);
SetMine(mine);
}
ValidatePoint(exit);
SetExit(exit);
}
public Robot(ProximitySensor proximitySensor, DrivingUnit drivingUnit, Room room_)
{
ProximitySensor = proximitySensor;
DrivingUnit = drivingUnit;
room = new FieldType[room_.MaxX, room_.MaxY];
for (int i = 0; i < room_.MaxX; ++i) for (int j = 0; j < room_.MaxY; ++j) {room[i,j] = FieldType.UNKNOWN;}
roomMaxX = room_.MaxX;
roomMaxY = room_.MaxY;
radius = 1;
positionX = room_.RobotX;
positionY = room_.RobotY;
algorithm1 = new RandomPathChooserAlgorithm(this);
algorithm2 = new DepthFirstSearchPathChooserAlgorithm(this);
}
public Room(String input)
{
/**
* Szoba beolvasása fájlból.
* Fájl leírása:
* MaxX MaxY
* RobotX RobotY
* Szoba leírása MaxY sorban soronként MaxX karakter: 1 - akadály, 0 üres terület
**/
string[] lines = System.IO.File.ReadAllLines(
Directory.GetParent(Directory.GetParent(Directory.GetParent(
Path.GetDirectoryName(System.AppDomain.CurrentDomain.BaseDirectory)
).FullName).FullName).FullName + "/" + input);
// Pálya méretének beolvasása
string[] row = lines[0].Split(' ');
MaxX = Int32.Parse(row[0]);
MaxY = Int32.Parse(row[1]);
room = new FieldType[MaxX, MaxY];
// Robot helyének beolvasása
row = lines[1].Split(' ');
RobotX = Int32.Parse(row[0]);
RobotY = Int32.Parse(row[1]);
// Pálya beolvasása
for (int i = 0; i < MaxX; i++)
{
for (int j = 0; j < MaxY; j++)
{
if (lines[j + 2][i] == '0')
{
room[i, j] = FieldType.DIRTY;
}
else
{
room[i, j] = FieldType.OBSTACLE;
}
}
}
}
public Table(int size)
{
_size = size;
FieldValues = new FieldType[size, size];
for (int i = 0; i < size; ++i)
{
for (int j = 0; j < size; ++j)
{
if (i == 0 || j == 0 || i == size - 1 || j == size - 1)
{
FieldValues[i, j] = FieldType.PermaWall;
}
else
{
FieldValues[i, j] = FieldType.Empty;
}
}
}
FieldValues[(size) / 2, (size) / 2] = FieldType.Magnet;
}
public Map(int width, int height)
{
rnd = new Random();
Width = width;
Height = height;
_playfield = new FieldType[width, height];
_changedData = new FieldType[width, height];
//Rand einzeichnen
for (int n = 0; n < width; n++)
{
ChangeField(n, 0, FieldType.Border);
ChangeField(n, height - 1, FieldType.Border);
}
for (int n = 0; n < height; n++)
{
ChangeField(0, n, FieldType.Border);
ChangeField(width - 1, n, FieldType.Border);
}
}
// Declare member variables here. Examples:
// Called when the node enters the scene tree for the first time.
public override void _Ready()
{
world = new FieldType[worldSizeX, worldSizeY];
for (int x = 0; x < world.GetLength(0); x++)
{
for (int y = 0; y < world.GetLength(0); y++)
{
world[x, y] = FieldType.Empty;
}
}
timer = (Timer)GetNode("Timer");
timer.Connect("timeout", this, nameof(onTick));
player = (PlayerLogic)GetNode("/root/Main/LogicWorld/PlayerLogic");
player.Connect(nameof(PlayerLogic.ChangedPosition), this, nameof(newPlayerPosition));
state = GameState.Running;
}
public void LionNonogramTest()
{
var Rows = new List <List <int> >()
{
new List <int>()
{
7
},
new List <int>()
{
9
},
new List <int>()
{
2, 4, 2
},
new List <int>()
{
2, 2
},
new List <int>()
{
2, 1, 1, 2
},
new List <int>()
{
3, 2
},
new List <int>()
{
2, 2
},
new List <int>()
{
3, 3, 1
},
new List <int>()
{
9, 1
},
new List <int>()
{
9, 1
},
new List <int>()
{
11, 2
},
new List <int>()
{
15
},
new List <int>()
{
14
},
new List <int>()
{
2, 3, 2
},
new List <int>()
{
1, 1, 1, 1, 1, 1, 1
},
};
var Columns = new List <List <int> >()
{
new List <int>()
{
4
},
new List <int>()
{
6, 4
},
new List <int>()
{
12, 1
},
new List <int>()
{
2, 1, 6
},
new List <int>()
{
2, 5, 1
},
new List <int>()
{
3, 1, 6
},
new List <int>()
{
3, 7
},
new List <int>()
{
3, 6
},
new List <int>()
{
3, 1, 5, 1
},
new List <int>()
{
2, 6
},
new List <int>()
{
12, 1
},
new List <int>()
{
6, 4
},
new List <int>()
{
4
},
new List <int>()
{
3
},
new List <int>()
{
5
},
};
Puzzle puzzle = new Puzzle(Rows, Columns);
FieldType[,] matrixSolution =
{
{ white, white, white, solid, solid, solid, solid, solid, solid, solid, white, white, white, white, white },
{ white, white, solid, solid, solid, solid, solid, solid, solid, solid, solid, white, white, white, white },
{ white, solid, solid, white, white, solid, solid, solid, solid, white, solid, solid, white, white, white },
{ white, solid, solid, white, white, white, white, white, white, white, solid, solid, white, white, white },
{ white, solid, solid, white, white, solid, white, white, solid, white, solid, solid, white, white, white },
{ white, solid, solid, solid, white, white, white, white, white, white, solid, solid, white, white, white },
{ white, solid, solid, white, white, white, white, white, white, white, solid, solid, white, white, white },
{ white, solid, solid, solid, white, white, white, white, white, solid, solid, solid, white, white, solid },
{ white, white, solid, solid, solid, solid, solid, solid, solid, solid, solid, white, white, white, solid },
{ white, white, solid, solid, solid, solid, solid, solid, solid, solid, solid, white, white, white, solid },
{ white, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, white, solid, solid },
{ solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid },
{ solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, white },
{ solid, solid, white, white, white, solid, solid, solid, white, white, white, solid, solid, white, white },
{ solid, white, solid, white, solid, white, solid, white, solid, white, solid, white, solid, white, white },
};
var solvedPuzzle = SolverEngine.Solve(puzzle);
var solvedPuzzleMatrix = solvedPuzzle.Matrix.Fields;
TestResult(matrixSolution, solvedPuzzleMatrix);
}
private int Move()
{
int points = 0;
if (column != 0 && column != 7 && row > 1)
{
if (boardStatus[row - 1, column - 1] == FieldType.Free && column > 3)
{
points = moveMid;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.WhitePawn;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
else if (boardStatus[row - 1, column - 1] == FieldType.Free && column < 4)
{
points = move;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.WhitePawn;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
if (boardStatus[row - 1, column + 1] == FieldType.Free && column > 3)
{
points = move;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column + 1] = FieldType.WhitePawn;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
else if (boardStatus[row - 1, column + 1] == FieldType.Free && column < 4)
{
points = moveMid;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column + 1] = FieldType.WhitePawn;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
else if (column == 0 && row > 1)
{
if (boardStatus[row - 1, column + 1] == FieldType.Free)
{
points = moveEdge;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column + 1] = FieldType.WhitePawn;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
else if (column == 7 && row > 1)
{
if (boardStatus[row - 1, column - 1] == FieldType.Free)
{
points = moveEdge;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.WhitePawn;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
else if (column != 0 && column != 7 && row == 1)
{
if (boardStatus[row - 1, column - 1] == FieldType.Free && column > 3)
{
points = moveMid;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
else if (boardStatus[row - 1, column - 1] == FieldType.Free && column < 4)
{
points = move;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
if (boardStatus[row - 1, column + 1] == FieldType.Free && column > 3)
{
points = move;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column + 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
else if (boardStatus[row - 1, column + 1] == FieldType.Free && column < 4)
{
points = moveMid;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column + 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
else if (column == 0 && row == 1)
{
if (boardStatus[row - 1, column + 1] == FieldType.Free)
{
points = moveEdge;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column + 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
else if (column == 7 && row == 1)
{
if (boardStatus[row - 1, column - 1] == FieldType.Free)
{
points = moveEdge;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
return(points);
}
public FieldType[,] Clone(FieldType[,] board)
{
FieldType[,] copyBoard = new FieldType[8, 8];
Array.Copy(board, copyBoard, board.Length);
return(copyBoard);
}
public void FlamingoNonogramTest()
{
var Rows = new List <List <int> >()
{
new List <int>()
{
4
},
new List <int>()
{
6
},
new List <int>()
{
3, 3
},
new List <int>()
{
7
},
new List <int>()
{
7
},
new List <int>()
{
1, 3
},
new List <int>()
{
3
},
new List <int>()
{
3, 5
},
new List <int>()
{
4, 7
},
new List <int>()
{
13
},
new List <int>()
{
13
},
new List <int>()
{
13
},
new List <int>()
{
13
},
new List <int>()
{
13
},
new List <int>()
{
11
}
};
var Columns = new List <List <int> >()
{
new List <int>()
{
4
},
new List <int>()
{
4
},
new List <int>()
{
5, 6
},
new List <int>()
{
2, 2, 9
},
new List <int>()
{
15
},
new List <int>()
{
15
},
new List <int>()
{
5, 6
},
new List <int>()
{
7
},
new List <int>()
{
8
},
new List <int>()
{
8
},
new List <int>()
{
8
},
new List <int>()
{
8
},
new List <int>()
{
8
},
new List <int>()
{
7
},
new List <int>()
{
5
}
};
Puzzle puzzle = new Puzzle(Rows, Columns);
FieldType[,] matrixSolution =
{
{ white, white, solid, solid, solid, solid, white, white, white, white, white, white, white, white, white },
{ white, solid, solid, solid, solid, solid, solid, white, white, white, white, white, white, white, white },
{ solid, solid, solid, white, solid, solid, solid, white, white, white, white, white, white, white, white },
{ solid, solid, solid, solid, solid, solid, solid, white, white, white, white, white, white, white, white },
{ solid, solid, solid, solid, solid, solid, solid, white, white, white, white, white, white, white, white },
{ solid, white, white, white, solid, solid, solid, white, white, white, white, white, white, white, white },
{ white, white, white, solid, solid, solid, white, white, white, white, white, white, white, white, white },
{ white, white, white, solid, solid, solid, white, white, solid, solid, solid, solid, solid, white, white },
{ white, white, solid, solid, solid, solid, white, solid, solid, solid, solid, solid, solid, solid, white },
{ white, white, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid },
{ white, white, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid },
{ white, white, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid },
{ white, white, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid },
{ white, white, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid },
{ white, white, white, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, solid, white },
};
var solvedPuzzle = SolverEngine.Solve(puzzle);
var solvedPuzzleMatrix = solvedPuzzle.Matrix.Fields;
TestResult(matrixSolution, solvedPuzzleMatrix);
}
public void RoseNonogramTest()
{
var Rows = new List <List <int> >()
{
new List <int>()
{
5
},
new List <int>()
{
5
},
new List <int>()
{
5
},
new List <int>()
{
3
},
new List <int>()
{
1
},
};
var Columns = new List <List <int> >()
{
new List <int>()
{
3
},
new List <int>()
{
4
},
new List <int>()
{
5
},
new List <int>()
{
4
},
new List <int>()
{
3
},
};
Puzzle puzzle = new Puzzle(Rows, Columns);
FieldType[,] matrixSolution =
{
{ solid, solid, solid, solid, solid },
{ solid, solid, solid, solid, solid },
{ solid, solid, solid, solid, solid },
{ white, solid, solid, solid, white },
{ white, white, solid, white, white },
};
var solvedPuzzle = SolverEngine.Solve(puzzle);
var solvedPuzzleMatrix = solvedPuzzle.Matrix.Fields;
TestResult(matrixSolution, solvedPuzzleMatrix);
}
private int Move()
{
int points = 0;
if (column != 0 && column != 7 && row != 0 && row != 7)
{
if (boardStatus[row + 1, column - 1] == FieldType.Free)
{
points = move;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row + 1, column - 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
if (boardStatus[row + 1, column + 1] == FieldType.Free)
{
points = move;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row + 1, column + 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
if (boardStatus[row - 1, column + 1] == FieldType.Free)
{
points = move;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column + 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
if (boardStatus[row - 1, column - 1] == FieldType.Free)
{
points = move;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
} // Center
else if (column == 0 && row == 0)
{
if (boardStatus[row + 1, column + 1] == FieldType.Free)
{
points = moveEdge;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row + 1, column + 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}// Left-Top Corner
else if (column == 7 && row == 7)
{
if (boardStatus[row - 1, column - 1] == FieldType.Free)
{
points = moveEdge;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
} // Right-Bottom Corner
else if (column == 0)
{
if (boardStatus[row + 1, column + 1] == FieldType.Free)
{
points = moveEdge;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row + 1, column + 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
if (boardStatus[row - 1, column + 1] == FieldType.Free)
{
points = moveEdge;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column + 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}// Left
else if (column == 7)
{
if (boardStatus[row + 1, column - 1] == FieldType.Free)
{
points = moveEdge;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row + 1, column - 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
if (boardStatus[row - 1, column - 1] == FieldType.Free)
{
points = moveEdge;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}// Right
else if (row == 0)
{
if (boardStatus[row + 1, column - 1] == FieldType.Free)
{
points = moveEdge;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row + 1, column - 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
if (boardStatus[row + 1, column + 1] == FieldType.Free)
{
points = moveEdge;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row + 1, column + 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}// Top
else
{
if (boardStatus[row - 1, column - 1] == FieldType.Free)
{
points = moveEdge;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
if (boardStatus[row - 1, column + 1] == FieldType.Free)
{
points = moveEdge;
FieldType[,] newBoard = Clone(boardStatus);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column + 1] = FieldType.WhiteQueen;
int newScore = points + CountScore();
Node newNode = new Node(parent, newBoard, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}// Bottom
return(points);
}
private int Hit(FieldType[,] board, int row, int column)
{
int points = 0;
if (column > 1 && column < 6 && row < 6 && row > 1) // Check if hit haven't make you out of board
{
if (board[row + 1, column - 1] == FieldType.BlackPawn || board[row + 1, column - 1] == FieldType.BlackQueen)
{
if (board[row + 2, column - 2] == FieldType.Free)
{
points = hit;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row + 1, column - 1] = FieldType.Free;
newBoard[row + 2, column - 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row + 2, column - 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
if (board[row + 1, column + 1] == FieldType.BlackPawn || board[row + 1, column + 1] == FieldType.BlackQueen)
{
if (board[row + 2, column + 2] == FieldType.Free)
{
points = hit;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row + 1, column + 1] = FieldType.Free;
newBoard[row + 2, column + 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row + 2, column + 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
if (board[row - 1, column - 1] == FieldType.BlackPawn || board[row - 1, column - 1] == FieldType.BlackQueen)
{
if (board[row - 2, column - 2] == FieldType.Free)
{
points = hit;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.Free;
newBoard[row - 2, column - 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column - 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
if (board[row - 1, column + 1] == FieldType.BlackPawn || board[row - 1, column + 1] == FieldType.BlackQueen)
{
if (board[row - 2, column + 2] == FieldType.Free)
{
points = hit;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column + 1] = FieldType.Free;
newBoard[row - 2, column + 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column + 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
} // Center
else if (column < 2 && row < 2) // Check if hit haven't make you out of board
{
if (board[row + 1, column + 1] == FieldType.BlackPawn || board[row + 1, column + 1] == FieldType.BlackQueen)
{
if (board[row + 2, column + 2] == FieldType.Free)
{
points = hitEdge;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row + 1, column + 1] = FieldType.Free;
newBoard[row + 2, column + 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row + 2, column + 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
} // Left-Top Corner
else if (column > 5 && row < 2)
{
if (board[row + 1, column - 1] == FieldType.BlackPawn || board[row + 1, column - 1] == FieldType.BlackQueen)
{
if (board[row + 2, column - 2] == FieldType.Free)
{
points = hitEdge;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row + 1, column - 1] = FieldType.Free;
newBoard[row + 2, column - 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row + 2, column - 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
} // Right-Top Corner
else if (row < 2)
{
if (board[row + 1, column - 1] == FieldType.BlackPawn || board[row + 1, column - 1] == FieldType.BlackQueen)
{
if (board[row + 2, column - 2] == FieldType.Free)
{
points = hitEdge;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row + 1, column - 1] = FieldType.Free;
newBoard[row + 2, column - 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row + 2, column - 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
if (board[row + 1, column + 1] == FieldType.BlackPawn || board[row + 1, column + 1] == FieldType.BlackQueen)
{
if (board[row + 2, column + 2] == FieldType.Free)
{
points = hitEdge;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row + 1, column + 1] = FieldType.Free;
newBoard[row + 2, column + 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row + 2, column + 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
}// Top
else if (column < 2 && row > 5)
{
if (board[row - 1, column + 1] == FieldType.BlackPawn || board[row - 1, column + 1] == FieldType.BlackQueen)
{
if (board[row - 2, column + 2] == FieldType.Free)
{
points = hitEdge;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column + 1] = FieldType.Free;
newBoard[row - 2, column + 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column + 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
} // Bottom-Left Corner
else if (column > 5 && row > 5)
{
if (board[row - 1, column - 1] == FieldType.BlackPawn || board[row - 1, column - 1] == FieldType.BlackQueen)
{
if (board[row - 2, column - 2] == FieldType.Free)
{
points = hitEdge;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.Free;
newBoard[row - 2, column - 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column - 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
} // Bottom-Right Corner
else if (row > 5)
{
if (board[row - 1, column - 1] == FieldType.BlackPawn || board[row - 1, column - 1] == FieldType.BlackQueen)
{
if (board[row - 2, column - 2] == FieldType.Free)
{
points = hitEdge;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.Free;
newBoard[row - 2, column - 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column - 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
if (board[row - 1, column + 1] == FieldType.BlackPawn || board[row - 1, column + 1] == FieldType.BlackQueen)
{
if (board[row - 2, column + 2] == FieldType.Free)
{
points = hitEdge;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column + 1] = FieldType.Free;
newBoard[row - 2, column + 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column + 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
} // Bottom
else if (column < 2)
{
if (board[row - 1, column + 1] == FieldType.BlackPawn || board[row - 1, column + 1] == FieldType.BlackQueen)
{
if (board[row - 2, column + 2] == FieldType.Free)
{
points = hitEdge;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column + 1] = FieldType.Free;
newBoard[row - 2, column + 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column + 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
if (board[row + 1, column + 1] == FieldType.BlackPawn || board[row + 1, column + 1] == FieldType.BlackQueen)
{
if (board[row + 2, column + 2] == FieldType.Free)
{
points = hitEdge;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row + 1, column + 1] = FieldType.Free;
newBoard[row + 2, column + 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row + 2, column + 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
} // Leftside
else if (column > 5)
{
if (board[row - 1, column - 1] == FieldType.BlackPawn || board[row - 1, column - 1] == FieldType.BlackQueen)
{
if (board[row - 2, column - 2] == FieldType.Free)
{
points = hitEdge;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.Free;
newBoard[row - 2, column - 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column - 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
if (board[row + 1, column - 1] == FieldType.BlackPawn || board[row + 1, column - 1] == FieldType.BlackQueen)
{
if (board[row + 2, column - 2] == FieldType.Free)
{
points = hitEdge;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row + 1, column - 1] = FieldType.Free;
newBoard[row + 2, column - 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row + 2, column - 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
}// Rightside
return(points);
}
public RightWallTracingStrategy(MapVector vertexVertexPosition, FieldType[,] fields)
{
_vertexPosition = vertexVertexPosition;
_fields = fields;
}
public UpWallTracingStrategy(MapVector fieldPosition, FieldType[,] fields)
{
_fieldPosition = fieldPosition;
_fields = fields;
}
public Node(Node parent = null, FieldType[,] currentBoard = null, int score = 0)
{
this.parent = parent;
this.currentBoard = currentBoard;
this.score = score;
}
private int Hit(FieldType[,] board, int row, int column)
{
int points = 0;
if (column > 1 && column < 4 && row > 2) // Check if hit haven't make you out of board
{
if (board[row - 1, column - 1] == FieldType.BlackPawn || board[row - 1, column - 1] == FieldType.BlackQueen)
{
if (board[row - 2, column - 2] == FieldType.Free)
{
points = hit;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.Free;
newBoard[row - 2, column - 2] = FieldType.WhitePawn;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column - 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
if (board[row - 1, column + 1] == FieldType.BlackPawn || board[row - 1, column + 1] == FieldType.BlackQueen)
{
if (board[row - 2, column + 2] == FieldType.Free)
{
points = hitMid;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column + 1] = FieldType.Free;
newBoard[row - 2, column + 2] = FieldType.WhitePawn;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column + 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
}
else if (column > 3 && column < 6 && row > 2) // Check if hit haven't make you out of board
{
if (board[row - 1, column - 1] == FieldType.BlackPawn || board[row - 1, column - 1] == FieldType.BlackQueen)
{
if (board[row - 2, column - 2] == FieldType.Free)
{
points = hitMid;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.Free;
newBoard[row - 2, column - 2] = FieldType.WhitePawn;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column - 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
if (board[row - 1, column + 1] == FieldType.BlackPawn || board[row - 1, column + 1] == FieldType.BlackQueen)
{
if (board[row - 2, column + 2] == FieldType.Free)
{
points = hit;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column + 1] = FieldType.Free;
newBoard[row - 2, column + 2] = FieldType.WhitePawn;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column + 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
}
else if (column < 2 && row > 2)
{
if (board[row - 1, column + 1] == FieldType.BlackPawn || board[row - 1, column + 1] == FieldType.BlackQueen)
{
if (board[row - 2, column + 2] == FieldType.Free)
{
points = hitEdge;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column + 1] = FieldType.Free;
newBoard[row - 2, column + 2] = FieldType.WhitePawn;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column + 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
}
else if (row > 2)
{
if (board[row - 1, column - 1] == FieldType.BlackPawn || board[row - 1, column - 1] == FieldType.BlackQueen)
{
if (board[row - 2, column - 2] == FieldType.Free)
{
points = hitEdge;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.Free;
newBoard[row - 2, column - 2] = FieldType.WhitePawn;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column - 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
}
else if (column > 1 && column < 4 && row == 2) // Check if hit haven't make you out of board
{
if (board[row - 1, column - 1] == FieldType.BlackPawn || board[row - 1, column - 1] == FieldType.BlackQueen)
{
if (board[row - 2, column - 2] == FieldType.Free)
{
points = hit;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.Free;
newBoard[row - 2, column - 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column - 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
if (board[row - 1, column + 1] == FieldType.BlackPawn || board[row - 1, column + 1] == FieldType.BlackQueen)
{
if (board[row - 2, column + 2] == FieldType.Free)
{
points = hitMid;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column + 1] = FieldType.Free;
newBoard[row - 2, column + 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column + 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
}
else if (column > 3 && column < 6 && row == 2) // Check if hit haven't make you out of board
{
if (board[row - 1, column - 1] == FieldType.BlackPawn || board[row - 1, column - 1] == FieldType.BlackQueen)
{
if (board[row - 2, column - 2] == FieldType.Free)
{
points = hitMid;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.Free;
newBoard[row - 2, column - 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column - 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
if (board[row - 1, column + 1] == FieldType.BlackPawn || board[row - 1, column + 1] == FieldType.BlackQueen)
{
if (board[row - 2, column + 2] == FieldType.Free)
{
points = hit;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column + 1] = FieldType.Free;
newBoard[row - 2, column + 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column + 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
}
else if (column < 2 && row == 2)
{
if (board[row - 1, column + 1] == FieldType.BlackPawn || board[row - 1, column + 1] == FieldType.BlackQueen)
{
if (board[row - 2, column + 2] == FieldType.Free)
{
points = hitEdge;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column + 1] = FieldType.Free;
newBoard[row - 2, column + 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column + 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
}
else if (row == 2)
{
if (board[row - 1, column - 1] == FieldType.BlackPawn || board[row - 1, column - 1] == FieldType.BlackQueen)
{
if (board[row - 2, column - 2] == FieldType.Free)
{
points = hitEdge;
FieldType[,] newBoard = Clone(board);
newBoard[row, column] = FieldType.Free;
newBoard[row - 1, column - 1] = FieldType.Free;
newBoard[row - 2, column - 2] = FieldType.WhiteQueen;
boardAfter = Clone(newBoard);
// Multicapturing
if (Hit(Clone(boardAfter), row - 2, column - 2) != 0)
{
points = points + hitMulti;
}
int newScore = points + CountScore();
Node newNode = new Node(parent, boardAfter, newScore); // Make new node
listNode.Add(newNode); // Add to list of possible moves
}
}
}
return(points);
}
