// ---------------------------------------------------------------------------------------------
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]);
}
}
}
}
}
