public virtual bool isValidMove(Coordinate i_Target)
{
bool isValid = false;
if (i_Target != null)
{
eVerticalDirections vertical = movesForwardOrBackward(this, i_Target);
eHorizontalDirections horizontal = movesRightOrLeft(this, i_Target);
Coin copy = new Coin(CoinType, Board);
copy.Coordinates.CopyCoordinates(Coordinates);
Coordinate newSquare = GetNextSquare(ref copy, vertical, horizontal);
if (newSquare.Equals(i_Target))
{
isValid = !isValid; // true
}
else if (IsAbleToEat(newSquare, out Coordinate target))
{
isValid = !isValid; // true
}
}
return(isValid);
}
public static eHorizontalDirections movesRightOrLeft(
Coin i_Coin,
Coordinate i_target)
{
eHorizontalDirections move = eHorizontalDirections.SamePlace;
int targetColumn = i_target.Column;
int sourceColumn = i_Coin.Coordinates.Column;
int diff = targetColumn - sourceColumn;
if (diff != 0)
{
// This coin belongs to the first player.
if (i_Coin.CoinType == eCoinType.O)
{
move = (diff < 0) ?
eHorizontalDirections.Right :
eHorizontalDirections.Left;
}
// This coin belongs to the second player
// (moves from down ---> up).
else
{
move = (diff > 0) ?
eHorizontalDirections.Right :
eHorizontalDirections.Left;
}
}
return(move);
}
public virtual bool IsAbleToEat(Coordinate i_Rival, out Coordinate o_Target)
{
bool isEatingPossibility = false;
eVerticalDirections forwordOrBackword = movesForwardOrBackward(this, i_Rival);
eHorizontalDirections rightOrLeft = movesRightOrLeft(this, i_Rival);
Coordinate currentSquare = new Coordinate();
currentSquare.CopyCoordinates(Coordinates);
o_Target = new Coordinate();
Coin copy = new Coin(CoinType, Board);
copy.Coordinates.CopyCoordinates(Coordinates);
currentSquare = GetNextSquare(ref copy, forwordOrBackword, rightOrLeft);
// Eating possibility detected
if (i_Rival.Equals(currentSquare) &&
Board.GetCoinType(currentSquare) != CoinType && Board.GetCoinType(currentSquare) != eCoinType.None)
{
copy.Coordinates.CopyCoordinates(currentSquare);
currentSquare = GetNextSquare(ref copy, forwordOrBackword, rightOrLeft);
if (Board.IsEmptyValidSquare(currentSquare))
{
isEatingPossibility = !isEatingPossibility; // true
o_Target.CopyCoordinates(currentSquare);
}
}
return(isEatingPossibility);
}
public override bool HasEatingMoves()
{
bool hasEatingMoves = false;
foreach (Coordinate currentCoordinate in AvailableCoordinates)
{
eVerticalDirections vertical = movesForwardOrBackward(this, currentCoordinate);
eHorizontalDirections horizontal = movesRightOrLeft(this, currentCoordinate);
if (IsEatingMove(currentCoordinate, out Coordinate rival))
{
hasEatingMoves = !hasEatingMoves; // true
}
}
return(hasEatingMoves);
}
public override bool IsEatingMove(Coordinate i_Target, out Coordinate o_RivalCoord)
{
bool isEatingMove = false;
o_RivalCoord = new Coordinate();
eVerticalDirections vertical = movesForwardOrBackward(this, i_Target);
eHorizontalDirections horizontal = movesRightOrLeft(this, i_Target);
Coordinate prevSquare = new Coordinate();
prevSquare.CopyCoordinates(Coordinates);
Coin kingCopy = new Coin(CoinType, Board);
kingCopy.Coordinates.CopyCoordinates(Coordinates);
Coordinate nextSquare = GetNextSquare(ref kingCopy, vertical, horizontal);
kingCopy.Coordinates = prevSquare;
while (Board.IsEmptyValidSquare(nextSquare))
{
prevSquare.CopyCoordinates(nextSquare);
nextSquare = GetNextSquare(ref kingCopy, vertical, horizontal);
}
if (kingCopy.IsAbleToEat(nextSquare, out Coordinate target))
{
isEatingMove = !isEatingMove; // true
isEatingMove = (isEatingMove && i_Target.Equals(target));
if (isEatingMove)
{
o_RivalCoord.CopyCoordinates(nextSquare);
}
}
return(isEatingMove);
}
public override bool isValidMove(Coordinate i_Target)
{
bool isValid = false;
if (i_Target != null)
{
eVerticalDirections vertical = movesForwardOrBackward(this, i_Target);
eHorizontalDirections horizontal = movesRightOrLeft(this, i_Target);
Coordinate prevSquare = new Coordinate();
prevSquare.CopyCoordinates(Coordinates);
Coin kingCopy = new Coin(CoinType, Board);
kingCopy.Coordinates.CopyCoordinates(Coordinates);
Coordinate nextSquare = GetNextSquare(ref kingCopy, vertical, horizontal);
kingCopy.Coordinates = prevSquare;
while (Board.IsValid(nextSquare))
{
if (Board.IsEmptySquare(nextSquare) && nextSquare.Equals(i_Target))
{
isValid = !isValid; // true
break;
}
else if (kingCopy.IsAbleToEat(nextSquare, out Coordinate target) &&
i_Target.Equals(target))
{
isValid = !isValid; // true
break;
}
prevSquare.CopyCoordinates(nextSquare);
nextSquare = GetNextSquare(ref kingCopy, vertical, horizontal);
}
}
return(isValid);
}
/*********************************************** Virtual Methods ************************************************/
/// <summary>
/// Returns true iff it is possible to go to the i_Target coordinate AND eat a rival coin during.
/// </summary>
/// <param name="i_Target"></param>
/// <returns></returns>
public virtual bool IsEatingMove(Coordinate i_Target, out Coordinate o_RivalCoord)
{
bool isEatingMove = false;
eVerticalDirections vertical = movesForwardOrBackward(this, i_Target);
eHorizontalDirections horizontal = movesRightOrLeft(this, i_Target);
o_RivalCoord = null;
Coin copy = new Coin(CoinType, Board);
copy.Coordinates.CopyCoordinates(Coordinates);
if (vertical == eVerticalDirections.Forword && horizontal != eHorizontalDirections.SamePlace)
{
Coordinate nextSquare = GetNextSquare(ref copy, vertical, horizontal);
if (IsAbleToEat(nextSquare, out Coordinate target))
{
isEatingMove = !isEatingMove;
isEatingMove = (isEatingMove && i_Target.Equals(target));
o_RivalCoord = new Coordinate();
o_RivalCoord.CopyCoordinates(nextSquare);
}
}
return(isEatingMove);
}
public override bool IsAbleToEat(Coordinate i_Rival, out Coordinate o_Target)
{
o_Target = new Coordinate();
Coordinate prevSquare = new Coordinate();
prevSquare.CopyCoordinates(Coordinates);
bool isEatingPossibility = false;
eVerticalDirections forwordOrBackword = movesForwardOrBackward(this, i_Rival);
eHorizontalDirections rightOrLeft = movesRightOrLeft(this, i_Rival);
Coordinate currentSquare = new Coordinate();
Coin kingCopy = new Coin(CoinType, Board);
kingCopy.Coordinates.CopyCoordinates(Coordinates);
currentSquare = GetNextSquare(ref kingCopy, forwordOrBackword, rightOrLeft);
kingCopy.Coordinates = prevSquare;
while (currentSquare != null && Board.IsEmptyValidSquare(currentSquare))
{
prevSquare.CopyCoordinates(currentSquare);
currentSquare = GetNextSquare(ref kingCopy, forwordOrBackword, rightOrLeft);
}
if (Board.IsValid(currentSquare))
{
isEatingPossibility = kingCopy.IsAbleToEat(currentSquare, out Coordinate target);
if (isEatingPossibility)
{
o_Target.CopyCoordinates(target);
}
}
return(isEatingPossibility);
}
private List <Coordinate> getNextMovesByDirections(eVerticalDirections i_Vertical, eHorizontalDirections i_Horizontal)
{
List <Coordinate> moves = new List <Coordinate>();
Coordinate prevSquare = new Coordinate();
prevSquare.CopyCoordinates(Coordinates);
Coin kingCopy = new KingCoin(CoinType, Board);
kingCopy.Coordinates.CopyCoordinates(Coordinates);
Coordinate nextSquare = GetNextSquare(ref kingCopy, i_Vertical, i_Horizontal);
kingCopy.Coordinates = prevSquare;
while (Board.IsValid(nextSquare))
{
if (Board.IsEmptySquare(nextSquare))
{
moves.Add(nextSquare);
}
else if (kingCopy.IsAbleToEat(nextSquare, out Coordinate target))
{
moves.Add(target);
break;
}
else
{
break;
}
prevSquare.CopyCoordinates(nextSquare);
nextSquare = GetNextSquare(ref kingCopy, i_Vertical, i_Horizontal);
}
return(moves);
}
/// <summary>
/// Gets the next coordinate on the board in relevence to the given i_Coin,
/// and with respect to the vertical and horizonatl directions.
/// </summary>
/// <param name="i_Coin"></param>
/// <param name="i_Vertical"></param>
/// <param name="i_Horizontal"></param>
/// <returns></returns>
public static Coordinate GetNextSquare(ref Coin i_Coin, eVerticalDirections i_Vertical, eHorizontalDirections i_Horizontal) // Added ref 07.06.18
{
Coordinate newCoord = new Coordinate();
if (i_Coin != null)
{
if (i_Vertical == eVerticalDirections.Forword)
{
if (i_Horizontal == eHorizontalDirections.Right)
{
newCoord = NextForwordRight(i_Coin);
}
else if (i_Horizontal == eHorizontalDirections.Left)
{
newCoord = NextForwordLeft(i_Coin);
}
}
else if (i_Vertical == eVerticalDirections.Backword)
{
if (i_Horizontal == eHorizontalDirections.Right)
{
newCoord = NextBackwordRight(i_Coin);
}
else if (i_Horizontal == eHorizontalDirections.Left)
{
newCoord = NextBackwordLeft(i_Coin);
}
}
}
return(newCoord);
}
