private void moveTo(SquareIndex index) { if (nodeList.Count == 0) { lastIndex = startIndex; currentIndex = index; nodeList.Add(instantiateMoveNode(moveNodeFinalPrefab, currentIndex, 10)); } else if (!index.Equals(nodeList[0].index)) { int listIndex = calculateListIndex(index); if (listIndex > 0) { removeIndex(listIndex, index); } else { addIndex(index); } lastIndex = currentIndex; currentIndex = index; } createNodeLinks(); calculateNumMoves(); }
public void clear(Player owner, SquareIndex index) { this.owner = owner; this.index = index; toMoveSquareList = new List <SquareIndex>(); int directionX = UnityEngine.Random.Range(-1, 2); int directionY = UnityEngine.Random.Range(-1, 2); //Check that the direction is not (0, 0) if (directionX == 0 && directionY == 0) { directionX = 1; } int distance = UnityEngine.Random.Range(1, 7); for (int i = 0; i < distance; i++) { toMoveSquareList.Add(index + new SquareIndex(directionX, directionY) * i); } canBeIntercepted = false; endAction = endClear; StartCoroutine(updateMove()); }
private bool isDirectionChange(SquareIndex nextIndex) { List <SquareIndex> indexList = retrieveIndexList(); SquareIndex index = indexList[0]; if (isDiagonal(startIndex, index)) { if (nodeList.Count == 1) { return(false); } else { if (isHorizontal(indexList[0], indexList[1])) { return(!isHorizontal(indexList[1], nextIndex)); } else { return(isHorizontal(indexList[1], nextIndex)); } } } else { if (isHorizontal(startIndex, indexList[0])) { return(!isHorizontal(indexList[0], nextIndex)); } else { return(isHorizontal(indexList[0], nextIndex)); } } }
private static int calculateNumDiagonalsInPath(SquareIndex startIndex, int a, int b) { bool isDiagonal; int diagonals = 0; SquareIndex currentIndex = new SquareIndex(a, b); SquareIndex parentIndex = parent[currentIndex.x][currentIndex.y]; if (parentIndex == null) { return(0); } while (parentIndex != startIndex) { isDiagonal = (Mathf.Abs(currentIndex.x - parentIndex.x) == 1 && Mathf.Abs(currentIndex.y - parentIndex.y) == 1); if (isDiagonal) { diagonals++; } currentIndex = new SquareIndex(parentIndex.x, parentIndex.y); parentIndex = parent[currentIndex.x][currentIndex.y]; } //Check between the start index and the first index isDiagonal = (Mathf.Abs(currentIndex.x - startIndex.x) == 1 && Mathf.Abs(currentIndex.y - startIndex.y) == 1); if (isDiagonal) { diagonals++; } return(diagonals); }
public bool CanMove(Move move) { bool fCanMove = false; SquareIndex selectedSquare = this.EmptySquare.Plus(MoveVector.OrthogonalSteps[(int)move]); int tileId = this[selectedSquare]; if (SquareIsOnTheBoard(selectedSquare)) { // Can't move the "empty" tile: if (tileId != 0) { // Find specified tile: SquareIndex currentSquare = Tiles[tileId]; // Calculate required movement from current square // to the empty square: MoveVector movement = SquareIndex.Subtract(EmptySquare, currentSquare); // See if movement is an orthogonal step: foreach (MoveVector orthogonalStep in MoveVector.OrthogonalSteps) { if (movement == orthogonalStep) { fCanMove = true; break; } } } } return(fCanMove); }
/// <summary> /// Move the specified tile from its current square to the empty square; /// returns true if the tile moves, false if tile can't be moved. /// </summary> public bool MoveTile(int tileId) { // Can't move the "empty" tile: if (tileId == 0) { return(false); } // Find specified tile: SquareIndex selectedSquare = Tiles[tileId]; // Calculate required movement from current square // to the empty square: MoveVector movement = SquareIndex.Subtract(EmptySquare, selectedSquare); // See if movement is an orthogonal step: foreach (MoveVector orthogonalStep in MoveVector.OrthogonalSteps) { if (movement == orthogonalStep) { ExchangeTiles(selectedSquare, EmptySquare); return(true); } } // Can't move the tile from the specified square // to the empty square in a single orthogonal step: return(false); }
//Converts a square index to world coordinates public Vector3 squareIndexToWorld(SquareIndex index) { float posx = origin.x + transform.position.x + (index.x * SIZE_SQUARE); float posy = origin.y + transform.position.z + (index.y * SIZE_SQUARE); return(new Vector3(posx, 0, posy)); }
/// <summary> /// Exchange contents of two squares. /// </summary> private void ExchangeTiles(SquareIndex squareA, SquareIndex squareB) { int tileId = this[squareA]; this[squareA] = this[squareB]; this[squareB] = tileId; }
public SquareIndex inverseIndex(SquareIndex index) { int x = (SIZE_X - 1) - index.x; int y = (SIZE_Y - 1) - index.y; return(new SquareIndex(x, y)); }
public void setPosition(SquareIndex index) { _index = index; cachedTransform.position = board.squareIndexToWorld(index); board.updatePlayerPosition(index, this); }
private void addIndex(SquareIndex index) { MoveNode endNode = nodeList[0]; nodeList.Add(instantiateMoveNode(moveNodePrefab, endNode.index, 10)); endNode.index = index; endNode.gameObject.transform.localPosition = board.squareIndexToWorld(index); }
public void init(Board board, Player player) { this.board = board; this.player = player; isActive = true; startIndex = player.index; }
public void showRadius(SquareIndex index, int radius, bool squareWithPlayerIn) { List <SquareIndex> indexList = getMoveToSquareList(index, radius, squareWithPlayerIn); for (int i = 0; i < indexList.Count; i++) { instantiateSquare(indexList[i].x, indexList[i].y); } }
/// <summary> /// Is specified square on the board. /// </summary> private bool SquareIsOnTheBoard(SquareIndex selectedSquare) { if (selectedSquare.Row >= 0 && selectedSquare.Row < Dimension && selectedSquare.Col >= 0 && selectedSquare.Col < Dimension) { return(true); } return(false); }
public void save(SquareIndex targetIndex) { if (index != targetIndex) { toMoveSquareList = PathFinder.findPath(index, targetIndex, board, false, true, 10); } endAction = endSave; StartCoroutine(updateMove()); }
private int calculateListIndex(SquareIndex index) { for (int i = 0; i < nodeList.Count; i++) { if (nodeList[i].index.Equals(index)) { return(i); } } return(-1); }
/// <summary> /// Instantiates a new move node /// </summary> /// <returns>The move node.</returns> /// <param name="prefab">The prefab for the node (there could be different nodes).</param> /// <param name="index">The index for the node.</param> /// <param name="numMoves">Number of moves left to show on the node.</param> private MoveNode instantiateMoveNode(GameObject prefab, SquareIndex index, int numMoves) { MoveNode moveNode = (GameObject.Instantiate(prefab) as GameObject).GetComponent <MoveNode>(); moveNode.init(numMoves, index); moveNode.transform.parent = transform; moveNode.transform.localPosition = board.squareIndexToWorld(index); return(moveNode); }
public Player getPlayerOnSquare(SquareIndex index) { if (isOnBounds(index)) { return(_boardData[index.x][index.y].player); } else { return(null); } }
/// <summary> /// Access a board square. /// </summary> private int this[SquareIndex selectedSquare] { get { return(Squares[selectedSquare.Row][selectedSquare.Col]); } set { Squares[selectedSquare.Row][selectedSquare.Col] = value; Tiles[value] = selectedSquare; } }
public IEnumerator updateMove() { if (toMoveSquareList.Count > 0) { SquareIndex nextSquareIndex = toMoveSquareList[0]; Vector2 direction = nextSquareIndex.V2 - index.V2; Vector3 position = board.squareIndexToWorld(index); Vector3 targetPosition = board.squareIndexToWorld(nextSquareIndex); float magnitude = (targetPosition - position).sqrMagnitude; float currentMagnitude = (cachedTransform.position - position).sqrMagnitude; Vector3 directionV3 = Util.v2ToV3(direction); while (currentMagnitude < magnitude) { cachedTransform.position += directionV3 * moveSpeed * Time.deltaTime; currentMagnitude = (cachedTransform.position - position).sqrMagnitude; yield return(null); } cachedTransform.position = board.squareIndexToWorld(nextSquareIndex); _index = nextSquareIndex; board.updatePlayerPosition(_index, this); toMoveSquareList.RemoveAt(0); //If the player has the ball, check for tackles if (hasTheBall) { List <Player> playerList = board.retrieveAdjacentPlayerList(_index, team.opponentTeam.teamData.id); if (playerList.Count > 0) { checkForTackle(playerList[0]); } else { StartCoroutine(updateMove()); } } else { StartCoroutine(updateMove()); } } else { endAction(); } }
public void pass(Player owner, SquareIndex index, List <SquareIndex> toMoveSquareList) { this.owner = owner; this.index = index; this.toMoveSquareList = toMoveSquareList; //Add the player level as power power = owner.playerData.level; canBeIntercepted = true; endAction = endPass; StartCoroutine(updateMove()); }
/// <summary> /// Access board by row and column. /// </summary> public int this[int row, int col] { get { SquareIndex selectedSquare = new SquareIndex(row, col); return(this[selectedSquare]); } set { SquareIndex selectedSquare = new SquareIndex(row, col); this[selectedSquare] = value; } }
/// <summary> /// Retrieves all the players adjacent to an index /// </summary> /// <returns>The player list.</returns> /// <param name="index">The index whose adjacent players we want to retrieve.</param> /// <param name="teamId">The id of the team whose players we want to retrieve.</param> public List <Player> retrieveAdjacentPlayerList(SquareIndex index, string teamId) { List <Player> playerList = new List <Player>(); List <SquareIndex> indexList = getAdjacentTileList(index); for (int i = 0; i < indexList.Count; i++) { Player player = getPlayerOnSquare(indexList[i]); if (player != null && !player.isInactive && player.team.teamData.id == teamId) { playerList.Add(player); } } return(playerList); }
/// <summary> /// Serial board accessor: left-to-right, then top-to-bottom /// </summary> public int this[int index] { get { SquareIndex selectedSquare = new SquareIndex(index / Dimension, index % Dimension); return(this[selectedSquare]); } set { SquareIndex selectedSquare = new SquareIndex(index / Dimension, index % Dimension); this[selectedSquare] = value; } }
public void intercept(SquareIndex index, bool success) { if (success) { toMoveSquareList = new List <SquareIndex>(); toMoveSquareList.Add(index); board.removePlayerFromSquare(index); endAction = endIntercept; StartCoroutine(updateMove()); } else { setInactive(true); } }
public List <SquareIndex> getAdjacentTileList(SquareIndex index) { List <SquareIndex> tileList = new List <SquareIndex>(); for (int i = index.x - 1; i <= index.x + 1; i++) { for (int j = index.y - 1; j <= index.y + 1; j++) { SquareIndex newindex = new SquareIndex(i, j); if (isOnBounds(newindex) && index != newindex) { tileList.Add(newindex); } } } return(tileList); }
private void removeIndex(int listIndex, SquareIndex index) { for (int i = listIndex; i < nodeList.Count; i++) { GameObject.Destroy(nodeList[i].gameObject); } for (int i = listIndex; i < nodeList.Count; i++) { nodeList.RemoveRange(listIndex, nodeList.Count - listIndex); } MoveNode head = nodeList[0]; head.index = index; head.gameObject.transform.position = board.squareIndexToWorld(head.index); SquareIndex prevIndex = nodeList.Count == 1 ? startIndex : nodeList[nodeList.Count - 1].index; }
//Returns a list with all the squares in an area public List <SquareIndex> getSquareListInArea(SquareIndex index, int radius) { List <SquareIndex> indexList = new List <SquareIndex>(); for (int i = index.x - radius; i < index.x + radius + 1; i++) { for (int j = index.y - radius; j < index.y + radius + 1; j++) { if (Mathf.Abs(index.x - i) <= radius && Mathf.Abs(index.y - j) <= radius && Mathf.Abs(index.x - i) + Mathf.Abs(index.y - j) <= radius) { SquareIndex currentIndex = new SquareIndex(i, j); bool onBounds = isOnBounds(currentIndex); indexList.Add(currentIndex); } } } return(indexList); }
private SquareIndex getCorrectIndex() { SquareIndex index = new SquareIndex(player.team.isP1Team ? (player.index.x - 1) : (player.index.x + 1), player.index.y); if (!isIndexCorrect(index)) { index = new SquareIndex(player.index.x, index.y - 1); } if (!isIndexCorrect(index)) { index = new SquareIndex(player.index.x, index.y + 1); } if (!isIndexCorrect(index)) { index = new SquareIndex(player.team.isP1Team ? (player.index.x + 1) : (player.index.x - 1), index.y); } return(index); }
public void Click(SquareIndex index) { ClickSquare(index.Row, index.Column); foreach (int row in Enumerable .Range(0, Constants.GridDimension) .Except(new[] { index.Row })) { ClickSquare(row, index.Column); } foreach (int column in Enumerable .Range(0, Constants.GridDimension) .Except(new[] { index.Column })) { ClickSquare(index.Row, column); } FindSequences(); }