public void PrintCommand(int CommandNumber)
{
if (CommandNumber < 9)
{
int LargeX = CurrentBoard % 3;
int LargeY = CurrentBoard / 3;
int SmallX = CommandNumber % 3;
int SmallY = CommandNumber / 3;
int BoardSize = (3 * buttonSize) + (2 * buttonPadding) + boardPadding;
int PointX = (SmallX + 1) * buttonPadding + SmallX * buttonSize + LargeX * BoardSize;
int PointY = (SmallY + 1) * buttonPadding + SmallY * buttonSize + LargeY * BoardSize;
Point Temp = new Point(PointX, PointY);
if (TurnID == 0)
{
PlacedX[PointerX] = Temp;
PointerX += 1;
TurnID++;
}
else if (TurnID == 1)
{
PlacedO[PointerO] = Temp;
PointerO += 1;
TurnID--;
}
CurrentBoard = CommandNumber;
}
else
{
CurrentBoard = (CommandNumber - 9);
}
BoardBox.Invalidate();
}
public void SetupBoard()
{
PointerX = 0;
PointerO = 0;
CurrentBoard = -1;
TurnID = 0;
SelectFlag.Text = "Choose a board";
UltSim.Start();
BoardBox.Invalidate();
if (PlayerMode == 2)
{
CC.StartRound(0, 1);
CC.StartRound(1, 2);
int Temporary = 0;
while (Temporary < 150)
{
if (!MUI.CurrentSim.Finished())
{
MUI.AiMove();
}
else
{
break;
}
Temporary++;
}
}
}
//box1 and box2 are from same palyer and they are same piece
bool isPair(BoardBox box1, BoardBox box2)
{
if (box1 == null || box2 == null)
{
return(false);
}
if (box1.boxContent != BoxContent.Piece || box2.boxContent != BoxContent.Piece)
{
return(false);
}
return(box1.currentPiece.owner == box2.currentPiece.owner && box1.currentPiece.type == box2.currentPiece.type);
}
void positionBox(BoardBox box)
{
float xPos = 0.0f;
float yPos = 0.0f;
float widthBox = box.gameObject.GetComponent <RectTransform>().rect.width;
float heightBox = box.gameObject.GetComponent <RectTransform>().rect.height;
//board locate at center of the screen
//relative_column and relative_row shows how far this box to the center
float relative_column = (float)box.colNum + 0.5f - (float)amtColumns / 2.0f;
float relative_row = ((float)box.rowNum + 0.5f - (float)amtRows / 2.0f) * -1.0f;
xPos = box.gameObject.GetComponentInParent <Transform>().position.x + (widthBox * relative_column);
yPos = box.gameObject.GetComponentInParent <Transform>().position.y + (heightBox * relative_row);
box.gameObject.transform.position = new Vector3(xPos, yPos, 0.0f);
}
private void SwapBoard(int Board)
{
if (!UltSim.Finished())
{
if (PlayerMode == 0 || PlayerMode == 1)
{
object[] Move = new object[1];
object[] TempMove = new object[1];
TempMove[0] = (double)(Board + 9);
Move[0] = TempMove;
UltSim.SetCommand(Move);
if (UltSim.ReturnChosenCommand() == Board + 9)
{
CurrentBoard = Board;
SelectFlag.Text = "";
BoardBox.Invalidate();
}
}
}
}
public void processPlay(BoardBox box)
{
// check if player played three in a row
if (checkForSequence(box))
{
// played a sequence, factor multiplier in
box.isSequence = true;
currentPlayer.score -= 3;
currentPlayer.score += 6;
}
// check if player trumped other player
checkForTrump(box);
// update score UI
UIManager.instance.p1ScoreText.text = "P1: " + player1.score;
UIManager.instance.p2ScoreText.text = "P2: " + player2.score;
// swap current player
turn();
}
public void OnClickBox(BoardBox clickedBox)
{
PlayerColor curColor = GameManager.instance.currentPlayer.color;
//Debug.Log(GameManager.instance.currentPlayer);
if (GameManager.instance.status == GameStatus.Fight)
{
if (clickedBox.boxContent == BoxContent.Barrier)
{
StartCoroutine(flashErrorText("Can't place anything in a box with a barrier!"));
return;
}
int buffer = 0;
if (curColor == PlayerColor.Blue)
{
buffer += 3;
}
if (clickedBox.boxContent == BoxContent.Empty)
{
GameObject newPiece = Instantiate(piecePrefab, clickedBox.transform);
clickedBox.GetComponent <Image>().sprite = GameManager.instance.pieceSprites[(int)GameManager.instance.currentTypeMode + buffer];
clickedBox.boxContent = BoxContent.Piece;
clickedBox.currentPiece = newPiece.GetComponent <Piece>();
++GameManager.instance.currentPlayer.score;
GameManager.instance.processPlay(clickedBox);
if (GameManager.instance.checkGameOver())
{
//game is over right now, no place to place any piece now.
int res = GameManager.instance.gameOver();
if (res == 0)
{
p1Win.gameObject.SetActive(true);
}
else if (res == 1)
{
p2Win.gameObject.SetActive(true);
}
else if (res == 2)
{
p1Win.gameObject.SetActive(true);
p2Win.gameObject.SetActive(true);
}
startGameButton.interactable = true;
}
}
}
else if (GameManager.instance.status == GameStatus.SetBarrier)
{
if (clickedBox.boxContent == BoxContent.Empty && GameManager.instance.countBarrier < GameManager.instance.maxBarriers)
{
//GameObject newPiece = Instantiate(piecePrefab, clickedBox.transform);
clickedBox.GetComponent <Image>().sprite = GameManager.instance.pieceSprites[6];
//dont set box content here, just remember all the barriers
clickedBox.boxContent = BoxContent.Barrier;
GameManager.instance.countBarrier++;
if (curColor == PlayerColor.Blue)
{
clickedBox.barrierInfo[0] = true;
}
else
{
clickedBox.barrierInfo[1] = true;
}
}
else if (clickedBox.boxContent == BoxContent.Barrier)
{
clickedBox.GetComponent <Image>().sprite = GameManager.instance.pieceSprites[7];
clickedBox.boxContent = BoxContent.Empty;
if (curColor == PlayerColor.Blue)
{
clickedBox.barrierInfo[0] = false;
}
else
{
clickedBox.barrierInfo[1] = false;
}
GameManager.instance.countBarrier--;
}
}
}
void checkForTrump(BoardBox box)
{
BoardBox barrierBox = null;
if (box.rowNum + 2 < amtRows)
{
BoardBox right = board.board[box.rowNum + 1][box.colNum];
if (right.boxContent == BoxContent.Piece)
{
if (right.currentPiece.owner != currentPlayer && doesTrump(box.currentPiece, right.currentPiece) && right.isSequence)
{
BoardBox rightRight = board.board[box.rowNum + 2][box.colNum];
if (isPair(box, rightRight))
{
// change sprite of middle box to a barrier
right.GetComponent <Image>().sprite = barrierSprite;
barrierBox = right;
right.currentPiece.owner.score -= 2;
// refactor the opposing player's score & fix booleans
right.isSequence = false;
while (right.colNum + 1 < amtColumns && board.board[right.rowNum][right.colNum + 1].boxContent != BoxContent.Empty)
{
if (isPair(right, board.board[right.rowNum][right.colNum + 1]))
{
--right.currentPiece.owner.score;
board.board[right.rowNum][right.colNum + 1].isSequence = false;
}
else
{
break;
}
right = board.board[right.rowNum][right.colNum + 1];
}
right = board.board[box.rowNum + 1][box.colNum];
while (right.colNum - 1 >= 0 && board.board[right.rowNum][right.colNum - 1].boxContent != BoxContent.Empty)
{
if (isPair(right, board.board[right.rowNum][right.colNum - 1]))
{
--right.currentPiece.owner.score;
board.board[right.rowNum][right.colNum - 1].isSequence = false;
}
else
{
break;
}
right = board.board[right.rowNum][right.colNum - 1];
}
barrierBox.boxContent = BoxContent.Barrier;
barrierBox.currentPiece = null;
return;
}
}
}
}
if (box.rowNum - 2 >= 0)
{
BoardBox left = board.board[box.rowNum - 1][box.colNum];
if (left.boxContent == BoxContent.Piece)
{
if (left.currentPiece.owner != currentPlayer && doesTrump(box.currentPiece, left.currentPiece) && left.isSequence)
{
BoardBox leftLeft = board.board[box.rowNum - 2][box.colNum];
if (isPair(box, leftLeft))
{
// change sprite of middle box to a barrier
left.GetComponent <Image>().sprite = barrierSprite;
barrierBox = left;
left.currentPiece.owner.score -= 2;
// refactor the opposing player's score
left.isSequence = false;
while (left.colNum + 1 < amtColumns && board.board[left.rowNum][left.colNum + 1].boxContent != BoxContent.Empty)
{
if (isPair(left, board.board[left.rowNum][left.colNum + 1]))
{
--left.currentPiece.owner.score;
board.board[left.rowNum][left.colNum + 1].isSequence = false;
}
else
{
break;
}
left = board.board[left.rowNum][left.colNum + 1];
}
left = board.board[box.rowNum - 1][box.colNum];
while (left.colNum - 1 >= 0 && board.board[left.rowNum][left.colNum - 1].boxContent != BoxContent.Empty)
{
if (isPair(left, board.board[left.rowNum][left.colNum - 1]))
{
--left.currentPiece.owner.score;
board.board[left.rowNum][left.colNum - 1].isSequence = false;
}
else
{
break;
}
left = board.board[left.rowNum][left.colNum - 1];
}
barrierBox.boxContent = BoxContent.Barrier;
barrierBox.currentPiece = null;
return;
}
}
}
}
if (box.colNum + 2 < amtColumns)
{
BoardBox up = board.board[box.rowNum][box.colNum + 1];
if (up.boxContent == BoxContent.Piece)
{
if (up.currentPiece.owner != currentPlayer && doesTrump(box.currentPiece, up.currentPiece) && up.isSequence)
{
BoardBox upUp = board.board[box.rowNum][box.colNum + 2];
if (isPair(box, upUp))
{
// change sprite of middle box to a barrier
up.GetComponent <Image>().sprite = barrierSprite;
barrierBox = up;
up.currentPiece.owner.score -= 2;
// refactor the opposing player's score
up.isSequence = false;
while (up.rowNum + 1 < amtRows && board.board[up.rowNum + 1][up.colNum].boxContent != BoxContent.Empty)
{
if (isPair(up, board.board[up.rowNum + 1][up.colNum]))
{
--up.currentPiece.owner.score;
board.board[up.rowNum + 1][up.colNum].isSequence = false;
}
else
{
break;
}
up = board.board[up.rowNum + 1][up.colNum];
}
up = board.board[box.rowNum][box.colNum + 1];
while (up.rowNum - 1 >= 0 && board.board[up.rowNum - 1][up.colNum].boxContent != BoxContent.Empty)
{
if (isPair(up, board.board[up.rowNum - 1][up.colNum]))
{
--up.currentPiece.owner.score;
board.board[up.rowNum - 1][up.colNum].isSequence = false;
}
else
{
break;
}
up = board.board[up.rowNum - 1][up.colNum];
}
barrierBox.boxContent = BoxContent.Barrier;
barrierBox.currentPiece = null;
return;
}
}
}
}
if (box.colNum - 2 >= 0)
{
BoardBox down = board.board[box.rowNum][box.colNum - 1];
if (down.boxContent == BoxContent.Piece)
{
if (down.currentPiece.owner != currentPlayer && doesTrump(box.currentPiece, down.currentPiece) && down.isSequence)
{
BoardBox downDown = board.board[box.rowNum][box.colNum - 2];
if (isPair(box, downDown))
{
// change sprite of middle box to a barrier
down.GetComponent <Image>().sprite = barrierSprite;
barrierBox = down;
down.currentPiece.owner.score -= 2;
// refactor the opposing player's score
down.isSequence = false;
while (down.rowNum + 1 < amtRows && board.board[down.rowNum + 1][down.colNum].boxContent != BoxContent.Empty)
{
if (isPair(down, board.board[down.rowNum + 1][down.colNum]))
{
--down.currentPiece.owner.score;
board.board[down.rowNum + 1][down.colNum].isSequence = false;
}
else
{
break;
}
down = board.board[down.rowNum + 1][down.colNum];
}
down = board.board[box.rowNum][box.colNum - 1];
while (down.colNum - 1 >= 0 && board.board[down.rowNum - 1][down.colNum].boxContent != BoxContent.Empty)
{
if (isPair(down, board.board[down.rowNum - 1][down.colNum]))
{
--down.currentPiece.owner.score;
board.board[down.rowNum - 1][down.colNum].isSequence = false;
}
else
{
break;
}
down = board.board[down.rowNum - 1][down.colNum];
}
barrierBox.boxContent = BoxContent.Barrier;
barrierBox.currentPiece = null;
return;
}
}
}
}
// diagonal cases
if (box.rowNum + 2 < amtRows && box.colNum - 2 >= 0)
{
BoardBox next = board.board[box.rowNum + 1][box.colNum - 1];
if (next.boxContent == BoxContent.Piece)
{
if (next.currentPiece.owner != currentPlayer && doesTrump(box.currentPiece, next.currentPiece) && next.isDiagonalSequence)
{
BoardBox nextNext = board.board[box.rowNum + 2][box.colNum - 2];
if (isPair(box, nextNext))
{
// change sprite of middle box to a barrier
next.GetComponent <Image>().sprite = barrierSprite;
barrierBox = next;
next.currentPiece.owner.score -= 2;
// refactor the opposing player's score
next.isDiagonalSequence = false;
while (next.rowNum + 1 < amtRows && next.colNum + 1 < amtColumns &&
board.board[next.rowNum + 1][next.colNum + 1].boxContent != BoxContent.Empty)
{
if (isPair(next, board.board[next.rowNum + 1][next.colNum + 1]))
{
--next.currentPiece.owner.score;
board.board[next.rowNum + 1][next.colNum + 1].isDiagonalSequence = false;
}
else
{
break;
}
next = board.board[next.rowNum + 1][next.colNum + 1];
}
next = board.board[box.rowNum + 1][box.colNum - 1];
while (next.rowNum - 1 >= 0 && next.colNum - 1 >= 0 &&
board.board[next.rowNum - 1][next.colNum - 1].boxContent != BoxContent.Empty)
{
if (isPair(next, board.board[next.rowNum - 1][next.colNum - 1]))
{
--next.currentPiece.owner.score;
board.board[next.rowNum - 1][next.colNum - 1].isDiagonalSequence = false;
}
else
{
break;
}
next = board.board[next.rowNum - 1][next.colNum - 1];
}
barrierBox.boxContent = BoxContent.Barrier;
barrierBox.currentPiece = null;
return;
}
}
}
}
if (box.rowNum - 2 >= 0 && box.colNum + 2 < amtColumns)
{
BoardBox next = board.board[box.rowNum - 1][box.colNum + 1];
if (next.boxContent == BoxContent.Piece)
{
if (next.currentPiece.owner != currentPlayer && doesTrump(box.currentPiece, next.currentPiece) && next.isDiagonalSequence)
{
BoardBox nextNext = board.board[box.rowNum - 2][box.colNum + 2];
if (isPair(box, nextNext))
{
// change sprite of middle box to a barrier
next.GetComponent <Image>().sprite = barrierSprite;
barrierBox = next;
next.currentPiece.owner.score -= 2;
// refactor the opposing player's score
next.isDiagonalSequence = false;
while (next.rowNum + 1 < amtRows && next.colNum + 1 < amtColumns &&
board.board[next.rowNum + 1][next.colNum + 1].boxContent != BoxContent.Empty)
{
if (isPair(next, board.board[next.rowNum + 1][next.colNum + 1]))
{
--next.currentPiece.owner.score;
board.board[next.rowNum + 1][next.colNum + 1].isDiagonalSequence = false;
}
else
{
break;
}
next = board.board[next.rowNum + 1][next.colNum + 1];
}
next = board.board[box.rowNum - 1][box.colNum + 1];
while (next.rowNum - 1 >= 0 && next.colNum - 1 >= 0 &&
board.board[next.rowNum - 1][next.colNum - 1].boxContent != BoxContent.Empty)
{
if (isPair(next, board.board[next.rowNum - 1][next.colNum - 1]))
{
--next.currentPiece.owner.score;
board.board[next.rowNum - 1][next.colNum - 1].isDiagonalSequence = false;
}
else
{
break;
}
next = board.board[next.rowNum - 1][next.colNum - 1];
}
barrierBox.boxContent = BoxContent.Barrier;
barrierBox.currentPiece = null;
return;
}
}
}
}
if (box.rowNum - 2 >= 0 && box.colNum - 2 >= 0)
{
BoardBox next = board.board[box.rowNum - 1][box.colNum - 1];
if (next.boxContent == BoxContent.Piece)
{
if (next.currentPiece.owner != currentPlayer && doesTrump(box.currentPiece, next.currentPiece) && next.isDiagonalSequence)
{
BoardBox nextNext = board.board[box.rowNum - 2][box.colNum - 2];
if (isPair(box, nextNext))
{
// change sprite of middle box to a barrier
next.GetComponent <Image>().sprite = barrierSprite;
barrierBox = next;
next.currentPiece.owner.score -= 2;
// refactor the opposing player's score
next.isDiagonalSequence = false;
while (next.rowNum + 1 < amtRows && next.colNum - 1 >= 0 &&
board.board[next.rowNum + 1][next.colNum - 1].boxContent != BoxContent.Empty)
{
if (isPair(next, board.board[next.rowNum + 1][next.colNum - 1]))
{
--next.currentPiece.owner.score;
board.board[next.rowNum + 1][next.colNum - 1].isDiagonalSequence = false;
}
else
{
break;
}
next = board.board[next.rowNum + 1][next.colNum - 1];
}
next = board.board[box.rowNum - 1][box.colNum - 1];
while (next.rowNum - 1 >= 0 && next.colNum + 1 < amtColumns &&
board.board[next.rowNum - 1][next.colNum + 1].boxContent != BoxContent.Empty)
{
if (isPair(next, board.board[next.rowNum - 1][next.colNum + 1]))
{
--next.currentPiece.owner.score;
board.board[next.rowNum - 1][next.colNum + 1].isDiagonalSequence = false;
}
else
{
break;
}
next = board.board[next.rowNum - 1][next.colNum + 1];
}
barrierBox.boxContent = BoxContent.Barrier;
barrierBox.currentPiece = null;
return;
}
}
}
}
if (box.rowNum + 2 < amtRows && box.colNum + 2 < amtColumns)
{
BoardBox next = board.board[box.rowNum + 1][box.colNum + 1];
if (next.boxContent == BoxContent.Piece)
{
if (next.currentPiece.owner != currentPlayer && doesTrump(box.currentPiece, next.currentPiece) && next.isDiagonalSequence)
{
BoardBox nextNext = board.board[box.rowNum + 2][box.colNum + 2];
if (isPair(box, nextNext))
{
// change sprite of middle box to a barrier
next.GetComponent <Image>().sprite = barrierSprite;
barrierBox = next;
next.currentPiece.owner.score -= 2;
// refactor the opposing player's score
next.isDiagonalSequence = false;
while (next.rowNum + 1 < amtRows && next.colNum - 1 >= 0 &&
board.board[next.rowNum + 1][next.colNum - 1].boxContent != BoxContent.Empty)
{
if (isPair(next, board.board[next.rowNum + 1][next.colNum - 1]))
{
--next.currentPiece.owner.score;
board.board[next.rowNum + 1][next.colNum - 1].isDiagonalSequence = false;
}
else
{
break;
}
next = board.board[next.rowNum + 1][next.colNum - 1];
}
next = board.board[box.rowNum + 1][box.colNum + 1];
while (next.rowNum - 1 >= 0 && next.colNum + 1 < amtColumns &&
board.board[next.rowNum - 1][next.colNum + 1].boxContent != BoxContent.Empty)
{
if (isPair(next, board.board[next.rowNum - 1][next.colNum + 1]))
{
--next.currentPiece.owner.score;
board.board[next.rowNum - 1][next.colNum + 1].isDiagonalSequence = false;
}
else
{
break;
}
next = board.board[next.rowNum - 1][next.colNum + 1];
}
barrierBox.boxContent = BoxContent.Barrier;
barrierBox.currentPiece = null;
return;
}
}
}
}
}
//three same piece in a row
bool checkForSequence(BoardBox box)
{
BoardBox leftBox = null;
BoardBox rightBox = null;
BoardBox upBox = null;
BoardBox downBox = null;
BoardBox posDiagonal = null;
BoardBox negDiagonal = null;
BoardBox leftDiagonal = null;
BoardBox rightDiagonal = null;
if (box.rowNum + 1 < amtRows)
{
rightBox = board.board[box.rowNum + 1][box.colNum];
if (rightBox.isSequence && isPair(box, rightBox))
{
return(true);
}
else if (box.rowNum + 2 < amtRows)
{
if (isPair(box, rightBox) && isPair(rightBox, board.board[box.rowNum + 2][box.colNum]))
{
rightBox.isSequence = true;
board.board[box.rowNum + 2][box.colNum].isSequence = true;
return(true);
}
}
}
if (box.rowNum - 1 >= 0)
{
leftBox = board.board[box.rowNum - 1][box.colNum];
if (leftBox.isSequence && isPair(box, leftBox))
{
return(true);
}
else if (box.rowNum - 2 >= 0)
{
if (isPair(box, leftBox) && isPair(leftBox, board.board[box.rowNum - 2][box.colNum]))
{
leftBox.isSequence = true;
board.board[box.rowNum - 2][box.colNum].isSequence = true;
return(true);
}
}
}
if (box.colNum + 1 < amtColumns)
{
upBox = board.board[box.rowNum][box.colNum + 1];
if (upBox.isSequence && isPair(box, upBox))
{
return(true);
}
else if (box.colNum + 2 < amtColumns)
{
if (isPair(box, upBox) && isPair(upBox, board.board[box.rowNum][box.colNum + 2]))
{
upBox.isSequence = true;
board.board[box.rowNum][box.colNum + 2].isSequence = true;
return(true);
}
}
}
if (box.colNum - 1 >= 0)
{
downBox = board.board[box.rowNum][box.colNum - 1];
if (downBox.isSequence && isPair(box, downBox))
{
return(true);
}
else if (box.colNum - 2 >= 0)
{
if (isPair(box, downBox) && isPair(downBox, board.board[box.rowNum][box.colNum - 2]))
{
downBox.isSequence = true;
board.board[box.rowNum][box.colNum - 2].isSequence = true;
return(true);
}
}
}
if (box.rowNum + 1 < amtRows && box.colNum + 1 < amtColumns)
{
posDiagonal = board.board[box.rowNum + 1][box.colNum + 1];
if (posDiagonal.isDiagonalSequence && isPair(box, posDiagonal))
{
return(true);
}
else if (box.rowNum + 2 < amtRows && box.colNum + 2 < amtColumns)
{
if (isPair(box, posDiagonal) && isPair(posDiagonal, board.board[box.rowNum + 2][box.colNum + 2]))
{
posDiagonal.isDiagonalSequence = true;
board.board[box.rowNum + 2][box.colNum + 2].isDiagonalSequence = true;
box.isDiagonalSequence = true;
return(true);
}
}
}
if (box.rowNum - 1 >= 0 && box.colNum - 1 >= 0)
{
negDiagonal = board.board[box.rowNum - 1][box.colNum - 1];
if (negDiagonal.isDiagonalSequence && isPair(box, negDiagonal))
{
return(true);
}
else if (box.rowNum - 2 >= 0 && box.colNum - 2 >= 0)
{
if (isPair(box, negDiagonal) && isPair(negDiagonal, board.board[box.rowNum - 2][box.colNum - 2]))
{
negDiagonal.isDiagonalSequence = true;
board.board[box.rowNum - 2][box.colNum - 2].isDiagonalSequence = true;
box.isDiagonalSequence = true;
return(true);
}
}
}
if (box.rowNum + 1 < amtRows && box.colNum - 1 >= 0)
{
leftDiagonal = board.board[box.rowNum + 1][box.colNum - 1];
if (leftDiagonal.isDiagonalSequence && isPair(box, leftDiagonal))
{
return(true);
}
else if (box.rowNum + 2 < amtRows && box.colNum - 2 >= 0)
{
if (isPair(box, leftDiagonal) && isPair(leftDiagonal, board.board[box.rowNum + 2][box.colNum - 2]))
{
leftDiagonal.isDiagonalSequence = true;
board.board[box.rowNum + 2][box.colNum - 2].isDiagonalSequence = true;
box.isDiagonalSequence = true;
return(true);
}
}
}
if (box.rowNum - 1 >= 0 && box.colNum + 1 < amtColumns)
{
rightDiagonal = board.board[box.rowNum - 1][box.colNum + 1];
if (rightDiagonal.isDiagonalSequence && isPair(box, rightDiagonal))
{
return(true);
}
else if (box.rowNum - 2 >= 0 && box.colNum + 2 < amtColumns)
{
if (isPair(box, rightDiagonal) && isPair(rightDiagonal, board.board[box.rowNum - 2][box.colNum + 2]))
{
rightDiagonal.isDiagonalSequence = true;
board.board[box.rowNum - 2][box.colNum + 2].isDiagonalSequence = true;
box.isDiagonalSequence = true;
return(true);
}
}
}
if (isPair(box, upBox) && isPair(box, downBox))
{
upBox.isSequence = true;
downBox.isSequence = true;
return(true);
}
if (isPair(box, leftBox) && isPair(box, rightBox))
{
leftBox.isSequence = true;
rightBox.isSequence = true;
return(true);
}
if (isPair(box, posDiagonal) && isPair(box, negDiagonal))
{
posDiagonal.isDiagonalSequence = true;
negDiagonal.isDiagonalSequence = true;
box.isDiagonalSequence = true;
return(true);
}
if (isPair(box, leftDiagonal) && isPair(box, rightDiagonal))
{
leftDiagonal.isDiagonalSequence = true;
rightDiagonal.isDiagonalSequence = true;
box.isDiagonalSequence = true;
return(true);
}
return(false);
}
