public Tile(Tile t)
{
Type = t.Type;
State = t.State;
Row = t.Row;
Col = t.Col;
PossibleDirections = t.PossibleDirections;
}
public Board(Board b)
{
Type = b.Type;
Pieces = new Tile[b.NumRows,b.NumCols];
for (int i = 0; i < NumRows; i++)
{
for (int j = 0; j < NumCols; j++)
{
Pieces[i,j] = new Tile(b.Pieces[i,j]);
}
}
}
private bool MakePlayerMove(Tile start, Tile dest)
{
Direction d = Board.GetDirection(start, dest);
// check whether the direction has already been used
// and whether moving was successful
var move = GameBoard.MovePiece(start, dest);
if (!CurrentMoveChain.Contains(d) && move!=null)
{
//CurrentMoveChain.Add(d);
if (move.CapturedTiles.Keys.Count > 1)
{
possibleMove = move;
GameBoard.MakeMove(move, move.CapturedTiles.Keys.First());
}
else
{
//CurrentPlayerTurnState = PlayerTurnState.Moved;
if (move.CapturedTiles.Keys.Any())
{
var dir = move.CapturedTiles.Keys.First();
GameBoard.MakeMove(move, dir);
}
}
EndTurn();
Console.WriteLine("Added "+ d.ToString());
return true;
}
return false;
}
public bool AreNeighbors(Tile a, Tile b)
{
// TODO: Use better implementation
return (GetNeighbors(a.Row, a.Col).Contains(b));
}
private void EndTurn()
{
CurrentPlayerTurnState = PlayerTurnState.NoMove;
SelectedPiece = null;
CurrentPlayer = Player.Computer;
possibleMove = null;
}
private void HandlePieceClick(int x, int y)
{
var tile = ClickedOnTile(x, y);
switch (CurrentPlayerTurnState)
{
case PlayerTurnState.NoMove:
Console.WriteLine("NoMove");
if (tile != null && tile.State != TileState.Empty) // Player clicked on a piece
{
tile.State = TileState.Selected;
CurrentPlayerTurnState = PlayerTurnState.PieceSelected;
SelectedPiece = tile;
}
break;
case PlayerTurnState.PieceSelected:
Console.WriteLine("PieceSelected");
if (tile != null && tile.State == TileState.Empty) // Player clicked on empty spot
{
bool legal = MakePlayerMove(SelectedPiece, tile);
if (!legal)
{
// TODO: Display error message
Console.WriteLine("Illegal move");
return;
}
CurrentPlayerTurnState = PlayerTurnState.Moved;
}
break;
case PlayerTurnState.SelectCapture:
Console.WriteLine("SelectCapture");
if (possibleMove != null)
{
}
break;
case PlayerTurnState.Moved:
if(tile != null){}
break;
}
}
public Move(Tile t, Direction d, IDictionary<Direction, ICollection<Tile>> captured)
{
startTile = t;
direction = d;
CapturedTiles = captured;
}
public static Direction GetDirection(Tile start, Tile dest)
{
Direction d = new Direction();
int x = dest.Col - start.Col;
int y = dest.Row - start.Row;
if (x < 0) // left
{
d |= Direction.Left;
}
else if (x > 0) // right
{
d |= Direction.Right;
}
if (y < 0) // up
{
d |= Direction.Up;
}
else if (y > 0) // down
{
d |= Direction.Down;
}
return d;
}
private void BuildBoard(int r, int c)
{
Pieces = new Tile[r, c];
PopulateMovements();
PopulatePieces();
}
private ICollection<Tile> GetPossibleDestinations(Tile t)
{
return GetPossibleDestinations(t.Row, t.Col);
}
public bool TileExistsInDirection(Tile start, Direction d)
{
int xChange = 0;
int yChange = 0;
if (start.Type == TileMvt.Adjacent
&& GetTileMvt(d) == TileMvt.Diagonal)
{
return false;
}
if (d.HasFlag(Direction.Up))
{
yChange += -1;
}
if (d.HasFlag(Direction.Down))
{
yChange += 1;
}
if (d.HasFlag(Direction.Left))
{
xChange += -1;
}
if (d.HasFlag(Direction.Right))
{
xChange += 1;
}
int newRow = start.Row + yChange;
int newCol = start.Col + xChange;
if (!PieceExists(newRow, newCol)) return false;
return true;
}
public IDictionary<Direction, ICollection<Tile>> GetCapturablePieces(Tile start, Direction dir)
{
var capturable = new Dictionary<Direction, ICollection<Tile>>();
var piece = GetTileInDirection(start, dir);
if(piece != null)
{
while (IsCapturablePiece(start, GetTileInDirection(piece, dir)))
{
var target = GetTileInDirection(piece, dir);
if (!capturable.ContainsKey(dir))
{
capturable[dir] = new List<Tile>();
}
capturable[dir].Add(target);
piece = target;
}
}
var oppDir = GetOppositeDirection(dir);
piece = start;
if(piece != null)
{
while (IsCapturablePiece(start, GetTileInDirection(piece, oppDir)))
{
var target = GetTileInDirection(piece, oppDir);
if (!capturable.ContainsKey(oppDir))
{
capturable[oppDir] = new List<Tile>();
}
capturable[oppDir].Add(target);
piece = target;
}
}
return capturable;
}
public Move MovePiece(Tile start, Tile dest)
{
var state = start.State == TileState.Selected || start.State == TileState.White ?
TileState.White : TileState.Black;
var dir = GetDirection(start, dest);
var move = new Move(start, dir, GetCapturablePieces(start, dir));
// Validate
if (GetPossibleMoves(state).Contains(move))
{
int startR = move.startTile.Row;
int startC = move.startTile.Col;
int destR = dest.Row;
int destC = dest.Col;
Pieces[startR, startC].State = TileState.Empty;
Pieces[destR, destC].State = state;
return move;
}
return null;
}
public bool IsPaika(Tile start, Direction dir)
{
return IsPaika(start, GetTileInDirection(start, dir));
}
public bool IsPaika(Tile start, Tile dest)
{
Direction d = GetDirection(start, dest);
var tileInDir = GetTileInDirection(dest, d);
var tileInOppDir = GetTileInDirection(start, GetOppositeDirection(d));
// Check if in both directions tiles are empty or nonexistant
return !( IsCapturablePiece(start, tileInDir)
|| IsCapturablePiece(start, tileInOppDir));
}
public bool IsCapturablePiece(Tile start, Tile target)
{
if (target == null) return false;
TileState a = start.State;
TileState b = target.State;
if (a == TileState.Selected) a = TileState.White;
if (b == TileState.Selected) b = TileState.White;
return (a == TileState.White && b == TileState.Black
|| a == TileState.Black && b == TileState.White);
}
public MoveType GetMoveType(Tile start, Tile dest)
{
if (IsPaika(start, dest))
{
return MoveType.Paika;
}
else return MoveType.Capturing;
}
