public Square[,] squares; // 2D array // Constructor public SquareGrid(int[,] map, float squareSize) { // Variables int nodeCountX = map.GetLength(0); int nodeCountY = map.GetLength(1); float mapWidth = nodeCountX * squareSize; float mapHeight = nodeCountY * squareSize; // 2D array of ControlNodes ControlNode[,] controlNodes = new ControlNode[nodeCountX, nodeCountY]; // Creating grid of ControlNodes for (int x = 0; x < nodeCountX; x++) { for (int y = 0; y < nodeCountY; y++) { // Calculate position 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); } // inner for } // for squares = new Square[nodeCountX - 1, nodeCountY - 1]; // Go through each each square // Creating grid of squares out of ControlNodes for (int x = 0; x < nodeCountX - 1; x++) { for (int y = 0; y < nodeCountY - 1; y++) { // Top left, top right, bottom right, bottom left control nodes squares[x, y] = new Square(controlNodes[x, y + 1], controlNodes[x + 1, y + 1], controlNodes[x + 1, y], controlNodes[x, y]); } // inner for } // for } // SquareGrid()
public Square[,] squares; //array de cuadrados 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); //-mapWith/2 far left (no antec) controlNodes[x, y] = new ControlNode(pos, map[x, y] == 1, squareSize);//pasa true or false (==1) } } squares = new Square[nodeCountX - 1, nodeCountY - 1]; //sempre hi ha un quadrat menos que nodos 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]); } } //va a cada quadrat i fa els seus control Nodes, bottom left, bottom right etc. }
public override void PaintControl(RichTextBox control, ControlPaintArgs args) { INode controlNode = new ControlNode(control); IRuleset ruleset = args.StyleSheet.GetRuleset(controlNode); RenderUtilities.ApplyColorProperties(control, ruleset); Rectangle clientRect = control.ClientRectangle; Rectangle borderRect = new Rectangle(clientRect.X - 3, clientRect.Y - 3, clientRect.Width + 6, clientRect.Height + 6); ScrollBars visibleScrollbars = ControlUtilities.GetVisibleScrollBars(control); if (visibleScrollbars.HasFlag(ScrollBars.Vertical)) { borderRect = new Rectangle(borderRect.X, borderRect.Y, borderRect.Width + SystemInformation.VerticalScrollBarWidth, borderRect.Height); } if (visibleScrollbars.HasFlag(ScrollBars.Horizontal)) { borderRect = new Rectangle(borderRect.X, borderRect.Y, borderRect.Width, borderRect.Height + SystemInformation.HorizontalScrollBarHeight); } args.PaintBackground(borderRect); args.PaintBorder(borderRect); }
public int squareConfiguration; // this value will equal this squares marching squares configuration, please see documentation to see marching square configurations. // the square constructor public Square(ControlNode _topLeft, ControlNode _topRight, ControlNode _bottomRight, ControlNode _bottomLeft) { // set the control Nodes topLeft = _topLeft; topRight = _topRight; bottomRight = _bottomRight; bottomLeft = _bottomLeft; //set the nodes depending on the control nodes centreTop = topLeft.right; centreRight = bottomRight.above; centreBot = bottomLeft.right; centreLeft = bottomLeft.above; if (topLeft.active) // if the top left node is active { squareConfiguration += 8; // add 8 to the square configuration } if (topRight.active) // if the top right node is active { squareConfiguration += 4; // add 4 to the square configuration } if (bottomRight.active) // if the bottom right node is active { squareConfiguration += 2; // add 2 to the square configuration } if (bottomLeft.active) // if the bottom left node is active { squareConfiguration += 1; // add one to the square configuration } // the configuration is ued for the marching squares formula. }
// Private members private void PaintDropDownArrow(ComboBox control, ControlPaintArgs e) { INode controlNode = new ControlNode(control); UserNode dropDownArrowNode = new UserNode(string.Empty, new[] { "DropDownArrow" }); dropDownArrowNode.SetParent(controlNode); dropDownArrowNode.SetStates(controlNode.States); IRuleset ruleset = e.StyleSheet.GetRuleset(dropDownArrowNode); // Create the arrow rectangle to match the bounds of the default control. Rectangle clientRect = control.ClientRectangle; Rectangle arrowRect = new Rectangle(clientRect.Right - 12, clientRect.Y + 9, 7, 6); e.Graphics.SmoothingMode = SmoothingMode.AntiAlias; using (Pen pen = new Pen(ruleset.Color?.Value ?? SystemColors.ControlText)) { pen.Width = 2.0f; pen.Alignment = PenAlignment.Center; pen.StartCap = LineCap.Flat; pen.EndCap = LineCap.Flat; PointF bottomMidpoint = new PointF(arrowRect.Left + arrowRect.Width / 2.0f, arrowRect.Bottom - 1); e.Graphics.DrawLine(pen, new PointF(arrowRect.Left, arrowRect.Top), bottomMidpoint); e.Graphics.DrawLine(pen, new PointF(arrowRect.Right, arrowRect.Top), bottomMidpoint); } }
public Square(ControlNode _bL, ControlNode _bR, ControlNode _tL, ControlNode _tR) { topLeft = _tL; topRight = _tR; bottomLeft = _bL; bottomRight = _bR; top = topLeft.right; bottom = bottomLeft.right; left = bottomLeft.above; right = bottomRight.above; configuration = 0; if (topLeft.active) { configuration += 8; } if (topRight.active) { configuration += 4; } if (bottomRight.active) { configuration += 2; } if (bottomLeft.active) { configuration += 1; } }
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++) { /* * RaycastHit hitInfo; * Vector3 fwd = transform.TransformDirection(Vector3.down); * Vector3 VecPos = new Vector3(-mapWidth/2 + x * squareSize + squareSize/2, 0, -mapHeight/2 + y * squareSize + squareSize/2); * if (Physics.Raycast(VecPos, fwd, out hitInfo) { * print("____________________hitInfo.distance__"+hitInfo.distance); * }*/ 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]); } } }
public Square(ControlNode _topLeft, ControlNode _topRight, ControlNode _bottomRight, ControlNode _bottomLeft) { topLeft = _topLeft; topRight = _topRight; bottomRight = _bottomRight; bottomLeft = _bottomLeft; centreTop = topLeft.right; centreRight = bottomRight.above; centreBottom = bottomLeft.right; centreLeft = bottomLeft.above; //in binary 0000 if (topLeft.active) { configuration += 8; //1000 } if (topRight.active) { configuration += 4; //0100 } if (bottomRight.active) { configuration += 2; //0010 } if (bottomLeft.active) { configuration += 1; //0001 } }
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]); } } }
public Square(ControlNode _topLeft, ControlNode _topRight, ControlNode _bottomRight, ControlNode _bottomLeft) { topLeft = _topLeft; topRight = _topRight; bottomRight = _bottomRight; bottomLeft = _bottomLeft; centreTop = topLeft.right; centreRight = bottomRight.above; centreBottom = bottomLeft.right; centreLeft = bottomLeft.above; if (topLeft.active) { configuration += 8; } if (topRight.active) { configuration += 4; } if (bottomRight.active) { configuration += 2; } if (bottomLeft.active) { configuration += 1; } }
public SquareGrid(int[,] map, float squareSize, AnimationCurve heightCurve = null, float heightMultiplier = 0, float[,] noiseMap = null, float[,] fallofMap = null, float[,] _noiseOffsetMap = null) { 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++) { float heightValue = (heightCurve != null && noiseMap != null) ? (heightCurve.Evaluate((float)noiseMap[x, y]) + ((_noiseOffsetMap != null)?_noiseOffsetMap[x, y]: 0)) * (float)heightMultiplier : 0; Vector3 pos = new Vector3(-mapWidth / 2 + x * squareSize + squareSize / 2, heightValue, -mapHeight / 2 + y * squareSize + squareSize / 2); controlNodes[x, y] = new ControlNode(pos, map[x, y] == 1, squareSize, new int[x, y]); } } 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]); } } }
public SquareGrid(int[,] map, float squareSize) // a new grid created for use as the new generation { int nodeCountX = map.GetLength(0); //the x direction amount to create the grid horizonally int nodeCountY = map.GetLength(1); //the x direction amounnt to create the grid vertically float mapWidth = nodeCountX * squareSize; //the size the grid will be based on the size of each square float mapHeight = nodeCountY * squareSize; ControlNode[,] controlNodes = new ControlNode[nodeCountX, nodeCountY];// the 2d array version of the grids controle nodes for (int x = 0; x < nodeCountX; x++) { for (int y = 0; y < nodeCountY; y++) { Vector3 pos = new Vector3(-mapWidth / 2 + x * squareSize + squareSize / 2, -mapHeight / 2 + y * squareSize + squareSize / 2, 0); //finding the center position of the square controlNodes[x, y] = new ControlNode(pos, map[x, y] == 1, squareSize); // crates the series of the control/nodes for each generated square } } squares = new Square[nodeCountX - 1, nodeCountY - 1]; for (int x = 0; x < nodeCountX - 1; x++)//loop to check was position in 2d array squares { 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]);// assings the instance of the control nodes in square (which inturn assings nodes) }//for each of the positions in the 2d array squares } }
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 _position = new Vector3(-_mapWidth / 2 + x * _squareSize + _squareSize / 2, 0, -_mapHeight / 2 + y * _squareSize + _squareSize / 2); controlNodes[x, y] = new ControlNode(_position, _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]); } } }
public int configuration;//guarda els bits ctius public Square(ControlNode _topLeft, ControlNode _topRight, ControlNode _bottomRight, ControlNode _bottomLeft) { topLeft = _topLeft; topRight = _topRight; bottomRight = _bottomRight; bottomLeft = _bottomLeft; centreTop = topLeft.right; centreRight = bottomRight.above; centreBottom = bottomLeft.right; centreLeft = bottomLeft.above; if (topLeft.active) { configuration += 8; //el bists que se sumen segons el nodo actiu } if (topRight.active) { configuration += 4; } if (bottomRight.active) { configuration += 2; } if (bottomLeft.active) { configuration += 1; } }
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]); } } }
public Grid(int[,] map, float squareSize) { var nodeCountX = map.GetLength(0); var nodeCountY = map.GetLength(1); Width = nodeCountX - 1; Height = nodeCountY - 1; var mapWidth = nodeCountX * squareSize; var mapHeight = nodeCountY * squareSize; var controlNodes = new ControlNode[nodeCountX, nodeCountY]; For.Xy(nodeCountX, nodeCountY, (x, y) => { var position = new Vector3(-mapWidth / 2 + x * squareSize + squareSize / 2, 0, -mapHeight / 2 + y * squareSize + squareSize / 2); controlNodes[x, y] = new ControlNode(position, map[x, y] == 1, squareSize); }); _squares = new Square[Width, Height]; For.Xy(Width, Height, (x, y) => { _squares[x, y] = new Square( controlNodes[x, y + 1], controlNodes[x + 1, y + 1], controlNodes[x + 1, y], controlNodes[x, y] ); }); }
public int Configuration = 0; // The configuration the square is in (16 possibles in marching squares) public Square(ControlNode topLeft, ControlNode topRight, ControlNode bottomRight, ControlNode bottomLeft) { TopLeft = topLeft; TopRight = topRight; BottomLeft = bottomLeft; BottomRight = bottomRight; CenterTop = TopLeft.Right; CenterRight = BottomRight.Above; CenterBottom = BottomLeft.Right; CenterLeft = BottomLeft.Above; // Determine the configuration based on the active nodes if (TopLeft.Active) // 1000 = 8 { Configuration += 8; } if (TopRight.Active) // 0100 = 4 { Configuration += 4; } if (BottomRight.Active) // 0010 = 2 { Configuration += 2; } if (BottomLeft.Active) // 0001 = 1 { Configuration += 1; } }
public Square(ControlNode topLeft, ControlNode topRight, ControlNode bottomRight, ControlNode bottomLeft) { this.topLeft = topLeft; this.topRight = topRight; this.bottomRight = bottomRight; this.bottomLeft = bottomLeft; centerTop = topLeft.right; centerRight = bottomRight.above; centerBottom = bottomLeft.right; centerLeft = bottomLeft.above; if (topLeft.active) { configuration += 8; } if (topRight.active) { configuration += 4; } if (bottomRight.active) { configuration += 2; } if (bottomLeft.active) { configuration += 1; } }
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]; Vector3 pos = Vector3.zero; for (int i = 0; i < nodeCountX; i++) { for (int j = 0; j < nodeCountY; j++) { pos.x = -mapWidth / 2.0f + i * squareSize + squareSize / 2.0f; pos.z = -mapHeight / 2.0f + j * squareSize + squareSize / 2.0f; controlNodes[i, j] = new ControlNode(pos, map[i, j] == 1, squareSize); } } Squares = new Square[nodeCountX - 1, nodeCountY - 1]; // There is one less square than there are nodes for (int i = 0; i < nodeCountX - 1; i++) { for (int j = 0; j < nodeCountY - 1; j++) { Squares[i, j] = new Square(controlNodes[i, j + 1], controlNodes[i + 1, j + 1], controlNodes[i + 1, j], controlNodes[i, j]); } } }
public Square(ControlNode _topLeft, ControlNode _topRight, ControlNode _bottomRight, ControlNode _bottomLeft) { topLeft = _topLeft; topRight = _topRight; bottomLeft = _bottomLeft; bottomRight = _bottomRight; midTop = topLeft.right; midRight = bottomRight.above; midBottom = bottomLeft.right; midLeft = bottomLeft.above; if (topLeft.active) { config += 8; } if (topRight.active) { config += 4; } if (bottomRight.active) { config += 2; } if (bottomLeft.active) { config += 1; } }
public SquareGrid(int[,] map) { int nodeCols = map.GetLength(1); int nodeRows = map.GetLength(0); float mapWidth = nodeCols * SQUARE_SIZE; float mapHeight = nodeRows * SQUARE_SIZE; ControlNode[,] controlNodes = new ControlNode[nodeRows, nodeCols]; for (int i = 0; i < nodeRows; i++) { for (int j = 0; j < nodeCols; j++) { Vector3 position = new Vector3(-mapWidth / 2 + j * SQUARE_SIZE + SQUARE_SIZE / 2, mapHeight / 2 - i * SQUARE_SIZE - SQUARE_SIZE / 2, MESH_Z); controlNodes[i, j] = new ControlNode(position, map[i, j] == 1); } } int rows = nodeRows - 1; int cols = nodeCols - 1; squares = new Square[rows, cols]; for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { squares[i, j] = new Square(controlNodes[i, j], controlNodes[i, j + 1], controlNodes[i + 1, j + 1], controlNodes[i + 1, j]); } } }
public Square(ControlNode _topLeft, ControlNode _topRight, ControlNode _bottomRight, ControlNode _bottomLeft) { topLeft = _topLeft; topRight = _topRight; bottomRight = _bottomRight; bottomLeft = _bottomLeft; centreTop = topLeft.right; centreRight = bottomRight.above; centreBottom = bottomLeft.right; centreLeft = bottomLeft.above; centre = new Node(new Vector3(centreTop.position.x, centreTop.position.y, centreRight.position.z)); if (topLeft.active) { configuration += 8; } if (topRight.active) { configuration += 4; } if (bottomRight.active) { configuration += 2; } if (bottomLeft.active) { configuration += 1; } }
public Square(ControlNode _tL, ControlNode _tR, ControlNode _bR, ControlNode _bL) { topLeft = _tL; topRight = _tR; bottomLeft = _bL; bottomRight = _bR; centerTop = topLeft.right; centerRight = bottomRight.above; centerLeft = bottomLeft.above; centerBottom = bottomLeft.right; if (topLeft.active) { configuration += 8; } if (topRight.active) { configuration += 4; } if (bottomRight.active) { configuration += 2; } if (bottomLeft.active) { configuration += 1; } }
public int Configuration; // one of the 16 possible states public Cell(ControlNode topLeft, ControlNode topRight, ControlNode bottomLeft, ControlNode bottomRight) { this.topLeft = topLeft; this.topRight = topRight; this.bottomLeft = bottomLeft; this.bottomRight = bottomRight; centerTop = topLeft.rightNode; centerRight = bottomRight.topNode; centerLeft = bottomLeft.topNode; centerDown = bottomLeft.rightNode; Configuration = 0; if (topLeft.isActive) { Configuration += 0x1000; } if (topRight.isActive) { Configuration += 0x0100; } if (bottomRight.isActive) { Configuration += 0x0010; } if (bottomLeft.isActive) { Configuration += 0x0001; } }
public int configuration; // 16 Ways to turn the nodes on/off // Constructor public Square(ControlNode _topLeft, ControlNode _topRight, ControlNode _bottomRight, ControlNode _bottomLeft) { topLeft = _topLeft; topRight = _topRight; bottomLeft = _bottomLeft; bottomRight = _bottomRight; centreTop = topLeft.right; centreRight = bottomRight.above; centreBottom = bottomLeft.right; centreLeft = bottomLeft.above; // Check to see if the nodes are active if (topLeft.active) { configuration += 8; // 1000 = 8 } if (topRight.active) { configuration += 4; // 0100 = 4 } if (bottomRight.active) { configuration += 2; // 0010 = 2 } if (bottomLeft.active) { configuration += 1; // 0001 = 1 } }
public SquareGrid(int[,] _map, float _squareSize) { int nodeCountX = _map.GetLength(0); int nodeCountY = _map.GetLength(1); float mapWidth = _squareSize * nodeCountX; float mapHeight = _squareSize * nodeCountY; 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); } } grid = new Square[nodeCountX - 1, nodeCountY - 1]; for (int x = 0; x < nodeCountX - 1; x++) { for (int y = 0; y < nodeCountY - 1; y++) { grid[x, y] = new Square(controlNodes[x, y + 1], controlNodes[x + 1, y + 1], controlNodes[x + 1, y], controlNodes[x, y]); } } }
public SquareGrid(TileType[,] 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] == TileType.Wall, 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]); if (x == 0 || y == 0 || x == nodeCountX - 2 || y == nodeCountY - 2) { squares[x, y].isBorder = true; } } } }
// Function to add the effect of an impact (position, force) to the mesh public void ImpactEffect(Vector3 position, Vector3 force) { // Get the nearest node from the impact and create a new node from it moving it of the force value divided by the impact attenuator parameter ControlNode node = GetNearestNode(position); ControlNode newNode = new ControlNode(node.position, true); newNode.position += force / impactAttenuator; // From the first index of the node in the vertices list, replace the node by the new node and try to find the node again (to replace it) // Exit the loop when the node is not in the vertices list anymore int index = vertices.IndexOf(node.position); while (index != -1) { vertices[index] = newNode.position; index = vertices.IndexOf(node.position); } // Replace the node by the new node in the ControlNodes list index = controlNodes.IndexOf(node); controlNodes[index] = newNode; // Update the vertices of the mesh (the triangles stay the same), recalculate Normals and update collider mesh as well objectMesh.mesh.vertices = vertices.ToArray(); objectMesh.mesh.RecalculateNormals(); objectMesh.GetComponent <MeshCollider>().sharedMesh = objectMesh.mesh; }
public Square(ControlNode _topLeft, ControlNode _topRight, ControlNode _bottomLeft, ControlNode _bottomRight) { topLeft = _topLeft; topRight = _topRight; bottomLeft = _bottomLeft; bottomRight = _bottomRight; centerTop = topLeft.right; centerRight = bottomRight.above; centerBottom = bottomLeft.right; centerLeft = bottomLeft.above; if (topLeft.active) { configIndex += 8; } if (topRight.active) { configIndex += 4; } if (bottomRight.active) { configIndex += 2; } if (bottomLeft.active) { configIndex += 1; } }
public Square(ControlNode _topLeft, ControlNode _topRight, ControlNode _bottomRight, ControlNode _bottomLeft) { topLeft = _topLeft; topRight = _topRight; bottomRight = _bottomRight; bottomLeft = _bottomLeft; //Move in Clocwise Direction centreTop = topLeft.right; centreRight = bottomRight.above; centreBottom = bottomLeft.right; centreLeft = bottomLeft.above; //Set up Configuration as to a Byte. if (topLeft.active) { config += 8; } if (topRight.active) { config += 4; } if (bottomRight.active) { config += 2; } if (bottomLeft.active) { config += 1; } }
public SquareGrid(int[,] map, float xspace, float yspace) { int nodeCountX = map.GetLength(0); int nodeCountY = map.GetLength(1); float mapWidth = nodeCountX * xspace; float mapHeight = nodeCountY * yspace; 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.0f + x * xspace + xspace / 2.0f, 0.0f, -mapHeight / 2.0f + y * yspace + yspace / 2.0f); controlNodes[x, y] = new ControlNode(pos, map[x, y] == 1, yspace, xspace); } } 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]); } } gateSquare = null; }
public Square (ControlNode _topLeft, ControlNode _topRight, ControlNode _bottomRight, ControlNode _bottomLeft) { topLeft = _topLeft; topRight = _topRight; bottomRight = _bottomRight; bottomLeft = _bottomLeft; centreTop = topLeft.right; centreRight = bottomRight.above; centreBottom = bottomLeft.right; centreLeft = bottomLeft.above; }
public ControlNode topLeft, topRight, bottomRight, bottomLeft; // Reference to all corners of the nodes #endregion Fields #region Constructors // Constructor public Square(ControlNode _topLeft, ControlNode _topRight, ControlNode _bottomRight, ControlNode _bottomLeft) { topLeft = _topLeft; topRight = _topRight; bottomLeft = _bottomLeft; bottomRight = _bottomRight; centreTop = topLeft.right; centreRight = bottomRight.above; centreBottom = bottomLeft.right; centreLeft = bottomLeft.above; // Check to see if the nodes are active if (topLeft.active) { configuration += 8; // 1000 = 8 } if (topRight.active) { configuration += 4; // 0100 = 4 } if (bottomRight.active) { configuration += 2; // 0010 = 2 } if (bottomLeft.active) { configuration += 1; // 0001 = 1 } }
public Square(ControlNode topLeft, ControlNode topRight, ControlNode bottomRight, ControlNode bottomLeft) { this.topLeft = topLeft; this.topRight = topRight; this.bottomRight = bottomRight; this.bottomLeft = bottomLeft; centreTop = topLeft.right; centreRight = bottomRight.above; centreLeft = bottomLeft.above; centreBottom = bottomLeft.right; if (topLeft.active) { configuration += 8; } if (topRight.active) { configuration += 4; } if (bottomRight.active) { configuration += 2; } if (bottomLeft.active) { configuration += 1; } }
public SquareGrid(int[,] map, float xspace, float yspace) { int nodeCountX = map.GetLength(0); int nodeCountY = map.GetLength (1); float mapWidth = nodeCountX * xspace; float mapHeight = nodeCountY * yspace; 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.0f + x * xspace + xspace/2.0f, 0.0f, -mapHeight/2.0f + y * yspace + yspace/2.0f); controlNodes[x,y] = new ControlNode(pos, map[x,y] == 1, yspace, xspace); } } 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]); } } gateSquare = null; }
private void _generateMesh(TerrainData data) { Vector3 startPosition = transform.position - new Vector3(m_data.Width, 0, m_data.Height) * m_boxSize * 0.5f; Vector3 step = new Vector3(m_boxSize, 0, m_boxSize); int width = data.Width; int height = data.Height; ControlNode[,] nodes = new ControlNode[width,height]; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { Vector3 offset = startPosition + new Vector3(step.x * x, 0.0f, step.z * y); nodes[x, y] = new ControlNode(offset, data.GetBlock(new Point(x, y)), m_boxSize); } } LinkedList<Square> squares = new LinkedList<Square>(); for (int y = 0; y < height - 1; y++) { for (int x = 0; x < width - 1; x++) { ControlNode bottomLeft = nodes[x, y]; ControlNode bottomRight = nodes[x + 1, y]; ControlNode topLeft = nodes[x, y + 1]; ControlNode topRight = nodes[x + 1, y + 1]; Square square = new Square(topLeft, topRight, bottomLeft, bottomRight); squares.AddLast(square); } } LinkedList<Vector3> verticies = new LinkedList<Vector3>(); LinkedList<int> indicies = new LinkedList<int>(); foreach (Square square in squares) { _buildSquare(square, verticies, indicies); } Mesh mesh = new Mesh(); GetComponent<MeshFilter>().mesh = mesh; mesh.vertices = verticies.ToArray(); mesh.triangles = indicies.ToArray(); mesh.RecalculateNormals(); }
public Square(ControlNode _topLeft, ControlNode _topRight, ControlNode _bottomRight, ControlNode _bottomLeft) { TopLeftNode = _topLeft; TopRightNode = _topRight; BottomRightNode = _bottomRight; BottomLeftNode = _bottomLeft; CenterTopNode = TopLeftNode.Right; CenterRightNode = BottomRightNode.Above; CenterBottomNode = BottomLeftNode.Right; CenterLeftNode = BottomLeftNode.Above; if (TopLeftNode.Active) { Configuration += 8; } if (TopRightNode.Active) { Configuration += 4; } if (BottomRightNode.Active) { Configuration += 2; } if (BottomLeftNode.Active) { Configuration += 1; } }
public Square(ControlNode topLeft, ControlNode topRight, ControlNode bottomRight, ControlNode bottomLeft) { this.topLeft = topLeft; this.topRight = topRight; this.bottomRight = bottomRight; this.bottomLeft = bottomLeft; centerTop = topLeft.right; centerRight = bottomRight.above; centerBottom = bottomLeft.right; centerLeft = bottomLeft.above; if (topLeft.active) configuration += 8; if (topRight.active) configuration += 4; if (bottomRight.active) configuration += 2; if (bottomLeft.active) configuration += 1; }
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++) { } } }
public int configuration; //16 possible configuaration of a square , control nodes public Square (ControlNode _topLeft, ControlNode _topRight, ControlNode _bottomRight, ControlNode _bottomLeft) { // constructor topLeft = _topLeft; topRight = _topRight; bottomRight = _bottomRight; bottomLeft = _bottomLeft; centreTop = topLeft.right; centreRight = bottomRight.above; centreBottom = bottomLeft.right; centreLeft = bottomLeft.above; //Nodes that are active generate number if (topLeft.active) configuration += 8; if (topRight.active) configuration += 4; if (bottomRight.active) configuration += 2; if (bottomLeft.active) configuration += 1; }
public Square[,] squares; //holds 2D arrays of squares public SquareGrid(int[,] map, float squareSize) { //constructor, gets map from mapGen int nodeCountX = map.GetLength(0); int nodeCountY = map.GetLength(1); float mapWidth = nodeCountX * squareSize; float mapHeight = nodeCountY * squareSize; ControlNode[,] controlNodes = new ControlNode[nodeCountX,nodeCountY]; //2D array of control nodes 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); //Calculate positions of control node controlNodes[x,y] = new ControlNode(pos,map[x,y] == 1, squareSize); // map is active if = 1 , // grid of control nodes } } squares = new Square[nodeCountX -1,nodeCountY -1]; //creation of grid of squares from control nodes 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] /*topleft*/ , controlNodes[x+1,y+1] /*topright*/ , controlNodes[x+1,y] /*bottomright*/ , controlNodes[x,y] /*bottomleft*/ ); //each square equal to new square with control node attributes from array } } }
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 p = new Vector3(-mapWidth / 2.0f + x * squareSize + squareSize / 2.0f, 0.0f, -mapHeight / 2.0f + y * squareSize + squareSize / 2.0f); controlNodes[x,y] = new ControlNode(p, map[x,y] != 0, 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]); } } }
public Square(ControlNode tl, ControlNode tr, ControlNode br, ControlNode bl) { topLeft = tl; topRight = tr; bottomRight = br; bottomLeft = bl; centerTop = topLeft.right; centerRight = bottomRight.above; centerBottom = bottomLeft.right; centerLeft = bottomLeft.above; if (topLeft.active) configuration |= 0x0008; if (topRight.active) configuration |= 0x0004; if (bottomRight.active) configuration |= 0x0002; if (bottomLeft.active) configuration |= 0x0001; }
public Carre (ControlNode _hautGauche, ControlNode _hautDroit, ControlNode _basDroit, ControlNode _basGauche) { hautGauche = _hautGauche; hautDroit = _hautDroit; basDroit = _basDroit; basGauche = _basGauche; centreHaut = hautGauche.droite; centreDroit = basDroit.dessus; centreBas = basGauche.droite; centreGauche = basGauche.dessus; /* Code binaire pour déterminer les configurations */ if (hautGauche.active) configuration += 8; if (hautDroit.active) configuration += 4; if (basDroit.active) configuration += 2; if (basGauche.active) configuration += 1; }
public SquareGrid(int[,] map, float squareSize) { int nodeCountX = map.GetLength(0); int nodeCountY = map.GetLength(1); ControlNode[,] controlNodes = new ControlNode[nodeCountX,nodeCountY]; for (int x = 0; x < nodeCountX; x ++) { for (int z = 0; z < nodeCountY; z ++) { Vector3 pos = new Vector3(x * squareSize + squareSize/2 -0.5f , terrainHeight, z * squareSize + squareSize/2 -0.5f); controlNodes[x,z] = new ControlNode(pos,map[x,z] == 1, squareSize); } } squares = new Square[nodeCountX -1,nodeCountY -1]; for (int x = 0; x < nodeCountX-1; x ++) { for (int z = 0; z < nodeCountY-1; z ++) { squares[x,z] = new Square(controlNodes[x,z+1], controlNodes[x+1,z+1], controlNodes[x+1,z], controlNodes[x,z]); } } }
public Square(ControlNode topLeft, ControlNode topRight, ControlNode bottomRight, ControlNode bottomLeft) { this.topLeft = topLeft; this.topRight = topRight; this.bottomLeft = bottomLeft; this.bottomRight = bottomRight; this.centreTop = topLeft.rightNode; this.centreRight = bottomRight.topNode; this.centreBottom = bottomLeft.rightNode; this.centreLeft = bottomLeft.topNode; configuration = 0; if (topLeft.active) configuration += 8; if (topRight.active) configuration += 4; if (bottomRight.active) configuration += 2; if (bottomLeft.active) configuration += 1; }
// Constructor public Square(ControlNode _topLeft, ControlNode _topRight, ControlNode _bottomRight, ControlNode _bottomLeft) { topLeft = _topLeft; topRight = _topRight; bottomRight = _bottomRight; bottomLeft = _bottomLeft; centerTop = topLeft.right; centerRight = bottomRight.above; centerBottom = bottomLeft.right; centerLeft = bottomLeft.above; if (topLeft.active) // 4th binary bit = 1000 = 8 (in base 10) configuration += 8; if (topRight.active) // 0100 = 4 configuration += 4; if (bottomRight.active) // 0010 = 2 configuration += 2; if (bottomLeft.active) // 0010 = 1 configuration += 1; }
// Constructor public SquareGrid(int[,] map, float squareSize) { // map provided by MapGenerator class 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], // topLeft controlNodes[x+1,y+1], // topRight controlNodes[x+1,y], // bottomRight controlNodes[x,y]); // bottomLeft } } }
//Defines a new square for marching squares, consisting of the control nodes and nodes public Square(ControlNode _topLeft, ControlNode _topRight, ControlNode _bottomRight, ControlNode _bottomLeft) { topLeft = _topLeft; topRight = _topRight; bottomRight = _bottomRight; bottomLeft = _bottomLeft; centerTop = topLeft.right; centerRight = bottomRight.above; centerBottom = bottomLeft.right; centerLeft = bottomLeft.above; if (topLeft.active) //First node, starting top left and then going clockwise configuration += 8; if (topRight.active) //Second node configuration += 4; if (bottomRight.active) //Third node configuration += 2; if (bottomLeft.active) //Fourth node configuration += 1; }
public Square(ControlNode topLeft, ControlNode topRight, ControlNode bottomLeft, ControlNode bottomRight) { m_topLeft = topLeft; m_topRight = topRight; m_bottomLeft = bottomLeft; m_bottomRight = bottomRight; }
public Grille(int[,] map, float tailleCarre) { int nbNodeX = map.GetLength(0); int nbNodeY = map.GetLength(1); float largeurMap = nbNodeX * tailleCarre; float hauteurMap = nbNodeY * tailleCarre; /* On met sur la grille l'ensemble des nodes de controles*/ ControlNode[,] controlNodes = new ControlNode[nbNodeX, nbNodeY]; for (int x = 0; x < nbNodeX; x ++) { for (int y = 0; y < nbNodeY; y ++) { Vector3 pos = new Vector3(-largeurMap/2 + x * tailleCarre + tailleCarre/2, 0, -hauteurMap/2 + y * tailleCarre + tailleCarre/2); controlNodes[x,y] = new ControlNode(pos,map[x,y] == 1, tailleCarre); } } /* Puis les carrés contenant les nodes simple */ carres = new Carre[nbNodeX -1,nbNodeY -1]; for (int x = 0; x < nbNodeX-1; x ++) { for (int y = 0; y < nbNodeY-1; y ++) { carres[x,y] = new Carre(controlNodes[x,y+1], controlNodes[x+1,y+1], controlNodes[x+1,y], controlNodes[x,y]); } } }
private void BuildControlNodes(float[,] map) { ControlNodes = new ControlNode[MapSize.x, MapSize.y]; for (int y = 0; y < MapSize.y; y++) { for (int x = 0; x < MapSize.x; x++) { Vector2i p = new Vector2i(x, y); ControlNodes[x, y] = new ControlNode( p, map, p.ToVector2() - WorldSize * 0.5f + Vector2.one * 0.5f, SquareSize); } } }
public void SetNext(ControlNode[] nodes) { nextNodes = nodes; }
public Cube( ControlNode _topLeftFront, ControlNode _topRightFront, ControlNode _bottomRightFront, ControlNode _bottomLeftFront, ControlNode _topLeftBack, ControlNode _topRightBack, ControlNode _bottomRightBack, ControlNode _bottomLeftBack) { topLeftFront = _topLeftFront; topRightFront = _topRightFront; bottomRightFront = _bottomRightFront; bottomLeftFront = _bottomLeftFront; topLeftBack = _topLeftBack; topRightBack = _topRightBack; bottomRightBack = _bottomRightBack; bottomLeftBack = _bottomLeftBack; centerTopFront = topRightFront.left; centerRightFront = bottomRightFront.above; centerBottomFront = bottomRightFront.left; centerLeftFront = bottomLeftFront.above; topLeftCenter = topLeftBack.front; topRightCenter = topRightBack.front; bottomRightCenter = bottomRightBack.front; bottomLeftCenter = bottomLeftBack.front; centerTopBack = topRightBack.left; centerRightBack = bottomRightBack.above; centerBottomBack = bottomRightBack.left; centerLeftBack = bottomLeftBack.above; if (topLeftFront.active) configuration += 1; if (topLeftBack.active) configuration += 2; if (topRightFront.active) configuration += 4; if (topRightBack.active) configuration += 8; if (bottomRightFront.active) configuration += 16; if (bottomRightBack.active) configuration += 32; if (bottomLeftFront.active) configuration += 64; if (bottomLeftBack.active) configuration += 128; }
public Square( ControlNode _topLeft, ControlNode _topRight, ControlNode _bottomRight, ControlNode _bottomLeft ) { topLeft = _topLeft; topRight = _topRight; bottomRight = _bottomRight; bottomLeft = _bottomLeft; centreTop = topLeft.right; centreRight = bottomRight.above; centreBottom = bottomLeft.right; centreLeft = bottomLeft.above; //Lesson 3 if( topLeft.active ) configuration += 8; if( topRight.active ) configuration += 4; if( bottomLeft.active ) configuration += 1; if( bottomRight.active ) configuration += 2; }
public void rotateRightHoriz() { ControlNode tempTLF = topLeftFront, tempBLF = bottomLeftFront; Node tempCLF = centerLeftFront, tempTLC = topLeftCenter, tempBLC = bottomLeftCenter; topLeftFront = topRightFront; centerLeftFront = centerRightFront; bottomLeftFront = bottomRightFront; topLeftCenter = centerTopFront; bottomLeftCenter = centerBottomFront; topRightFront = topRightBack; centerRightFront = centerRightBack; bottomRightFront = bottomRightBack; centerTopFront = topRightCenter; centerBottomFront = bottomRightCenter; topRightBack = topLeftBack; centerRightBack = centerLeftBack; bottomRightBack = bottomLeftBack; topRightCenter = centerTopBack; bottomRightCenter = centerBottomBack; topLeftBack = tempTLF; centerLeftBack = tempCLF; bottomLeftBack = tempBLF; centerTopBack = tempTLC; centerBottomBack = tempBLC; }
public Square( ControlNode bottomLeft, ControlNode topLeft, ControlNode topRight, ControlNode bottomRight) { SquareCenter = (bottomLeft.Position + topRight.Position) * 0.5f; BottomLeft = bottomLeft; TopLeft = topLeft; TopRight = topRight; BottomRight = bottomRight; CenterLeft = BottomLeft.Up; CenterRight = BottomRight.Up; CenterTop = TopLeft.Right; CenterBottom = BottomLeft.Right; }
public void rotateRightVert() { ControlNode tempBLF = bottomLeftFront, tempBLB = bottomLeftBack; Node tempBLC = bottomLeftCenter, tempCLF = centerLeftFront, tempCLB = centerLeftBack; bottomLeftFront = bottomRightFront; bottomLeftCenter = bottomRightCenter; bottomLeftBack = bottomRightBack; centerLeftFront = centerBottomFront; centerLeftBack = centerBottomBack; bottomRightFront = topRightFront; bottomRightCenter = topRightCenter; bottomRightBack = topRightBack; centerBottomFront = centerRightFront; centerBottomBack = centerRightBack; topRightFront = topLeftFront; topRightCenter = topLeftCenter; topRightBack = topLeftBack; centerRightFront = centerTopFront; centerRightBack = centerTopBack; topLeftFront = tempBLF; topLeftCenter = tempBLC; topLeftBack = tempBLB; centerTopFront = tempCLF; centerTopBack = tempCLB; }
public Square (ControlNode _topLeft, ControlNode _topRight, ControlNode _bottomRight, ControlNode _bottomLeft){ topLeft = _topLeft; topRight = _topRight; bottomRight = _bottomRight; bottomLeft = _bottomLeft; centerTop = topLeft.right; centerRight = bottomRight.above; centerBottom = bottomLeft.right; centerLeft = bottomLeft.above; if(topLeft.active) config += 8; if(topRight.active) config += 4; if(bottomRight.active) config += 2; if(bottomLeft.active) config +=1; }
public SquareGrid(int[,,] map, float squareSize) { int nodeCountX = map.GetLength(0); int nodeCountY = map.GetLength(1); int nodeCountZ = map.GetLength(2); float mapWidth = nodeCountX * squareSize; float mapHeight = nodeCountY * squareSize; float mapDepth = nodeCountZ * squareSize; ControlNode[,,] controlNodes = new ControlNode[nodeCountX, nodeCountY, nodeCountZ]; for (int x = 0; x < nodeCountX; x++) { for (int y = 0; y < nodeCountY; y++) { for (int z = 0; z < nodeCountZ; z++) { Vector3 pos = new Vector3(-mapWidth / 2 + x * squareSize + squareSize / 2, -mapDepth / 2 + z * squareSize + squareSize / 2, -mapHeight / 2 + y * squareSize + squareSize / 2); controlNodes[x, y, z] = new ControlNode(pos, map[x, y, z] == 1, squareSize); } } } cubes = new Cube[nodeCountX - 1, nodeCountY - 1, nodeCountZ - 1]; for (int x = 0; x < nodeCountX - 1; x++) { for (int y = 0; y < nodeCountY - 1; y++) { for (int z = 0; z < nodeCountZ - 1; z++) { cubes[x, y, z] = new Cube( controlNodes[x , y+1, z+1], controlNodes[x+1, y+1, z+1], controlNodes[x+1, y , z+1], controlNodes[x , y , z+1], controlNodes[x , y+1, z ], controlNodes[x+1, y+1, z ], controlNodes[x+1, y , z ], controlNodes[x , y , z ]); } } } }