public Grid()
{
m_field = new Square[NumberOfRows, NumberOfColumns];
for (int r = 0; r < NumberOfRows; ++r)
for (int c = 0; c < NumberOfColumns; ++c)
m_field[r, c] = new Square(r, c);
}
public SquareGrid(int[,] map, float squareSize)
{
int nodeCountX = map.GetLength(0);
int nodeCountY = map.GetLength(1);
float mapWidth = nodeCountX * squareSize;
float mapHeight = nodeCountY * squareSize;
ControlNode[,] controlNodes = new ControlNode[nodeCountX, nodeCountY];
for (int x = 0; x < nodeCountX; x++)
{
for (int y = 0; y < nodeCountY; y++)
{
Vector3 pos = new Vector3(-mapWidth / 2 + x * squareSize + squareSize / 2, 0, -mapHeight / 2 + y * squareSize + squareSize / 2);
controlNodes[x, y] = new ControlNode(pos, map[x, y] == 1, squareSize);
}
}
Squares = new Square[nodeCountX - 1, nodeCountY - 1];
for (int x = 0; x < nodeCountX - 1; x++)
{
for (int y = 0; y < nodeCountY - 1; y++)
{
Squares[x, y] = new Square(controlNodes[x, y + 1], controlNodes[x + 1, y + 1], controlNodes[x + 1, y], controlNodes[x, y]);
}
}
}
private bool done = false; // true when game is over
// initialize variables and thread for connecting to server
private void TicTacToeClientForm_Load(object sender, EventArgs e)
{
board = new Square[3, 3];
// create 9 Square objects and place them on the board
board[0, 0] = new Square(board0Panel, ' ', 0);
board[0, 1] = new Square(board1Panel, ' ', 1);
board[0, 2] = new Square(board2Panel, ' ', 2);
board[1, 0] = new Square(board3Panel, ' ', 3);
board[1, 1] = new Square(board4Panel, ' ', 4);
board[1, 2] = new Square(board5Panel, ' ', 5);
board[2, 0] = new Square(board6Panel, ' ', 6);
board[2, 1] = new Square(board7Panel, ' ', 7);
board[2, 2] = new Square(board8Panel, ' ', 8);
// create a SolidBrush for writing on the Squares
brush = new SolidBrush(Color.Black);
// make connection to server and get the associated
// network stream
connection = new TcpClient("127.0.0.1", 50000);
stream = connection.GetStream();
writer = new BinaryWriter(stream);
reader = new BinaryReader(stream);
// start a new thread for sending and receiving messages
outputThread = new Thread(new ThreadStart(Run));
outputThread.Start();
} // end method TicTacToeClientForm_Load
internal BoardCreator (Square[,] grid) {
Debug.Assert (grid != null);
this.grid = grid;
this.board = new Board (grid);
this.width = board.Width;
this.height = board.Height;
}
private Square[,] m_field; //dvodimenzijalno polje
#endregion Fields
#region Constructors
//konstruktor klase
public Grid()
{
m_field = new Square[NumberOfRows, NumberOfColumns];
for (int r = 0; r < 10; ++r) //rows
for (int c = 0; c < 10; ++c) //columns
m_field[r, c] = new Square(r, c); //inicijalizacija
}
public MainForm()
{
InitializeComponent();
controller = new Controller(this);
int panelWidth = this.MainBoard.Width;
int squareMargin = 10;
int width = panelWidth / 4;
int size = 150;
blocks = new Square[4, 4];
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 4; j++)
{
Square block = new Square();
blocks[i, j] = block;
block.Left = j * size;
block.Top = i * size;
block.Width = size;
block.Height = size;
block.Visible = true;
block.BackColor = Color.FromArgb(0, 100, 100, 100);
block.Margin = new Padding(squareMargin);
MainBoard.Controls.Add(block);
}
}
}
public AutoBoard(Difficulty difficulty)
{
_board = new Square[difficulty.Height,difficulty.Width];
CurrentState = State.Playing;
CurrentDifficulty = difficulty;
AddRandomMines(CurrentDifficulty.Mines);
}
public GameEngine(int rows, int columns, int numberOfMines)
{
this.rows = rows;
this.columns = columns;
this.numberOfMines = numberOfMines;
squares = new Square[rows, columns];
tiles = new ITile[rows,columns];
}
/// <summary>
/// Initializes a new instance of the <see cref="Board"/> class.
/// </summary>
/// <param name="width">
/// The width of the board
/// </param>
/// <param name="height">
/// The height of the board
/// </param>
/// <param name="floorTexture">
/// The floor Texture.
/// </param>
public Board(int width, int height, Texture2D floorTexture)
{
Contract.Requires(width > 1 && height > 1);
bounds = new Rectangle(0, 0, width, height);
board = new Square[width, height];
canSpawn = new bool[width, height];
this.floorTexture = floorTexture;
revealedAreas.Add(0);
}
private List<Unit> units; // list of your units on map
#endregion Fields
#region Constructors
/* constructor - note that we probably won't use this one much in the final game.
* Rather, we will usually use the default constructor (which initializes all the variables as nulls)
* and then use the Load method to get all the info from a text file
* */
public Map(Square[,] squares, List<Unit> enemies, int rows, int cols)
{
this.squares = squares;
this.enemies = enemies;
this.rows = rows;
this.cols = cols;
this.offset = Vector2.Zero;
this.units = new List<Unit>();
}
/// <summary>
/// Initialises a new instance of the ChessBoard class.
/// </summary>
public ChessBoard()
{
this.Round = 1;
this.squares = new Square[8, 8];
for (int i = 0; i < 8; i++) {
for (int j = 0; j < 8; j++) {
this.squares[i, j] = new Square();
}
}
}
public void DrawGrid()
{
squares = new Square[row, col];
for (int i = 0; i < row; i++)
for (int j = 0; j < col; j++)
{
Square sqr = new Square(this, i, j); //this is sending the game, probably can send the panel from game.Panel
squares[i, j] = sqr;
}
}
public Minesweeper(int rows, int columns, int mines)
{
Rows = rows;
Columns = columns;
Mines = mines;
_grid = new Square[Rows,Columns];
_minesLocation = new HashSet<int>();
ResetGrid();
}
/**
* Basic constructor. Does not conduct any dimension
* checks.
*/
public Tour(int width, int height)
{
Board = new Square[width, height];
for (int x = 0; x < width; x++)
for (int y = 0; y < height; y++)
Board[x, y] = new Square(x, y);
Width = width;
Height = height;
}
public void DrawGrid()
{
squares = new Square[row, col];
for (int i = 0; i < row; i++)
{
for (int j = 0; j < col; j++)
{
Square sqr = new Square(this, i, j); //this is sending the game, probably can send the panel from game.Panel
squares[i, j] = sqr;
}
}
}
public Chessboard()
{
squares = new Square[FilesNumber, RanksNumber];
for (int i = 0; i < FilesNumber; i++)
{
for (int j = 0; j < RanksNumber; j++)
{
squares[i, j] = new Square(Char.Parse(Enum.GetName(typeof(fileNames), i)), j + 1, (i + j) % 2 == 0 ? blackColor : whiteColor);
}
}
}
public ChessBoardSnapshot(int turn, Square[,] squares)
{
this.turn = turn;
pieceSnapshots = new List <PieceSnapshot>();
foreach (Square square in squares)
{
if (square.piece != null)
{
pieceSnapshots.Add(new PieceSnapshot(square.piece));
}
}
}
/// <summary>
/// Instantiate <see cref="Board"/>
/// </summary>
public Board()
{
_squares = new Square[Size, Size];
for (int file = 1; file <= Size; file++)
{
for (int rank = 1; rank <= Size; rank++)
{
var fileEnum = (File) file;
this[Square.GetId(fileEnum, rank)] = new Square(fileEnum, rank);
}
}
}
private void CreateSquares(BoardArray board)
{
squares = new Square[countY, countX];
for (int i = 0; i < countY; i++)
{
for (int j = 0; j < countX; j++)
{
CreateSquare(i, j, board.rows[i].row[j]);
}
}
StartCoroutine(ShowCreatedSquares());
}
/// <summary>
/// Instantiate <see cref="Board"/>
/// </summary>
public Board()
{
_squares = new Square[Size, Size];
for (int file = 1; file <= Size; file++)
{
for (int rank = 1; rank <= Size; rank++)
{
var fileEnum = (File)file;
this[Square.GetId(fileEnum, rank)] = new Square(fileEnum, rank);
}
}
}
public SquareMatrix(SquareEdgeNodeMatrix edgeNodes)
{
squares = new Square[edgeNodes.Width - 1, edgeNodes.Height - 1];
for (var x = 0; x < edgeNodes.Width - 1; x++)
{
for (var y = 0; y < edgeNodes.Height - 1; y++)
{
squares[x, y] = CreateSquare(edgeNodes, x, y);
}
}
}
public Square finishShip(Board board)
{
Square[,] squares = board.AllSquares();
//SIMPLIFY
for (int i = 0; i < squares.GetLength(0); i++)
{
for (int j = 0; j < squares.GetLength(1); j++)
{
if (board.IsShipShotNotSunk(i, j))
{
if (i + 1 < squares.GetLength(0) && board.IsShipShotNotSunk(i + 1, j))
{
int index = i + 2;
while (index < squares.Length && board.IsShipShotNotSunk(index, j))
{
index++;
}
return(squares[index, j]);
}
if (i - 1 > 0 && board.IsShipShotNotSunk(i - 1, j))
{
int index = i - 2;
while (index > 0 && board.IsShipShotNotSunk(index, j))
{
index--;
}
return(squares[index, j]);
}
if (j + 1 < squares.GetLength(1) && board.IsShipShotNotSunk(i, j + 1))
{
int index = j + 2;
while (index < squares.Length && board.IsShipShotNotSunk(i, index))
{
index++;
}
return(squares[i, index]);
}
if (j - 1 > 0 && board.IsShipShotNotSunk(i, j - 1))
{
int index = j - 2;
while (index > 0 && board.IsShipShotNotSunk(i, index))
{
index--;
}
return(squares[i, index]);
}
}
}
}
return(null);
}
public Board(bool pb)
{
playerBoard = pb;
grid = new Square[10, 10];
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 10; j++)
{
grid[i, j] = new Square(pb);
}
}
}
private static void backRank(Colour inColour, int y, ref Square[,] inBoard)
{
//Ew
inBoard[0, y] = new Square('A', y + 1, new Rook(inColour));
inBoard[1, y] = new Square('B', y + 1, new Knight(inColour));
inBoard[2, y] = new Square('C', y + 1, new Bishop(inColour));
inBoard[3, y] = new Square('D', y + 1, new Queen(inColour));
inBoard[4, y] = new Square('E', y + 1, new King(inColour));
inBoard[5, y] = new Square('F', y + 1, new Bishop(inColour));
inBoard[6, y] = new Square('G', y + 1, new Knight(inColour));
inBoard[7, y] = new Square('H', y + 1, new Rook(inColour));
}
public Board(int matrixSize)
{
Matrix = new Square[matrixSize + 2, matrixSize + 2];
for (uint x = 0; x <= matrixSize + 1; x++)
{
for (uint y = 0; y <= matrixSize + 1; y++)
{
Matrix[x, y] = new Square(x, y);
}
}
}
public Gameboard()
{
gameSquares = new Square[GAMEBOARD_HEIGHT, GAMEBOARD_WIDTH];
for (int _row = 0; _row < GAMEBOARD_HEIGHT; ++_row)
{
for (int _column = 0; _column < GAMEBOARD_WIDTH; ++_column)
{
gameSquares[_row, _column] = new Square(_row, _column);
}
}
}
private void CreateMap(int x, int y)
{
array = new Square[x, y];
for (int i = 0; i < x; i++)
{
for (int j = 0; j < y; j++)
{
array[i, j] = new Square();
}
}
}
//constructor method
public Puzzle(int size)
{
N = size;
grid = new Square[size, size];
for (int i = 0; i < this.N; i++) // looping through the 2-D array and creating all the nessacary instances of the square class
{
for (int j = 0; j < this.N; j++)
{
grid[i, j] = new Square();
}
}
}
public override void Evaluate(Square[,] b)
{
Square[,] board = null;
if (b == null)
{
board = Board.Instance.SquareMatrix;
}
else
{
board = b;
}
possibleMoves.Clear();
int actualX = this.actualSquare.X;
int actualY = this.actualSquare.Y;
bool right = true, left = true, up = true, down = true;
bool rightUp = true, rightDown = true, leftUp = true, leftDown = true;
int i = 1;
if (rightUp)
{
EvaluateBoardInPosition(board, actualX + i, actualY + i, out rightUp);
}
if (rightDown)
{
EvaluateBoardInPosition(board, actualX + i, actualY - i, out rightDown);
}
if (leftDown)
{
EvaluateBoardInPosition(board, actualX - i, actualY - i, out leftDown);
}
if (leftUp)
{
EvaluateBoardInPosition(board, actualX - i, actualY + i, out leftUp);
}
if (right)
{
EvaluateBoardInPosition(board, actualX + i, actualY, out right);
}
if (left)
{
EvaluateBoardInPosition(board, actualX - i, actualY, out left);
}
if (up)
{
EvaluateBoardInPosition(board, actualX, actualY + i, out up);
}
if (down)
{
EvaluateBoardInPosition(board, actualX, actualY - i, out down);
}
}
public void StartCustomGame(int width, int height, int mines)
{
playField = gameManager.NewCustomGame(width, height, mines);
previousGameMode = "custom";
previousCustomWidth = width;
previousCustomHeight = height;
previousCustomMines = mines;
//previousCustomMineSaturation = saturation;
DrawPlayField(playField);
}
public static void PrintResult(int rows, int columns, Square[,] squares)
{
for (int i = 0; i < rows; i++)
{
Console.Write("\r\n");
for (int j = 0; j < columns; j++)
{
Console.Write(squares[i, j].ToString());
}
}
Console.Write("\r\n");
}
internal BoardGame(short size)
{
this.m_Size = size;
m_Board = new Square[this.m_Size, this.m_Size];
for (int i = 0; i < this.m_Size; i++)
{
for (int j = 0; j < this.m_Size; j++)
{
m_Board[i, j] = new Square(Square.eSquareType.None, i, j);
}
}
}
private void CreateSquares()
{
squares = new Square[countY, countX];
for (int i = 0; i < countY; i++)
{
for (int j = 0; j < countX; j++)
{
CreateSquare(i, j);
}
}
StartCoroutine(ShowCreatedSquares());
}
/// <summary>
/// Generate a 1-1 copy of the given board
/// </summary>
/// <param name="board"></param>
/// <returns></returns>
public Square[,] GenerateBoardCopy(Square[,] board)
{
Square[,] copy = new Square[8, 8];
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
copy[i, j] = new Square(board[i, j]);
}
}
return(copy);
}
/// <summary>
/// moves player left one square (if this is within the bounds of the squares)
/// </summary>
/// <param name="squares"></param>
public void moveLeft(Square[,] squares)
{
int newCol = column - 1;
if (newCol >= 0)//checks this move is allowed
{
savePath();
hide(squares);
column = newCol;
show(squares);
}
}
/// <summary>
/// moves player down one square (if move is within the bounds of the grid)
/// </summary>
/// <param name="squares"></param>
public void moveDown(Square[,] squares)
{
int newRow = row + 1;
if (newRow < squares.GetLength(0))//check move is allowed
{
savePath();
hide(squares);
row = newRow;
show(squares);
}
}
public Player(Player other, Square[,] newBoard)
{
iD = other.iD;
this.modSquareTableValue = other.modSquareTableValue;
this.type = other.type;
pieces = new List <Piece>();
for (int i = 0; i < other.pieces.Count; i++)
{
var newPiece = other.pieces[i].Copy(newBoard[other.pieces[i].ActualSquare.Y, other.pieces[i].ActualSquare.X]);
newPiece.SetPropietary(this);
}
}
// used to draw the game
public void OnDrawing(Tetris.GameBase.TetrisGame game,
Tetris.GameBase.TetrisGame.DrawEventArgs e)
{
Square[,] image = game.Image;
if (imageCache == null)
{
imageCache = new int[image.GetUpperBound(0) + 1, image.GetUpperBound(1) + 1];
Array.Clear(imageCache, 0, (image.GetUpperBound(0) + 1) * (image.GetUpperBound(1) + 1));
}
int i, j;
for (i = 0; i < game.Height; i++)
{
for (j = 0; j < game.Width; j++)
{
// only draw the changed part
if ((image[i, j] == null && imageCache[i, j] != 0) || (image[i, j] != null && image[i, j].Color + image[i, j].SubId != imageCache[i, j]))
{
imageCache[i, j] = image[i, j] == null ? 0 : image[i, j].Color + image[i, j].SubId;
try
{
squaresMatrix[i, j].Dispatcher.Invoke(
new Action(
delegate
{
/*
* squaresMatrix[i, j].Fill =
* new SolidColorBrush(
* colorMap[
* image[i, j] == null
* ? 0
* : (image[i, j].Color < colorMap.Length
* ? image[i, j].Color
* : colorMap.Length - 1)]);
*/
squaresMatrix[i, j].Fill = SquareGenerator.brushClone(
brushesMap[
image[i, j] == null
? 0
: (image[i, j].Color + image[i, j].SubId
< brushesMap.Length
? image[i, j].Color + +image[i, j].SubId
: brushesMap.Length - 1)]);
}
));
}
catch
{
}
}
}
}
}
public void RunMiniMax(Player maxPlayer, Player minPlayer, Square[,] board)
{
vueltas = 0;
int maxValue = MiniMaxFunctionRoot(maxPlayer, minPlayer, board);
Debug.Log("Total Boards Evaluated: " + vueltas.ToString());
pieceToMove.Move(bestMove.Square.RelatedBehaviour);
bestMove.RunCallback();
GameController.Instance.ChangeTurns();
GameController.Instance.EvaluatePlayers();
}
private void printTheGrid(int maxX, int maxY, Square[,] grid)
{
for (int x = 0; x < maxX; x++)
{
for (int y = 0; y < maxY; y++)
{
Console.Write(grid[x, y].ID);
}
Console.Write("\n");
}
Console.ReadLine();
}
public static void printBoard(Square[,] board)
{
for (int y = 0; y < Board.ySize; y++)
{
string s = "";
for (int x = 0; x < Board.xSize; x++)
{
s += board[x, y].playerSign + "\t";
}
Console.WriteLine(s);
}
}
public void CreateZone(Square [,] square)
{
for (int i = 0; i < 10; i++)
{
for (int a = 0; a < 10; a++)
{
square[i, a].y = i;
square[i, a].x = a;
square[i, a].data = " ";
}
}
}
/// <summary>
/// Moves player right one square (if move is within grid)
/// </summary>
/// <param name="squares"></param>
public void moveRight(Square[,] squares)
{
int newCol = column + 1;
if (newCol < squares.GetLength(0))//checks move is allowed
{
savePath();
hide(squares);
column = newCol;
show(squares);
}
}
/// <summary>
/// Moves player up one square (checks if move is allowed first)
/// </summary>
/// <param name="squares"></param>
public void moveUp(Square[,] squares)
{
int newRow = row - 1;
if (newRow >= 0)//check if move is allowed
{
savePath();
hide(squares);
row = newRow;
show(squares);
}
}
public static Bitmap drawBoard(Square[,] bord)
{
Bitmap bob = new Bitmap(50, 100);
for (int i = 1; i < 50; i++)
{
for (int j = 1; j < 100; j++)
{
if (bord[i / 10, j / 10] == null)
{
bob.SetPixel(i, 100 - j, Color.Black);
}
else if (bord[i / 10, j / 10].color == 1)
{
bob.SetPixel(i, 100 - j, Color.Red);
}
else if (bord[i / 10, j / 10].color == 2)
{
bob.SetPixel(i, 100 - j, Color.Green);
}
else if (bord[i / 10, j / 10].color == 3)
{
bob.SetPixel(i, 100 - j, Color.Purple);
}
else
{
bob.SetPixel(i, 100 - j, Color.Black);
}
}
}
return(bob);
/*Graphics g = Graphics.FromImage(bob);
* Brush wb = Brushes.White;
* Brush rb = Brushes.Red;
* Brush gb = Brushes.Green;
* Brush pb = Brushes.Purple;
* for (int i = 0; i < 5; i++)
* {
* for (int j = 0; j < 10; j++)
* {
* if (bord[i,j] == null) { g.FillRectangle(wb, i * 5, j * 5, i * (5 + 1), j * (5 + 1)); }
* else if (bord[i, j].color == 1) { g.FillRectangle(rb, i * 5, j * 5, i * (5 + 1), j * (5 + 1)); }
* else if (bord[i, j].color == 2) { g.FillRectangle(gb, i * 5, j * 5, i * (5 + 1), j * (5 + 1)); }
* else if (bord[i, j].color == 3) { g.FillRectangle(pb, i * 5, j * 5, i * (5 + 1), j * (5 + 1)); }
* }
* }
*
* bob.Save("myimage.png");*/
//return false;
}
// Constructor
public Grid(int width, int height)
{
this.width = width;
this.height = height;
grid = new Square[(int)width, (int)height];
for(int i = 0; i < width; i++) {
for(int j = 0; j < height; j++) {
Vector2 loc = new Vector2(i, j);
Square sq = new Square(this, loc, new Vector3(i, j, 0.0f));
grid[i, j] = sq;
}
}
}
public void GenerateEmpty(int hauteurArg, int largeurArg, bool stockReferences = false)
{
Square[,] tab = new Square[hauteurArg, largeurArg];
this.transform.position = new Vector3(0.5f,0.5f,0);
for (int i= 0; i<hauteurArg; i++)
{
for(int j = 0; j<largeurArg; j++)
{
tab[i,j] = (Square) Instantiate (emptySquare, new Vector3(this.transform.position.x + j, this.transform.position.y + i, 0), Quaternion.identity);
tab[i,j].transform.SetParent(this.transform);
}
}
mapSquares = tab;
}
public Grid(List<List<Square>> squares)
{
_grid = new Square[squares.Count, squares.Count];
var size = squares.Count;
for (var x = 0; x < size; x++)
{
for (var y = 0; y < size; y++)
{
_grid[x, y] = squares[y][x];
}
}
}
public Board(int size)
{
RowSize = size;
// Create the array to store the squares.
_board = new Square[RowSize, RowSize];
// Populate the board with Square objects.
for (int i = 0; i < RowSize; ++i)
{
for (int j = 0; j < RowSize; ++j)
{
_board[i, j] = new Square(i, j);
}
}
}
public Card(int rows)
{
_rows = rows;
_card = new Square[rows, 5];
int currentStart = 1;
for (int col = 0; col < 5; col++)
{
var randomise = Randomizer.Randomize(currentStart, currentStart + rows - 1);
for (int row = 0; row < rows; row++)
_card[row, col] = new Square(randomise[row]);
currentStart = currentStart + rows;
}
}
public MapManager(int size, MapTextures mapTex, CowPiece head, Game1 game)
{
this.size = size;
map = new Square[size,size];
this.grassTexture = mapTex.grassTexture;
this.hedgeTexture = mapTex.hedgeTexture;
this.hedgeVertTexture = mapTex.hedgeVertTexture;
this.hedgeCornerTexturetl = mapTex.hedgeCornerTexturetl;
this.hedgeCornerTexturetr = mapTex.hedgeCornerTexturetr;
this.hedgeCornerTexturebl = mapTex.hedgeCornerTexturebl;
this.hedgeCornerTexturebr = mapTex.hedgeCornerTexturebr;
this.hedgeCrossTexture = mapTex.hedgeCrossTexture;
this.foodTexture = mapTex.foodTexture;
headPiece = head;
this.game = game;
createMap();
}
//reads all the info for a map from a text file.
public void Load(string filename)
{
StreamReader stream = new StreamReader(filename);
string line = stream.ReadLine();
this.rows = int.Parse(line); // first line is the # of rows
line = stream.ReadLine();
this.cols = int.Parse(line); // second line is the # of columns
this.squares = new Square[rows, cols];
for (int i = 0; i < rows; i++)
{
for (int j = 0; j < cols; j++) // rest of the lines are each one square
{
line = stream.ReadLine();
squares[i, j].Load(line);
}
}
}
private void SetupEntityGrid()
{
GameUniformGrid.Children.Clear();
GameBoard = new Square[25, 25];
for (int x = 0; x < 25; x++)
{
for (int y = 0; y < 25; y++)
{
Square r = new Square { Background = Brushes.MintCream };
GameBoard[x, y] = r;
GameBoard[x, y].Margin = new Thickness(1);
GameUniformGrid.Children.Add(GameBoard[x, y]);
Console.WriteLine(GameBoard[x,y]);
}
}
}
// Use this for initialization
void Start () {
//if suggesting, make a pool
if (suggesting) {
pool = new ArrayList ();
for (int i = 0; i < size * size; i++) {
pool.Add (i / size + 1);
}
}
grid = new Square [size, size];
// counter = new int[10];
//very hacky way of filling the grid
//use overlap spheres to find which square is at each position
//may change later
for (int i = 0; i < size; i++) {
for (int j = 0; j < size; j++) {
grid[i,j] = (Physics.OverlapSphere(new Vector3((-1 * size + 1 + 2f*i), (-1 * size + 1 + 2f*j), 0f), 0.01f))[0].gameObject.GetComponent<Square>();
// grid [i, j].active = true;
// counter[grid[i,j].number]++;
if (suggesting && grid [i, j].number != 0) {
pool.Remove (grid [i, j].number);
}
}
}
//if suggesting, generate the nums for the first round
if (suggesting) {
Debug.Log ("GENERATING NEW SET");
suggestions = generateNums ();
string numBuf = "";
for (int i = 0; i < numSuggestions; i++) {
numBuf = numBuf + " | " + suggestions [i];
}
Debug.Log(numBuf + " | ");
suggestionTimer = 0f;
suggestionIndex = 0;
}
// totalNumsPlaced = 0;
}
private Board()
{
matrix = new Square[NUM_ROWS, NUM_ROWS];
whitePieces = new List();
blackPieces = new List();
this.Size = new Size(480, 480);
this.Location = new Point(30, 30);
// Create the squares
int h;
int v = 0;
for (int i = 0; i < NUM_ROWS; i++)
{
h = 0;
for (int j = 0; j < NUM_ROWS; j++)
{
matrix[i, j] = new Square(new Position(i, j));
if ((i + j) % 2 == 0)
{
matrix[i, j].BackgroundImage = Image.FromFile(path + "//WhiteWood.gif");
}
else {
matrix[i, j].BackgroundImage = Image.FromFile(path + "//BlackWood.gif");
}
matrix[i, j].Name = "square" + i + "" + j; //square00, square01, etc.
matrix[i, j].Location = new Point(h, v);
matrix[i, j].Click += new System.EventHandler(this.square_Click);
h += 60;
matrix[i, j].Size = new Size(60, 60);
this.Controls.Add(matrix[i, j]);
}
v += 60;
}
}
public BoardControl(int row, int col, int mines)
{
this.Dock = DockStyle.Fill;
this.BorderStyle = BorderStyle.Fixed3D;
this.DoubleBuffered = true;
this.ResizeRedraw = true;
this.columns = col;
this.rows = row;
//this.MouseMove += new MouseEventHandler(BoardControl_MouseMove);
//this.Paint += new PaintEventHandler(OnPaint);
squares = new Square[row, col];
for (int x = 0; x < row; x++)
{
for (int y = 0; y < col; y++)
{
squares[x, y] = new Square();
squares[x, y].Bounds = new Rectangle(x * SQUARE_SIZE, y * SQUARE_SIZE, SQUARE_SIZE, SQUARE_SIZE);
}
}
}
public VisualDisplay(GameWindow window) {
this.window = window;
window.UpdateFrame += window_UpdateFrame;
window.RenderFrame += window_RenderFrame;
window.Resize += window_Resize;
window.KeyPress += window_KeyPress;
window.Closed += window_Closed;
window.Load += window_Load;
window.MouseUp += window_MouseUp;
board = new Square[14, 14];
colors = new Color[6];
GridSize = window.Height / 15f;
GridPosX = window.Width / 20f;
GridPosY = window.Height / 20f;
ControlSize = window.Height / 10f;
ControlPosX = window.Width * (0.7f);
ControlPosY = window.Height * (0.2f);
setupBoard();
}
public Maze(int w, int h, int s)
{
width = w;
height = h;
spacing = s;
random = new Random();
List<int> randomList = CreateSloppyRandomList(width * height);
randomUnblockedSquares = new List<Square>();
// initialize all squares
squares = new Square[height, width];
int i = 0;
for (int r = 0; r < height; ++r) {
for (int c = 0; c < width; ++c) {
squares[r, c] = new Square(r, c, this);
squares[r, c].Id = randomList[i];
i++;
}
}
}
// Use this for initialization
void Start()
{
mTerrain = this.GetComponent <Terrain>();
/*lineRenderer = gameObject.AddComponent<LineRenderer>();
lineRenderer.SetVertexCount(5);
if(lineRenderer == null)
{
Debug.Log ("null lineRenderer");
}else {Debug.Log("lineRenderer");}*/
mTData = mTerrain.terrainData;
mTerrainWidth = (int)mTData.size.x;
mTerrainLength = (int)mTData.size.z;
mTileWidth = (mTerrainWidth / mXCells);
mTileLength = (mTerrainLength / mYCells);
mSquare = new Square[mXCells, mYCells];
//legger object i den todimensjonale Square tabellen
GL.Begin(GL.LINES);
for (int i = 0; i < mXCells; i++)
{
for (int j = 0; j < mYCells; j++)
{
mSquare[i,j] =new Square( (i*mTileWidth), (j*mTileLength), mTileWidth, mTileLength, this.gameObject);
}
}
//Writing out the toString for every Square object
for(int i =0; i<mXCells; i++)
{
for(int j = 0; j<mYCells; j++)
{
}
}
}
private void CreateSquares(ByteMatrix byteMatrix, int squareSize)
{
squares = new Square[(byteMatrix.Width / squareSize) + 1, (byteMatrix.Height / squareSize) + 1];
for (int y = 0, cntY = 0; y < byteMatrix.Height; y+=squareSize, cntY++)
{
for (int x = 0, cntX = 0; x < byteMatrix.Width; x+=squareSize, cntX++)
{
Color clr;
if (byteMatrix.Array[x][y] == 0)
clr = Color.Black;
else
clr = Color.White;
squares[cntX, cntY] = new Square(
new Size(squareSize, squareSize),
new System.Drawing.Point(cntX * squareSize, cntY * squareSize)
);
squares[cntX, cntY].Color = clr;
}
}
}
