// --------------------------------------------------------------------------------------------- private void removePathElement(int x, int y, int z) { int i, len = _aPath.Count; for (i = 0; i < len; ++i) { // remove element if it already exists if (_aPath [i].x == x && _aPath [i].y == y && _aPath [i].z == z) { _aPath.RemoveAt(i); GridCube gc = _aGridCubes [x, y, z]; gc.isPath = false; if (gc.go != null) { Destroy(gc.go); gc.go = null; } _aGridCubes [x, y, z] = gc; len--; break; } } }
// Grid cube to center and verts in buffer for GPU private void instantiateGridCubes() { GridVerts = new Vector3[XCubes + 1, YCubes + 1, ZCubes + 1]; Cubes = new GridCube[XCubes * YCubes * ZCubes]; for (int x = 0; x < XCubes; x++) { for (int y = 0; y < YCubes; y++) { for (int z = 0; z < ZCubes; z++) { Vector3 centerPoint = cubeMap[x, y, z]; Cubes[x + XCubes * (y + YCubes * z)].CenterPos = centerPoint; Cubes[x + XCubes * (y + YCubes * z)].V0 = centerPoint + vertMap[0]; Cubes[x + XCubes * (y + YCubes * z)].V1 = centerPoint + vertMap[1]; Cubes[x + XCubes * (y + YCubes * z)].V2 = centerPoint + vertMap[2]; Cubes[x + XCubes * (y + YCubes * z)].V3 = centerPoint + vertMap[3]; Cubes[x + XCubes * (y + YCubes * z)].V4 = centerPoint + vertMap[4]; Cubes[x + XCubes * (y + YCubes * z)].V5 = centerPoint + vertMap[5]; Cubes[x + XCubes * (y + YCubes * z)].V6 = centerPoint + vertMap[6]; Cubes[x + XCubes * (y + YCubes * z)].V7 = centerPoint + vertMap[7]; GridVerts[x, y, z] = centerPoint + vertMap[0]; GridVerts[x + 1, y, z] = centerPoint + vertMap[1]; GridVerts[x + 1, y + 1, z] = centerPoint + vertMap[2]; GridVerts[x, y + 1, z] = centerPoint + vertMap[3]; GridVerts[x, y, z + 1] = centerPoint + vertMap[4]; GridVerts[x + 1, y, z + 1] = centerPoint + vertMap[5]; GridVerts[x + 1, y + 1, z + 1] = centerPoint + vertMap[6]; GridVerts[x, y + 1, z + 1] = centerPoint + vertMap[7]; } } } }
/// <summary> /// Checks if you need multiple of the same colour before you can mix. /// </summary> /// <param name="gridCube">Grid cube.</param> /// <returns>True if the colour can be added to the mixer, False otherwise.</returns> private bool CheckForPreMix(GridCube gridCube) { bool addToMixer = true; if (gridCube.MoreToMix) { if (Mixer.PreMixer.ContainsKey(gridCube.ColourName)) { int mixerAmount = Mixer.PreMixer[gridCube.ColourName]; mixerAmount -= 1; if (mixerAmount <= 0) { Mixer.PreMixer.Remove(gridCube.ColourName); addToMixer = true; } else { Mixer.PreMixer[gridCube.ColourName] = mixerAmount; addToMixer = false; } } else { Mixer.PreMixer.Add(gridCube.ColourName, gridCube.AmountToMix - 1); addToMixer = false; } } return addToMixer; }
// --------------------------------------------------------------------------------------------- private void setMaterial(GridCube gc) { if (gc.go != null) { Renderer r = gc.go.GetComponent <Renderer> (); if (r != null) { r.sharedMaterial = (gc.isSet ? matOpaque : (gc.isPath ? matPath : matTransparent)); } } }
private static void CheckVertexes(GridCube cube, double start, double end) { Assert.AreEqual(cube.Vertex[0], new CommonTypes.Point(start, start, start)); Assert.AreEqual(cube.Vertex[1], new CommonTypes.Point(end, start, start)); Assert.AreEqual(cube.Vertex[2], new CommonTypes.Point(end, start, end)); Assert.AreEqual(cube.Vertex[3], new CommonTypes.Point(start, start, end)); Assert.AreEqual(cube.Vertex[4], new CommonTypes.Point(start, end, start)); Assert.AreEqual(cube.Vertex[5], new CommonTypes.Point(end, end, start)); Assert.AreEqual(cube.Vertex[6], new CommonTypes.Point(end, end, end)); Assert.AreEqual(cube.Vertex[7], new CommonTypes.Point(start, end, end)); }
public void Start() { spawnedTargets = new List <Vector3>(); var xMin = -(TileCountX / 2); var xMax = TileCountX / 2; var zMin = -(TileCountZ / 2); var zMax = TileCountZ / 2; for (var x = xMin; x < xMax; x++) { for (var z = zMin; z < zMax; z++) { var tile = Instantiate(TilePrefab); tile.transform.position = new Vector3(x, 0, z); GridCube cube = tile.GetComponent <GridCube>(); cube.isBlue = x > 0; } } var tryCount = 0; for (var i = 0; i < TargetCount; i++) { var targetX = Random.Range(0 + TargetDistanceFromSides, xMax - TargetDistanceFromSides); var targetZ = Random.Range(zMin + TargetDistanceFromSides, zMax - TargetDistanceFromSides); if (spawnedTargets.Any()) { while (spawnedTargets.FirstOrDefault(t => t.x < targetX + TargetMinSpreadDistance && t.x > targetX - TargetMinSpreadDistance || t.z < targetZ + TargetMinSpreadDistance && t.z > targetZ - TargetMinSpreadDistance) != Vector3.zero) { targetX = Random.Range(0 + TargetDistanceFromSides, xMax - TargetDistanceFromSides); targetZ = Random.Range(zMin + TargetDistanceFromSides, zMax - TargetDistanceFromSides); tryCount++; if (tryCount > 50) { break; } } } var blueTargetPos = new Vector3(targetX, 2, targetZ); var redTargetPos = new Vector3(-targetX, 2, targetZ); spawnedTargets.Add(blueTargetPos); spawnedTargets.Add(redTargetPos); var target = Instantiate(BlueTargetPrefab, blueTargetPos, Quaternion.identity); var targetRed = Instantiate(RedTargetPrefab, redTargetPos, Quaternion.identity); target.GetComponent <Target>().TeamBlue = true; targetRed.GetComponent <Target>().TeamBlue = false; } }
//Spawning gridCubes class, shortcut method, maybe for future purposes, or additional //methods etc... public static GridCube[,] ReturnGridCubes(float[,] noise) { GridCube[,] gridCubes = new GridCube[noise.GetLength(0), noise.GetLength(1)]; for (int x = 0; x < noise.GetLength(0); x++) { for (int y = 0; y < noise.GetLength(1); y++) { GridCube gridCube = new GridCube(x, y); gridCubes[x, y] = gridCube; } } return(gridCubes); }
// private void setPathElement(int x, int y, int z) { if (x == (int)_v3StartPos.x && y == (int)_v3StartPos.y && z == (int)_v3StartPos.z) { return; } _aPath.Add(new Vector3Int(x, y, z)); GridCube gc = _aGridCubes [x, y, z]; gc.isPath = true; _aGridCubes [x, y, z] = gc; createCubeGameObject(x, y, z); setMaterial(_aGridCubes [x, y, z]); }
private void PlaceNewObject(GridCube.CubeState state) { bool done = false; while (!done) { GridCube cube = cubes.ElementAt(Random.Range(0, cubes.Count)); if (!cube.isEmpty() || (cube.SameSideAs(SnakeHead()) && rotationEnabled)) { continue; } cube.SetCubeState(state); done = true; } }
//public Vector3 resolution = new Vector3(10f, 10f, 10f); // Use this for initialization void Start() { numCubes = xResolution * yResolution * zResolution; Instantiate(gridCubePrefab, new Vector3(0, 0, 0), Quaternion.identity); //for (int x = 0; x < (int) resolution.x; x++) //{ // for (int y = 0; x < (int) resolution.y; y++) // { // for (int z = 0; x < (int) resolution.z; z++) // { // Instantiate(gridCubePrefab, new Vector3(x, y, z), Quaternion.identity); // } // } //} for (int x = -xResolution; x < xResolution; x++) { float xPos = ((float)x / xResolution); for (int y = -yResolution; y < yResolution; y++) { float yPos = ((float)y / yResolution); for (int z = -zResolution; z < zResolution; z++) { float zPos = ((float)z / zResolution); GridCube temp = (GridCube)Instantiate(gridCubePrefab, new Vector3(xPos, yPos, zPos), Quaternion.identity); temp.transform.localScale = new Vector3(1f / (float)xResolution, 1f / (float)yResolution, 1f / (float)zResolution); temp.cubeColor = new Color(1f, 1f, 1f, Random.Range(0f, 1f)); temp.xPos = x; temp.yPos = y; temp.zPos = z; //temp.alpha = Random.Range(0f, 1f); //temp.alpha = Vector3.Distance(new Vector3(0, 0, 0), new Vector3(xPos, yPos, zPos)); float r = Vector3.Distance(new Vector3(0, 0, 0), new Vector3(xPos, yPos, zPos)); float a = 0.5f; //temp.alpha = 1-r; //temp.alpha = 2 * Mathf.Pow(a, -3f / 2f) * Mathf.Exp(-r / a); temp.alpha = Mathf.Abs(1 / Mathf.Sqrt(2) * Mathf.Pow(a, -3f / 2f) * (1 - 0.5f * r / a) * Mathf.Exp(-r / 2 * a)); //gridCubes.Add(temp); } } } }
// --------------------------------------------------------------------------------------------- private void setMaterial(GridCube gc) { if (gc.go != null) { Renderer r = gc.go.GetComponent <Renderer> (); if (r != null) { r.sharedMaterial = (gc.isSet ? matOpaque : matTransparent); /*if (gc.x == (int)_v3StartPos.x && gc.y == (int)_v3StartPos.y && gc.z == (int)_v3StartPos.z) { * r.sharedMaterial = matStart; * } else { * r.sharedMaterial = (gc.isSet ? matOpaque : matTransparent); * }*/ } } }
public MoveResult MoveHead(GridCube.Direction direction) { if (isRotating) { return(MoveResult.ROTATING); } GridCube next = SnakeHead().GetNextCube(direction, out var changedSide); if (next == null) { next = FindSnakeBound(SnakeHead()); changedSide = false; if (next == null) { return(MoveResult.ERROR); } } if (next.IsSnake() || next.IsHole()) { return(MoveResult.DIED); } if (changedSide) { bool ok = StartRotation(direction); return(ok ? MoveResult.ROTATING : MoveResult.ERROR); } bool ateApple = next.IsApple(); next.SetCubeState(GridCube.CubeState.SNAKE); snake.AddFirst(next); GridCube last = snake.Last.Value; if (!ateApple) { last.SetCubeState(GridCube.CubeState.EMPTY); snake.RemoveLast(); return(MoveResult.MOVED); } return(MoveResult.ATE); }
// --------------------------------------------------------------------------------------------- private void createCubeGameObject(int x, int y, int z) { if (_aGridCubes [x, y, z].go != null) { return; } float half = (float)gridDimension * 0.5f; GridCube gc = _aGridCubes [x, y, z]; gc.go = Instantiate(prefabCube); gc.go.name = "x" + x.ToString() + "-" + "y" + y.ToString() + "-" + "z" + z.ToString(); gc.go.transform.SetParent(gridContainer.transform); gc.go.transform.localScale = new Vector3(cubeScale, cubeScale, cubeScale); gc.go.transform.localPosition = new Vector3(-half + x * cubeScale, -half + y * cubeScale, -half + z * cubeScale); gc.go.transform.localRotation = Quaternion.identity; _aGridCubes [x, y, z] = gc; }
public GridCube GetNextCube(Direction dir, out bool changedSide) { changedSide = false; Vector3 direction; switch (dir) { case Direction.UP: direction = new Vector3(0, 1, 0); break; case Direction.DOWN: direction = new Vector3(0, -1, 0); break; case Direction.LEFT: direction = new Vector3(-1, 0, 0); break; case Direction.RIGHT: direction = new Vector3(1, 0, 0); break; default: return(null); } GridCube neighbour = GetNeighbourAt(direction); if (neighbour == null) { // Get neighbour on the other side of the cube (back) changedSide = true; return(GetNeighbourAt(new Vector3(0, 0, 1))); } return(neighbour); }
private GridCube FindSnakeBound(GridCube snake) { //Left side if (snake.Line == 0) { return(cubes.Find(c => c.Column == snake.Column && c.Line == gridSize - 1)); } if (snake.Column == 0) { return(cubes.Find(c => c.Line == snake.Line && c.Column == gridSize - 1)); } //Right side if (snake.Line == gridSize - 1) { return(cubes.Find(c => c.Column == snake.Column && c.Line == 0)); } if (snake.Column == gridSize - 1) { return(cubes.Find(c => c.Line == snake.Line && c.Column == 0)); } return(null); }
// --------------------------------------------------------------------------------------------- private void createCubeGrid() { // center gridCubes container float half = (float)gridDimension * 0.5f; //gridContainer.transform.position = new Vector3 (-half, -half, -half); // create grid of cubes int endCorner = _numCubesPerAxis - 1; int x, y, z; for (x = 0; x < _numCubesPerAxis; ++x) { for (y = 0; y < _numCubesPerAxis; ++y) { for (z = 0; z < _numCubesPerAxis; ++z) { GridCube gc = new GridCube(); gc.go = Instantiate(prefabCube); gc.go.name = "x" + x.ToString() + "-" + "y" + y.ToString() + "-" + "z" + z.ToString(); gc.go.transform.SetParent(gridContainer); gc.go.transform.localScale = new Vector3(cubeScale, cubeScale, cubeScale); gc.go.transform.localPosition = new Vector3(-half + x * cubeScale, -half + y * cubeScale, -half + z * cubeScale); gc.x = x; gc.y = y; gc.z = z; if (x == (int)_v3StartPos.x && y == (int)_v3StartPos.y && z == (int)_v3StartPos.z) { gc.isSet = true; } else { gc.isSet = false; } gc.isCorner = false; if (x == 0 || x == endCorner) { if (y == 0 && z == 0) // bottom left front { gc.isCorner = true; } else if (y == endCorner && z == 0) // top left front { gc.isCorner = true; } else if (y == 0 && z == endCorner) // bottom left back { gc.isCorner = true; } else if (y == endCorner && z == endCorner) // top left back { gc.isCorner = true; } } _aGridCubes [x, y, z] = gc; setMaterial(gc); } } } }
public void SetupGrid(bool enableRotation, int appleCount) { if (cubes != null) { foreach (GridCube c in cubes) { Destroy(c.gameObject); } } snake = new LinkedList <GridCube>(); cubes = new List <GridCube>(); isRotating = false; rotationEnabled = enableRotation; if (gridSize % 2 == 0) { gridSize++; } gridSize = Mathf.Max(gridSize, 5); float finalGridSize = GetGridSizeWorld(); float halfGridSize = finalGridSize / 2; int zDepth = rotationEnabled ? gridSize : 1; for (int i = 0; i < gridSize; i++) { for (int j = 0; j < gridSize; j++) { for (int k = 0; k < zDepth; k++) { // Dont add cubes at center of 3d grid if ((k != 0 && k != gridSize - 1) && (j != 0 && j != gridSize - 1) && (i != 0 && i != gridSize - 1)) { continue; } GameObject cubeGameObject = Instantiate(gridCubeClone); cubeGameObject.transform.SetParent(transform); Vector3 size = cubeGameObject.transform.localScale; float offset = halfGridSize - size.x / 2; cubeGameObject.transform.Translate(i * size.x - offset, j * size.x - offset, k * size.x - offset); int centerPos = (int)halfGridSize; GridCube cube = cubeGameObject.GetComponent <GridCube>(); if (i == centerPos && j == centerPos && k == 0) { // Set up starting cell cube.SetCubeState(GridCube.CubeState.SNAKE); snake.AddFirst(cube); } else { cube.SetCubeState(GridCube.CubeState.EMPTY); } if (i == 0) { cube.AddCubeSide(GridCube.CubeSide.LEFT); } else if (i == gridSize - 1) { cube.AddCubeSide(GridCube.CubeSide.RIGHT); } if (j == 0) { cube.AddCubeSide(GridCube.CubeSide.BOTTOM); } else if (j == gridSize - 1) { cube.AddCubeSide(GridCube.CubeSide.TOP); } if (k == 0) { cube.AddCubeSide(GridCube.CubeSide.FRONT); } else if (k == gridSize - 1) { cube.AddCubeSide(GridCube.CubeSide.BACK); } cubes.Add(cube); } } } for (int i = 0; i < appleCount; i++) { PlaceNewApple(); } }
// --------------------------------------------------------------------------------------------- private void movePos(int x, int y, int z) { Vector3Int v3LastPos = new Vector3Int((int)_v3CurPos.x, (int)_v3CurPos.y, (int)_v3CurPos.z); GridCube gcLast = _aGridCubes [v3LastPos.x, v3LastPos.y, v3LastPos.z]; bool moved = false; int newPos; if (x != 0) { newPos = (int)_v3CurPos.x + x; if (newPos > 0 && newPos < (_numCubesPerAxis - 1)) { _v3CurPos.x = newPos; moved = true; } } else if (y != 0) { newPos = (int)_v3CurPos.y + y; if (newPos > 0 && newPos < (_numCubesPerAxis - 1)) { _v3CurPos.y = newPos; moved = true; } } else if (z != 0) { newPos = (int)_v3CurPos.z + z; if (newPos > 0 && newPos < (_numCubesPerAxis - 1)) { _v3CurPos.z = newPos; moved = true; } } if (moved) { setPlayerPos(); // did we turn around? Vector3Int v3NewPos = new Vector3Int((int)_v3CurPos.x, (int)_v3CurPos.y, (int)_v3CurPos.z); GridCube gcNew = _aGridCubes [v3NewPos.x, v3NewPos.y, v3NewPos.z]; if (gcLast.prevCell.x == v3NewPos.x && gcLast.prevCell.y == v3NewPos.y && gcLast.prevCell.z == v3NewPos.z) { gcLast.prevCell = new Vector3Int(-1, -1, -1); _aGridCubes [v3LastPos.x, v3LastPos.y, v3LastPos.z] = gcLast; //Debug.Log ("remove"); removePathElement(v3LastPos.x, v3LastPos.y, v3LastPos.z); } else if (gcNew.prevCell.x == -1 && gcNew.prevCell.y == -1 && gcNew.prevCell.z == -1) { if (_v3StartPos.x != _v3CurPos.x || _v3StartPos.y != _v3CurPos.y || _v3StartPos.z != _v3CurPos.z) { gcNew.prevCell = v3LastPos; _aGridCubes [v3NewPos.x, v3NewPos.y, v3NewPos.z] = gcNew; //Debug.Log ("add"); setPathElement(v3NewPos.x, v3NewPos.y, v3NewPos.z); } } setContainersAndUI(); } }
public bool SameSideAs(GridCube other) { return((other.cubeSide & cubeSide) != 0); }
// --------------------------------------------------------------------------------------------- private void createCubeGrid() { //float half = (float)gridDimension * 0.5f; // create grid of cubes int endCorner = _numCubesPerAxis - 1; int x, y, z; for (x = 0; x < _numCubesPerAxis; ++x) { for (y = 0; y < _numCubesPerAxis; ++y) { for (z = 0; z < _numCubesPerAxis; ++z) { GridCube gc = new GridCube(); gc.x = x; gc.y = y; gc.z = z; gc.prevCell = new Vector3Int(-1, -1, -1); if (x == (int)_v3CurPos.x && y == (int)_v3CurPos.y && z == (int)_v3CurPos.z) { gc.isSet = true; } else { gc.isSet = false; } gc.isPath = false; gc.isCorner = false; if (x == 0 || x == endCorner) { if (y == 0 && z == 0) // bottom left front { gc.isCorner = true; } else if (y == endCorner && z == 0) // top left front { gc.isCorner = true; } else if (y == 0 && z == endCorner) // bottom left back { gc.isCorner = true; } else if (y == endCorner && z == endCorner) // top left back { gc.isCorner = true; } } _aGridCubes [x, y, z] = gc; if (gc.isCorner || gc.isSet) { createCubeGameObject(x, y, z); setMaterial(_aGridCubes [x, y, z]); } } } } }