void Start()
{
BoardTile[,] spPuzzle1Board =
{
{ BoardTile.Path(false, true), BoardTile.Empty(), BoardTile.Path(false, true) },
{ BoardTile.Target(true, true), BoardTile.Path(true, false), BoardTile.Path(false, true)},
{ BoardTile.Path(false, true), BoardTile.Empty(), BoardTile.Target(false, true) },
{ BoardTile.Target(true, true), BoardTile.Path(true, false), BoardTile.Path(false, true)},
{ BoardTile.Path(false, false), BoardTile.Empty(), BoardTile.Path(false, false) },
};
BoardPillar[] spPuzzle1Pillars =
{
BoardPillar.Key(0, 0),
BoardPillar.Key(0, 2),
BoardPillar.Key(4, 0),
BoardPillar.Regular(4, 2)
};
BoardTile[,] spPuzzle2Board =
{
{ BoardTile.Empty(), BoardTile.Path(false, true), BoardTile.Empty() },
{ BoardTile.Path(true, true), BoardTile.Path(true, true), BoardTile.Path(false, true)},
{ BoardTile.Target(false, true), BoardTile.Path(false, true), BoardTile.Path(false, true)},
{ BoardTile.Path(false, true), BoardTile.Path(false, true), BoardTile.Path(false, true)},
{ BoardTile.Path(true, false), BoardTile.Path(true, true), BoardTile.Path(true, false)},
{ BoardTile.Empty(), BoardTile.Path(false, false), BoardTile.Empty() },
};
spPuzzle1 = gameObject.GetComponent <SlidingPillars>();
spPuzzle1.SetBoard(spPuzzle1Board);
spPuzzle1.SetPillars(spPuzzle1Pillars);
spPuzzle1.Generate();
}
//Use this for preinitialization
public void Awake()
{
//Initalize the gridOutline
gridOutline = new BoardTile[boardSize, boardSize];
enemyOutline = new EnemyTile[boardSize, boardSize];
boardCodes = new int[boardSize, boardSize];
}
/// <summary>
/// Initializes the board.
/// </summary>
/// <param name="dimensions">The dimensions of the board. The length of a square side.</param>
/// <param name="position">The position of this board in the world.</param>
/// <param name="owner">The owner of this board.</param>
/// <param name="gridMaterial">The material used to render the grid.</param>
public void Initialize(int dimensions, Vector3 position, Player owner, Material gridMaterial)
{
tiles = new BoardTile[dimensions, dimensions];
for (int x = 0; x < dimensions; x++)
{
for (int y = 0; y < dimensions; y++)
{
tiles[x, y] = new GameObject("Tile X: " + x + " Y: " + y).AddComponent <BoardTile>();
tiles[x, y].transform.position = -new Vector3(1f, 0, 1f) * ((float)dimensions / 2f + 0.5f) + new Vector3(x + 1, 0f, y + 1);
tiles[x, y].transform.parent = this.transform;
tiles[x, y].boardCoordinates = new Vector2(x, y);
tiles[x, y].board = this;
}
}
//this.position = position;
this.transform.position = position;
this.transform.parent = owner.transform;
this.owner = owner;
this.dimensions = dimensions;
this.gridMaterial = gridMaterial;
//gridRendered = true;
Set(BoardState.DISABLED);
}
void Awake()
{
GameObject container = new GameObject();
container.transform.SetParent(transform);
container.name = "Tiles";
tilesPool = new GameObjectPool(tilePrefab, maxTilesCount, container);
tiles = new BoardTile[maxTilesCount, maxTilesCount];
boardGOs = new GameObject[maxTilesCount, maxTilesCount];
// allocate enough pieces to fill the board, and a second lot so things can animate, like if we want to clear the board and animate a new lot of pieces coming in
container = new GameObject();
container.transform.SetParent(transform);
container.name = "Pieces";
piecesPool = new GameObjectPool(piecePrefab, maxTilesCount * 2, container);
// waiters
for (int i = 0; i < removeWaiterArraySize; i++)
{
removeTileDelayWaiters[i] = new WaitForSeconds(Mathf.SmoothStep(removeTileDelayMax, removeTileDelayMin, (float)i / (float)removeWaiterArraySize));
}
// Sounds
for (int i = 0; i < 12; i++)
{
AudioSource source = gameObject.AddComponent <AudioSource>();
randomPitchSources.Add(source);
source.pitch = Random.Range(0.9f, 1.3f);
}
gameObject.SetActive(false);
}
private void InitializeBoard()
{
boardTiles = new BoardTile[width, height];
for (int j = 0; j < height; j++)
{
for (int i = 0; i < width; i++)
{
bool isWalkable = true;
if (j == 0 || j == height - 1 || Random.Range(0, 3) == 0)
{
isWalkable = false;
}
boardTiles[i, j] = new BoardTile(i, j, isWalkable);
if (i > 0)
{
boardTiles[i, j].Neighbors.Add(boardTiles[i - 1, j]);
boardTiles[i - 1, j].Neighbors.Add(boardTiles[i, j]);
}
if (j > 0)
{
boardTiles[i, j].Neighbors.Add(boardTiles[i, j - 1]);
boardTiles[i, j - 1].Neighbors.Add(boardTiles[i, j]);
}
}
}
Player.Instance.currentTile = boardTiles[0, 1];
}
private void CreateBoard(Vector2 offset, Vector2 baseSpaw)
{
board = new BoardTile[rows, columns];
//Create frame
if (framePrefab != null)
{
SpriteRenderer frame = Instantiate(framePrefab,
new Vector3(transform.position.x,
transform.position.y,
0f),
framePrefab.transform.rotation);
frame.transform.SetParent(tilesParent.transform);
frame.transform.localScale = new Vector2(columns + 0.3f, rows + 0.3f);
}
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < columns; j++)
{
BoardTile tile = Instantiate(tilePrefab,
new Vector3(baseSpaw.x + (offset.x * j),
baseSpaw.y + (offset.y * i),
0f),
tilePrefab.transform.rotation);
tile.transform.SetParent(tilesParent.transform);
board[i, j] = tile;
board[i, j].InitializeBoardTile(i, j);
}
}
}
/// <summary>
/// Generates the game board
/// </summary>
/// <param name="row"></param>
/// <param name="colum"></param>
private void Createboard(int row, int column)
{
//Creates a new tileset size row x column
_gameBoard = new BoardTile[row, column];
for (int r = row - 1; r >= 0; r--)
{
for (int c = column - 1; c >= 0; c--)
{
BoardTile tile = new BoardTile(r, c);
tile.Terrain = SquareTerrain.Grass;
if (r == row - 1)
{
tile.State = SquareStatus.Enemy;
tile.Terrain = SquareTerrain.Woods;
_enemyUnits++;
}
else if (r == row - row)
{
tile.State = SquareStatus.Player;
tile.Terrain = SquareTerrain.Woods;
_playerUnits++;
}
else
{
tile.State = SquareStatus.None;
tile.Terrain = SquareTerrain.Grass;
}
_gameBoard[r, c] = tile;
}
}
}
protected override void Awake()
{
base.Awake();
if (this.SkipRegen)
{
this.Tiles = new BoardTile[this.width, this.height];
List <GameObject> children = this.gameObject.transform.GetChildren();
Debug.Log("Found " + children.Count + " children");
foreach (GameObject d in children)
{
BoardTile bt = d.GetComponent <BoardTile>();
if (bt)
{
bt.ColorManager.ChangeColor(Color.black);
this.Tiles[bt.x, bt.y] = bt;
}
else
{
Debug.Log("Non-BT child found.");
}
}
return;
}
this.DeleteAllChildren();
this.GenerateBoard();
}
public MiniMax(int size, int Sequance)
{
BoardState = new BoardTile[size, size];
RowsEval = new int[size];
ColsEval = new int[size];
DiagsEval = new int[2];
this.Sequance = Sequance;
}
/// <summary>
/// Function that handles a mouse click action
/// </summary>
/// <param name="mouseX">X position of the mouse</param>
/// <param name="mouseY">Y position of the mouse</param>
private void handleMouseAction(int mouseX, int mouseY)
{
//Make a rectangle for the mouse click size of 1 pixel
Rectangle mouseClick = new Rectangle(mouseX, mouseY, 1, 1);
//Below handles the event of when the black button is pressed
if (mouseClick.Intersects(blackButton))
{
newGame(PieceColor.Black);
}
//Below handles the event of when the white button is pressed
else if (mouseClick.Intersects(whiteButton))
{
newGame(PieceColor.White);
}
//Below handles any clicking of checkers pieces or board tiles
else if (currentState.winner == PieceColor.None && currentState.turnColor != PieceColor.None)
{
bool clickablePlace = false;
foreach (CheckersPiece gamePiece in currentState.moveablePieces)
{
if (gamePiece.intersects(mouseClick) == true)
{
clickablePlace = true;
currentState.doGamePieceAction(gamePiece);
break;
}
}
BoardTile[,] tiles = currentState.gameBoard.getTiles();
for (int x = 0; x < CheckersBoard.MAX_HORIZONTAL_TILES; x++)
{
for (int y = 0; y < CheckersBoard.MAX_VERTICAL_TILES; y++)
{
if (tiles[x, y].intersects(mouseClick) == true)
{
clickablePlace = true;
if (currentState.doTileAction(tiles[x, y]) == true)
{
currentState.activeGamePiece.Update(currentState);
break;
}
}
}
if (clickablePlace == true)
{
break;
}
}
if (clickablePlace == false)
{
currentState.gameBoard.clearMarkings();
}
}
}
void BuildBoard()
{
// move to center of screen
transform.position = -(Vector2)Dimensions / 2 + Vector2.one / 2;
// create 2D array for tiles
_tiles = new BoardTile[Dimensions.x, Dimensions.y];
// fill the board
FillEmptySpaces();
}
public Board()
{
_board = new BoardTile[RowColLen, RowColLen];
for (int i = 0; i < RowColLen; i++)
{
for (int j = 0; j < RowColLen; j++)
{
_board[i, j] = new BoardTile(new PiecePosition(i, j));
}
}
}
void ListPossibleMoves()
{
board = null;
pieces.Clear();
board = Board.instance.GetBoard();
listAvaliableMoves = new List <AIMoviment>();
//checking dark pieces
for (int i = 0; i < board.GetLength(0); i++)
{
for (int j = 0; j < board.GetLength(1); j++)
{
if (board[i, j].currentPiece == null)
{
continue;
}
if (board[i, j].currentPiece.CheckPieceType(PieceTypes.Black))
{
pieces.Add(board[i, j].currentPiece);
}
}
}
//list possible piece moves
for (int i = 0; i < pieces.Count; i++)
{
//getting piece tile coordinates
int actualRow = pieces[i].currentTile.row;
int actualCol = pieces[i].currentTile.column;
if (pieces[i].IsKing()) //if the actual piece is a king
{
//checking diagonals
bool downRight = AIKingTile(pieces[i], actualRow + 1, actualCol + 1, 1, 1, PieceTypes.Black);
bool downLeft = AIKingTile(pieces[i], actualRow + 1, actualCol - 1, 1, -1, PieceTypes.Black);
bool upRight = AIKingTile(pieces[i], actualRow - 1, actualCol + 1, -1, 1, PieceTypes.Black);
bool upLeft = AIKingTile(pieces[i], actualRow - 1, actualCol - 1, -1, -1, PieceTypes.Black);
}
else
{
if (pieces[i].IsDownMoviment())
{
bool upRight = AIBoardTile(pieces[i], actualRow - 1, actualCol + 1, -1, 1, PieceTypes.Black);
bool upLeft = AIBoardTile(pieces[i], actualRow - 1, actualCol - 1, -1, -1, PieceTypes.Black);
}
else
{
bool downRight = AIBoardTile(pieces[i], actualRow + 1, actualCol + 1, 1, 1, PieceTypes.Black);
bool downLeft = AIBoardTile(pieces[i], actualRow + 1, actualCol - 1, 1, -1, PieceTypes.Black);
}
}
}
}
public FallLogic(
Vector3 boardPosition,
SGridCoords boardSize,
BoardTile[,] boardTiles,
float fallSpeed)
{
_BoardPosition = boardPosition;
_BoardSize = boardSize;
_BoardTiles = boardTiles;
_FallSpeed = fallSpeed;
_LinkerObjects = new LinkerObject[_BoardSize._Column, _BoardSize._Row];
}
public void GenerateTiles()
{
Debug.Log("Called GenerateTiles");
tiles = new BoardTile[size.x, size.z];
for (int x = 0; x < size.x; x++)
{
for (int z = 0; z < size.z; z++)
{
CreateTile(new IntVector2(x, z), emptyTilePrefab, TileType.Empty, 1);
}
}
}
/// <summary>
/// Copy constructor for the checkers board.
/// This constructor is used for creating temporary states used in the AI.
/// </summary>
/// <param name="board">A board to copy</param>
public CheckersBoard(CheckersBoard board)
{
tiles = new BoardTile[6, 6];
for (int x = 0; x < MAX_HORIZONTAL_TILES; x++)
{
for (int y = 0; y < MAX_VERTICAL_TILES; y++)
{
BoardTile copyTile = board.tiles[x, y];
tiles[x, y] = new BoardTile(copyTile);
}
}
}
/// <summary>
/// Generate the chess board.
/// </summary>
public void GenerateBoard()
{
Tiles = new BoardTile[BoardSize, BoardSize];
for (int y = 0; y < BoardSize; y++)
{
for (int x = 0; x < BoardSize; x++)
{
Tiles[y, x] = new BoardTile(x, y);
}
}
}
public GameBoard(int rows, int columns)
{
Id = Guid.NewGuid();
tileGrid = new BoardTile[rows, columns];
foreach (int rowNum in Enumerable.Range(0, rows))
{
foreach (int colNum in Enumerable.Range(0, columns))
{
BoardTile tile = new BoardTile(rowNum, colNum);
tileGrid[rowNum, colNum] = tile;
}
}
}
public void Generate()
{
CalcStartPos();
board = new BoardTile[rows, cols];
for (int r = 0; r < rows; r++)
{
for (int c = 0; c < cols; c++)
{
CreateTile(r, c);
}
}
}
public LinkerLogic(
Vector3 boardPosition,
SGridCoords boardSize,
BoardTile[,] boardTiles,
float fallSpeed)
{
_FallLogic = new FallLogic(
boardPosition,
boardSize,
boardTiles,
fallSpeed
);
}
/// <summary>
/// Default constructor for the checkers board
/// </summary>
public CheckersBoard()
{
position = Vector2.Zero;
tiles = new BoardTile[6, 6];
for (int x = 0; x < MAX_HORIZONTAL_TILES; x++)
{
for (int y = 0; y < MAX_VERTICAL_TILES; y++)
{
Vector2 tilePosition = new Vector2(x, y);
tiles[x, y] = new BoardTile(tilePosition);
}
}
}
public Board(Texture2D spriteSheet)
{
Sprites = spriteSheet;
boardRecs = new BoardTile[8, 8];
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
boardRecs[i, j] = new BoardTile(i, j, new Rectangle(i * S_LENGTH, j * S_LENGTH, S_LENGTH, S_LENGTH));
}
}
}
//finds closest possible target
public BoardTile FindTarget(BoardTile[,] map, ChessPiece caster, bool ally)
{
ChessPiece currentTarget = null;
float currentTargetDistance = 0;
List <ChessPiece> Targets = new List <ChessPiece>();
//loop will find all available chess pieces to target
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
if (!ally)
{
if (map[i, j].CurrentPiece != caster && map[i, j].CurrentPiece != null && caster.isEnemy != map[i, j].CurrentPiece.isEnemy)
{
Targets.Add(map[i, j].CurrentPiece);
}
}
else
{
if (map[i, j].CurrentPiece != caster && map[i, j].CurrentPiece != null && caster.isEnemy == map[i, j].CurrentPiece.isEnemy)
{
Targets.Add(map[i, j].CurrentPiece);
}
}
}
}
//will determine closest piece
foreach (ChessPiece x in Targets)
{
float Distance = Mathf.Sqrt(Mathf.Pow((caster.CurrentBlock.CurrentX - x.CurrentBlock.CurrentX), 2) + Mathf.Pow((caster.CurrentBlock.CurrentZ - x.CurrentBlock.CurrentZ), 2));
if (currentTarget == null)
{
currentTarget = x;
currentTargetDistance = Distance;
}
else
{
if (Distance < currentTargetDistance)
{
currentTarget = x;
currentTargetDistance = Distance;
}
}
}
return(currentTarget.CurrentBlock);
}
public BoardTile Pathfinding(BoardTile[,] map, BoardTile casterLocation, BoardTile targetLocation, int range)
{
BoardTile currentTarget = null;
float currentTargetDistance = 0;
//finds all possible tiles within range of target
List <BoardTile> possible = new List <BoardTile>();
int casterX = casterLocation.CurrentX;
int casterZ = casterLocation.CurrentZ;
int targetX = targetLocation.CurrentX;
int targetZ = targetLocation.CurrentZ;
for (int i = targetX - range; i <= targetX + range; i++)
{
if (i >= 0 && i < 8)
{
for (int j = targetZ - range; j <= targetZ + range; i++)
{
if (j >= 0 && j < 8)
{
if (map[i, j] != targetLocation)
{
possible.Add(map[i, j]);
}
}
}
}
}
foreach (BoardTile x in possible)
{
float Distance = Mathf.Sqrt(Mathf.Pow((casterX - targetX), 2) + Mathf.Pow((casterZ - targetZ), 2));
if (currentTarget == null)
{
currentTarget = x;
currentTargetDistance = Distance;
}
else
{
if (Distance < currentTargetDistance)
{
currentTarget = x;
currentTargetDistance = Distance;
}
}
}
return(currentTarget);
}
void Start()
{
gameObject.transform.position += Layouts.GetBoardPos();
Layouts.UpdateCameraZoom();
BoardTile[,] boardTiles = SpawnBackgroundTiles();
_LinkerLogic = new LinkerLogic(
gameObject.transform.position,
new SGridCoords(LevelSettings.Instance.BoardWidth, LevelSettings.Instance.BoardHeight),
boardTiles,
_FallSpeed
);
_LinkerLogic.SetSpawners(SpawnLinkerSpawners());
_LinkerLogic.Initialize();
}
//instantiates Tiles
void Awake()
{
int numTiles = (leftOffset + rightOffset) * (downOffset + upOffset);
holes = Mathf.Min(holes, numTiles);
walls = Mathf.Min(walls, numTiles - holes);
boardArray = new BoardTile[leftOffset + rightOffset, downOffset + upOffset];
tileArray = new GameObject[leftOffset + rightOffset, downOffset + upOffset];
// i is width offset, j is height offset, i.e. # of tiles
//(i,j) corresponds to tile with southwest corner being (i,j) * tileScale
for (int i = -leftOffset; i < rightOffset; i++)
{
for (int j = -downOffset; j < upOffset; j++)
{
//center of the tile position
float xPos = (i + 0.5f) * tileScale;
float yPos = (j + 0.5f) * tileScale;
int x_index = i + leftOffset;
int y_index = j + downOffset;
//10/27 changed implementation to have all board tiles simply be accessible by everyone by default
//bool leftPlayer = (i < 0);
boardArray[x_index, y_index] = new BoardTile(x_index, y_index, xPos, yPos, 2, true);
//if (leftPlayer){
tileArray[x_index, y_index] = Instantiate(DefaultTile, new Vector3(xPos, yPos, 0), Quaternion.identity);
//} else {
// Instantiate(RightTile, new Vector3(xPos, yPos, 0), Quaternion.identity);
//}
}
}
control = GameObject.Find("GameManager").GetComponent <GameManager>();
//lPlayer = GameObject.Find("LeftPlayer").GetComponent<Player>();
//rPlayer = GameObject.Find("RightPlayer").GetComponent<Player>();
leftPlayerTile = PositionToTile(lPStartingLoc);
rightPlayerTile = PositionToTile(rPStartingLoc);
//i think 1/8 tiles being a hole, 1/8 tiles being a wall is good?
//this is assuming 4x8 = 32 total tiles, so 8 are obstacles
generateHoles_Walls(holes, walls);
}
/// <summary>
/// Transposes an array (turns rows to columns and columns to rows).
/// </summary>
/// <param name="boardArray">Original untransposed array.</param>
/// <returns></returns>
public BoardTile[,] Transpose2DArray(BoardTile[,] boardArray)
{
int w = boardArray.GetLength(0);
int h = boardArray.GetLength(1);
BoardTile[,] result = new BoardTile[h, w];
for (int i = 0; i < w; i++)
{
for (int j = 0; j < h; j++)
{
result[j, i] = boardArray[i, j];
}
}
return(result);
}
public GeneratedMove(bool isHorizontal, int startIndex, int endIndex, int[] anchor, Dictionary <BoardTile, CharTile> tilesUsed, BoardTile[,] boardBeforeMove, Rack rack)
{
IsHorizontal = isHorizontal;
StartIndex = startIndex;
EndIndex = endIndex;
Anchor = anchor;
TilesUsed = tilesUsed;
Word = GetWord();
BoardBeforeMove = new BoardTile[boardBeforeMove.GetLength(0), boardBeforeMove.GetLength(1)];
RackTilesUsedCoordinates = new List <int[]>();
ExtraWordsPlayed = new List <List <BoardTile> >();
//Creates a copy of the original board before move generation
//Used to get the scores of it and words connected.
for (int i = 0; i < BoardBeforeMove.GetLength(0); i++)
{
for (int j = 0; j < BoardBeforeMove.GetLength(1); j++)
{
BoardBeforeMove[i, j] = new BoardTile
{
BoardLocationX = boardBeforeMove[i, j].BoardLocationX,
BoardLocationY = boardBeforeMove[i, j].BoardLocationY,
BoardTileType = boardBeforeMove[i, j].BoardTileType,
CharTile = boardBeforeMove[i, j].CharTile,
IsFilled = boardBeforeMove[i, j].IsFilled
};
foreach (var tileUsed in TilesUsed)
{
if (BoardBeforeMove[i, j].BoardLocationX == tileUsed.Key.BoardLocationX &&
BoardBeforeMove[i, j].BoardLocationY == tileUsed.Key.BoardLocationY &&
BoardBeforeMove[i, j].CharTile == null)
{
RackTilesUsedCoordinates.Add(new int[] { i, j });
BoardBeforeMove[i, j].CharTile = tileUsed.Value;
}
}
}
}
BoardAfterMove = BoardBeforeMove;
Score = GetScore();
Rack = new Rack {
Rack_CharTiles = new List <Rack_CharTile>(rack.Rack_CharTiles)
};
RackScore = GetRackScore(Rack);
}
public void LaySquareBoard(Vector2 dimensions, int tileSize)
{
boardShape = BoardShape.Square;
MakeHitbox(new Vector2(0, 0), HitboxShape.Rectangle, new Vector3(dimensions.X * tileSize, dimensions.Y * tileSize, 0));
boardTiles = new BoardTile[(int)dimensions.X, (int)dimensions.Y];
int xPos = (int)((-dimensions.X / 2) * tileSize + tileSize / 2);
for (int x = 0; x < dimensions.X; x++)
{
int yPos = (int)((-dimensions.Y / 2) * tileSize + tileSize / 2);
for (int y = 0; y < dimensions.Y; y++)
{
MakeBoardTileSquare(x, y, xPos, yPos, tileSize);
yPos += tileSize;
}
xPos += tileSize;
}
}
void Awake()
{
//construct board if there is no board
if (tileBoard == null)
{
tileBoard = new BoardTile[sizeY, sizeX];
for (int y = 0; y < sizeY; ++y)
{
for (int x = 0; x < sizeX; ++x)
{
tileBoard[y, x] = Instantiate(TilePrefab, new Vector3(this.transform.position.x + x, this.transform.position.y + y), transform.rotation, this.transform).GetComponent <BoardTile>();
tileBoard[y, x].setBoard(this);
tileBoard[y, x].name = (string)(x + "_" + y);
}
}
}
}
// --------------------------------------------------------------------------------------------
public Board(Game game, int width, int height) : base("Board")
{
_game = game;
this.width = width;
this.height = height;
_tiles = new BoardTile[width, height];
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
BoardTile boardTile = new BoardTile(x, y);
AddChild(boardTile);
_tiles[x, y] = boardTile;
}
}
_groundPlane = new Plane(Vector3.up, Vector3.zero);
}
// Use this for initialization
void Start()
{
baselineX = GameBoardTile.transform.position.x;
baselineY = GameBoardTile.transform.position.y;
boardTiles = new BoardTile[BOARD_HEIGHT, BOARD_WIDTH];
boardTileWidth = (GameBoardSpriteDull.bounds.max - GameBoardSpriteDull.bounds.min).x;
boardTileHeight = (GameBoardSpriteDull.bounds.max - GameBoardSpriteDull.bounds.min).y;
//Create starting tile
for (int i = 0; i < BOARD_WIDTH; i++)
{
for (int j = 0; j < BOARD_HEIGHT; j++)
{
GetTile(i, j);
}
}
highlightedPosition = new XYPair();
highlightedPosition.x = BOARD_WIDTH / 2;
highlightedPosition.y = BOARD_HEIGHT / 2;
blankTile = (Instantiate(GameBoardTile, new Vector3(1000f, 1000f), Quaternion.identity) as GameObject).GetComponent <BoardTile>();
players = new MageController[4];
playerLocations = new XYPair[4];
currentPlayer = 0;
for (int i = 0; i < numPlayers; i++)
{
XYPair playerLocation = GetStartingPosition(i);
playerLocations[i] = playerLocation;
print("player " + i + " Location" + "x: " + playerLocation.x + "y: " + playerLocation.y);
GameObject tempPlayer = Instantiate(Player, ComputePosition(playerLocation.x, playerLocation.y), Quaternion.identity) as GameObject;
tempPlayer.SetActive(true);
players[i] = tempPlayer.GetComponent <MageController>();
if (i == 0)
{
players[0].SetPlayerName("Aaron");
}
players[i].PlayerID = i;
players[i].Mana = 1;
}
PlayerInputHandler.GameState = PlayerInputHandler.GameStateType.PLAYING;
}
public static void Initialize()
{
s_board = ConvertTilemapToLevelData(SaveManager.Load());
}
//Use this for preinitialization
public void Awake()
{
//Initalize the gridOutline
gridOutline = new BoardTile[boardSize, boardSize];
boardGen = new int[boardSize, boardSize];
}