// Methods to handle parking spots
protected void InitParkingSpots()
{
int index = 0;
for (int i = 0; i < parkingSpots.GetLength(0); i++)
{
for (int j = 0; j < parkingSpots.GetLength(1); j++)
{
for (int k = 0; k < parkingSpots.GetLength(2); k++)
{
index++;
var tmp = context.Vehicles.FirstOrDefault(v => v.VehicleParkingSpot == index);
if (tmp != null)
{
for (int l = 0; l < tmp.VehicleSize; l++)
{
parkingSpots[i, j, k + l] = true;
}
}
}
}
}
}
private static bool IsOnWall(bool[, ,] cuboid, int[] cube, out int newDimension)
{
for (int dimension = 0; dimension < 3; dimension++)
{
if (isMinOrMax(cube[dimension], cuboid.GetLength(dimension) - 1))
{
newDimension = dimension;
return(true);
}
}
newDimension = -1;
return(false);
}
public double GetValue(double x, double y, double z)
{
if (Voxels != null)
{
try
{
if (IsInBounds((int)x, (int)y, (int)z))
{
return(Voxels[(int)x, (int)z, (int)z] ? 1 : 0);
}
else
{
return(0);
}
}
catch (Exception e)
{
SafeDebug.LogError(string.Format("Message: {0}, \nfunction: GetValue, \nStacktrace: {1}, \nValues: x={2}/{3}, z={4}/{5}.",
e.Message, e.StackTrace, x, Voxels.GetLength(0), z, Voxels.GetLength(1)), e);
}
}
return(0);
}
public void SetImagePath(string filepath)
{
if (ImagePath != filepath)
{
try
{
Bitmap image = new Bitmap("Assets/Textures/Tilesets/" + filepath);
ImagePath = filepath;
bool[,,] oldPasabilites = Pasabilities;
int[,] oldPriorities = Priorities;
int[,] oldTerrainTags = TerrainTags;
bool[,] oldBushFlags = BushFlags;
bool[,] oldCounterFlags = CounterFlags;
bool[,] oldReflectionFlags = ReflectionFlags;
bool[,] oldBridgeFlags = BridgeFlags;
Pasabilities = new bool[8, (image.Height / 32) + 1, 8];
Priorities = new int[8, (image.Height / 32) + 1];
TerrainTags = new int[8, (image.Height / 32) + 1];
BushFlags = new bool[8, (image.Height / 32) + 1];
CounterFlags = new bool[8, (image.Height / 32) + 1];
ReflectionFlags = new bool[8, (image.Height / 32) + 1];
BridgeFlags = new bool[8, (image.Height / 32) + 1];
for (int x = 0; x < Pasabilities.GetLength(0); x++)
{
for (int y = 0; y < Pasabilities.GetLength(1); y++)
{
if (y < oldPasabilites.GetLength(1))
{
for (int dir = 0; dir < 8; dir++)
{
Pasabilities[x, y, dir] = oldPasabilites[x, y, dir];
}
Priorities[x, y] = oldPriorities[x, y];
TerrainTags[x, y] = oldTerrainTags[x, y];
BushFlags[x, y] = oldBushFlags[x, y];
CounterFlags[x, y] = oldCounterFlags[x, y];
ReflectionFlags[x, y] = oldReflectionFlags[x, y];
BridgeFlags[x, y] = oldBridgeFlags[x, y];
}
}
}
image.Dispose();
}
catch { }
}
}
public static int Misplaced(bool[, ,] initial, bool[, ,] target)
{
int misplaced = 0;
for (int i = 0; i < initial.GetLength(0); ++i)
{
for (int j = 0; j < initial.GetLength(1); ++j)
{
for (int k = 0; k < initial.GetLength(2); ++k)
{
// If it's a block, check if there is no block in target
if (!initial [i, j, k])
{
if (target [i, j, k])
{
++misplaced;
}
}
}
}
}
return(misplaced);
}
private static bool IsOnEdge(bool[,,] cuboid, int[] cube)
{
int count = 0;
for (int dimension = 0; dimension < 3; dimension++)
{
if (isMinOrMax(cube[dimension], cuboid.GetLength(dimension) - 1))
{
count++;
}
}
return(count > 1 ? true : false);
}
public Simulation(int resx, int resy, int resz, float hbar, float[,,] px, float[,,] py, float[,,] pz)
{
_px = px;
_py = py;
_pz = pz;
isJet = new bool[resx, resy, resz];
kvec = new float[] { JetVelocity[0] / hbar, JetVelocity[1] / hbar, JetVelocity[2] / hbar };
omega = (JetVelocity[0] * JetVelocity[0] + JetVelocity[1] * JetVelocity[1] + JetVelocity[2] * JetVelocity[2]) / (2 * hbar);
for (int i = 0; i < isJet.GetLength(0); i++)
{
for (int j = 0; j < isJet.GetLength(1); j++)
{
for (int k = 0; k < isJet.GetLength(2); k++)
{
isJet[i, j, k] = (Math.Abs(px[i, j, k] - nozzle_cen[0]) <= nozzle_len / 2) &&
((Math.Pow(py[i, j, k] - nozzle_cen[1], 2) + (pz[i, j, k] - nozzle_cen[2]) * (pz[i, j, k] - nozzle_cen[2])) <= nozzle_rad * nozzle_rad);
}
}
}
}
List <Matrix4x4> GeneratePositionMatricies(bool[,,] field)
{
List <Matrix4x4> outputList = new List <Matrix4x4>();
for (int iX = 0; iX < field.GetLength(0); iX++)
{
for (int iY = 0; iY < field.GetLength(1); iY++)
{
for (int iZ = 0; iZ < field.GetLength(2); iZ++)
{
if (fieldWeight[iX, iY, iZ])
{
float posX = objectSize.x * iX + objectSize.x / 2;
float posY = objectSize.y * iY + objectSize.y / 2;
float posZ = objectSize.z * iZ + objectSize.z / 2;
Vector3 localPosition = new Vector3(posX, posY, posZ);
Vector3 rotatedLocalPosition = gameObject.transform.rotation * localPosition;
Vector3 position = gameObject.transform.position + rotatedLocalPosition;
Quaternion rotation = gameObject.transform.rotation;
Vector3 scale = gameObject.transform.localScale;
Matrix4x4 objectTRS = Matrix4x4.TRS(position, rotation, scale);
outputList.Add(objectTRS);
}
}
}
}
return(outputList);
}
private GameObject[] makeObject(bool[,,] f, GameObject parentObj, GameObject blockPrefab, int targetArea)
{
Vector3 sc = parentObj.transform.localScale;
int sx = f.GetLength(0), sy = f.GetLength(1), sz = f.GetLength(2);
Vector3 scDiv = sc;
scDiv.x /= (float)sx * 2f;
scDiv.y /= (float)sy * 2f;
scDiv.z /= (float)sz * 2f;
Vector3 p0 = parentObj.transform.position;
Vector3 pSc = parentObj.transform.localScale;
GameObject[] Obj = new GameObject[sx * sy * sz];
int counter = 0;
for (int i = 0; i < sx; i++)
{
for (int j = 0; j < sy; j++)
{
for (int k = 0; k < sz; k++)
{
if (f[i, j, k])
{
objBlocks[targetArea, counter].SetActive(true);
}
else
{
objBlocks[targetArea, counter].SetActive(false);
}
counter++;
}
}
}
return(Obj);
}
public LocalDataset(double[] freq, double[,,] uvw, bool[,,] flags, Complex[,,] vis)
{
Frequencies = freq;
UVW = uvw;
Flags = flags;
Visibilities = vis;
var visCountLocal = 0;
for (int i = 0; i < flags.GetLength(0); i++)
{
for (int j = 0; j < flags.GetLength(1); j++)
{
for (int k = 0; k < flags.GetLength(2); k++)
{
if (!flags[i, j, k])
{
visCountLocal++;
}
}
}
}
VisibilitiesCount = visCountLocal;
}
public bool IsValidVoxel(bool[,,] bools, int x, int y, int z, bool keepInside = true)
{
if (keepInside && bools[x, y, z])
{
return(true);
}
// If the current voxel is false, return false
if (!bools[x, y, z])
{
return(false);
}
// If it's on the "border", return true
if (x == 0 || y == 0 || z == 0 || x == (bools.GetLength(0) - 1) || y == (bools.GetLength(1) - 1) || z == (bools.GetLength(2) - 1))
{
return(true);
}
// If any of the surroundings is false, it is a border voxel, return true
for (int dx = x - 1; dx < (x + 2); ++dx)
{
for (int dy = y - 1; dy < (y + 2); ++dy)
{
for (int dz = z - 1; dz < (z + 2); ++dz)
{
if (!bools[dx, dy, dz])
{
return(true);
}
}
}
}
return(false);
}
/// <summary>
/// Creates an instance of this class from 3D boolean table.
/// </summary>
/// <param name="accessible">Boolean table: true - clear; false - obstacle.</param>
public GraphMap(bool[,,] accessible)
{
for (int x = 0; x < accessible.GetLength(0); x++)
{
for (int y = 0; y < accessible.GetLength(1); y++)
{
for (int z = 0; z < accessible.GetLength(2); z++)
{
if (!accessible[x, y, z])
{
continue;
}
var node = new Node(new Vector3(x, y, z));
for (int sx = -1; sx <= 1; sx++)
{
for (int sy = -1; sy <= 1; sy++)
{
for (int sz = -1; sz <= 1; sz++)
{
Node neighbour;
var offset = new Vector3(x + sx, y + sy, z + sz);
if (!_nodes.TryGetValue(offset, out neighbour))
{
continue;
}
neighbour.LinkAdjacent(node.Position - neighbour.Position, node);
node.LinkAdjacent(neighbour.Position - node.Position, neighbour);
}
}
}
_nodes.Add(node.Position, node);
}
}
}
}
private static ShapeType?Lookup(bool[,] match)
{
for (int i = 0; i < shapes.GetLength(0); i++)
{
var isMatch = true;
for (int y = 0; isMatch && y < shapes.GetLength(1); y++)
{
for (int x = 0; isMatch && x < shapes.GetLength(2); x++)
{
if (shapes[i, y, x] != match[x, y])
{
isMatch = false;
}
}
}
if (isMatch)
{
return(GetMatchType(i));
}
}
return(null);
}
private bool[,,] StateChanges3D(bool[,,] configuration)
{
var xLength = configuration.GetLength(0);
var yLength = configuration.GetLength(1);
var zLength = configuration.GetLength(2);
var changes = new bool[xLength, yLength, zLength];
for (int x = 0; x < xLength; x++)
{
for (int y = 0; y < yLength; y++)
{
for (int z = 0; z < zLength; z++)
{
var activeNeighbors = GetActiveNeighbors3D(x, y, z, configuration);
if (configuration[x, y, z] == true)
{
if (activeNeighbors != 3 && activeNeighbors != 4)
{
changes[x, y, z] = true;
}
}
if (configuration[x, y, z] == false)
{
if (activeNeighbors == 3)
{
changes[x, y, z] = true;
}
}
}
}
}
return(changes);
}
static Color[] ToColorsA(bool[, ,] values, int bits)
{
int dx = values.GetLength(0);
int dy = values.GetLength(1);
int dz = values.GetLength(2) / bits;
Color[] colors = new Color[dx * dy * dz];
for (int x = 0; x < dx; x++)
{
for (int y = 0; y < dy; y++)
{
for (int z = 0; z < dz; z++)
{
int iv = 0;
for (int n = 0; n < bits; n++)
{
iv |= values[x, y, z *bits + n] ? (1 << n) : 0;
}
colors[z * dx * dy + y * dx + x] = new Color(0, 0, 0, iv / (float)((1 << bits) - 1));
}
}
}
return(colors);
}
private int CountActiveCubes3D(bool [,,] configuration)
{
var xLength = configuration.GetLength(0);
var yLength = configuration.GetLength(1);
var zLength = configuration.GetLength(2);
var activeCubes = 0;
for (int x = 0; x < xLength; x++)
{
for (int y = 0; y < yLength; y++)
{
for (int z = 0; z < zLength; z++)
{
if (configuration[x, y, z] == true)
{
activeCubes++;
}
}
}
}
return(activeCubes);
}
private bool[,,] IncreaseConfiguration3D(bool[,,] configuration)
{
var xLength = configuration.GetLength(0);
var yLength = configuration.GetLength(1);
var zLength = configuration.GetLength(2);
var increasedConfiguration = new bool[xLength + 2, yLength + 2, zLength + 2];
for (int x = 0; x < xLength; x++)
{
for (int y = 0; y < yLength; y++)
{
for (int z = 0; z < zLength; z++)
{
if (configuration[x, y, z] == true)
{
increasedConfiguration[x + 1, y + 1, z + 1] = true;
}
}
}
}
return(increasedConfiguration);
}
protected override void ThreadFunction()
{
int chunkSize = ChunkManager.CHUNK_SIZE;
int chunkHeight = ChunkManager.CHUNK_HEIGHT;
Vector3 offset = chunkLocationToGenerate * chunkSize;
chunkVoxelArray = new bool[chunkSize + 1, chunkHeight, chunkSize + 1];
for (int i = 0; i < chunkVoxelArray.GetLength(0); i++)
{
for (int j = 0; j < chunkVoxelArray.GetLength(2); j++)
{
int height = PerlinCalculator.GetHeightAtCoords(i + (int)offset.x, j + (int)offset.z, 2);
for (int k = 0; k < chunkVoxelArray.GetLength(1); k++)
{
if (k <= height)
{
chunkVoxelArray[i, k, j] = true;
}
}
}
}
}
public void clear()
{
//очистка ВСЕХ ячеек и кандидатов на всякий от мусора
for (int i = 0; i < matrix.GetLength(0); i++)
{
for (int j = 0; j < matrix.GetLength(1); j++)
{
matrix[i, j] = 0;
for (int k = 0; k < candidates.GetLength(2); k++)
{
candidates[i, j, k] = true;
}
}
}
}
public void setBit(int x, int y, int z, bool val)
{
if (x >= field.GetLength(2) ||
y >= field.GetLength(0) ||
z >= field.GetLength(1) ||
false
)
{
return;
}
field[y, z, x] = val;
tetrisGrid.setBit(x, y, z, val);
}
private void FillEvironmentMap()
{
Vector3 halfExtents = Vector3.one * (CellSize / 2);
for (int x = 0; x < environmentMap.GetLength(0); x++)
{
for (int y = 0; y < environmentMap.GetLength(1); y++)
{
for (int z = 0; z < environmentMap.GetLength(2); z++)
{
if (Physics.OverlapBox(ConvertCellToPosition(new Point3D(x, y, z)), halfExtents).Length == 0)
{
environmentMap[x, y, z] = true;
}
}
}
}
}
public static bool[, ,] CopyMap(bool[, ,] given)
{
bool[, ,] ret = new bool[given.GetLength(0), given.GetLength(1), given.GetLength(2)];
for (int i = 0; i < given.GetLength(0); ++i)
{
for (int j = 0; j < given.GetLength(1); ++j)
{
for (int k = 0; k < given.GetLength(2); ++k)
{
ret [i, j, k] = given [i, j, k];
}
}
}
return(ret);
}
/// <summary>
/// Takes a Point3 in data coordinates.
/// </summary>
public Pathfinding(MazeStructure maze, bool[, ,] walls, Point3 center)
{
// initialize member variables
this.center = center;
this.maze = maze;
//Debug.Log(center);
data = new int[walls.GetLength(0), walls.GetLength(1), walls.GetLength(2)];
data.Initialize();
// create visited matrix
bool[, ,] visited = new bool[walls.GetLength(0), walls.GetLength(1), walls.GetLength(2)];
visited.Initialize();
// initialize vars
Queue <VisitPoint> toVisit = new Queue <VisitPoint>(walls.GetLength(0) * walls.GetLength(1));
toVisit.Enqueue(new VisitPoint(center, 0));
// visit every possible cell
while (toVisit.Count > 0)
{
// visit the given cell
int value = toVisit.Peek().value;
Point3 pos = toVisit.Dequeue().pos;
data[pos.x, pos.y, pos.z] = value;
visited[pos.x, pos.y, pos.z] = true;
// add appropriate neighbors to toVisit
Point3[] neighbors = Point3.Scramble(pos.neighbors(2));
foreach (Point3 newPos in neighbors)
{
if (maze.ValidMove(pos, newPos) && (!visited[newPos.x, newPos.y, newPos.z]))
{
toVisit.Enqueue(new VisitPoint(newPos, value + 1));
}
}
}
}
/// <summary>
/// Change bool[,,] to string[,,]
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public static string[,,] NumberToString(bool[,,] input)
{
string[,,] result = new string[input.GetLength(0), input.GetLength(1), input.GetLength(2)];
for (int i = 0; i < input.GetLength(0); i++)
{
for (int j = 0; j < input.GetLength(1); j++)
{
for (int k = 0; k < input.GetLength(2); k++)
{
result[i, j, k] = input[i, j, k].ToString();
}
}
}
return(result);
}
private int ActiveNeighbors(bool[,,] space, int x, int y, int z)
{
int size = space.GetLength(0);
int activeneighbors = 0;
for (int dx = -1; dx <= 1; dx++)
{
for (int dy = -1; dy <= 1; dy++)
{
for (int dz = -1; dz <= 1; dz++)
{
int x2 = x + dx, y2 = y + dy, z2 = z + dz;
if (x2 >= 0 && x2 < size && y2 >= 0 && y2 < size && z2 >= 0 && z2 < size &&
!(x2 == x && y2 == y && z2 == z) && space[x2, y2, z2])
{
activeneighbors++;
}
}
}
}
return(activeneighbors);
}
public void RebuildGrid(float cellSize, int gridSize, float duration,
float timeStep, Vector2 globalPosition, float visualHeightScale)
{
var allMatch = (
cellSize == CellSize &&
gridSize == GridSize &&
duration == Duration &&
timeStep == TimeStep &&
globalPosition == GlobalPosition &&
visualHeightScale == VisualHeightScale
);
if (allMatch)
{
RecreateGrid();
return;
}
CellSize = cellSize;
GridSize = gridSize;
Duration = duration;
TimeStep = timeStep;
GlobalPosition = globalPosition;
TimeStepCount = Mathf.RoundToInt(Duration / TimeStep);
Height = TimeStep * TimeStepCount;
Width = GridSideLength * CellSize;
GlobalY = Height / 2 - TimeStep / 2;
CellSize3D = new Vector3(CellSize, TimeStep, CellSize);
VisualHeightScale = visualHeightScale;
RecreateGrid();
_globalCoords = new Vector3[GridSideLength, TimeStepCount, GridSideLength];
for (var x = 0; x < _grid.GetLength(0); x++)
{
for (var t = 0; t < _grid.GetLength(1); t++)
{
for (var y = 0; y < _grid.GetLength(2); y++)
{
_globalCoords[x, t, y] = GridCoordsToGlobal(
x, t, y
);
}
}
}
}
void Start()
{
wallEntityLayerMask = 1 << LayersManager.layersManager.wallEntityLayer;
wallLayerMask = 1 << LayersManager.layersManager.wallLayer;
raycastLayerMask = wallEntityLayerMask | wallLayerMask;
minPositionX = Mathf.RoundToInt(boundaryWW.transform.position.x); // ASSUMPTION: will never round out of bounds
maxPositionX = Mathf.RoundToInt(boundaryEE.transform.position.x);
minPositionY = Mathf.RoundToInt(boundarySS.transform.position.y);
maxPositionY = Mathf.RoundToInt(boundaryNN.transform.position.y);
maxIndexX = maxPositionX - minPositionX;
maxIndexY = maxPositionY - minPositionY;
InitializeEnvironmentGraph();
XN = environmentGraph.GetLength(0);
YM = environmentGraph.GetLength(1);
circleSmallArray = new GameObject[maxIndexX + 1, maxIndexY + 1];
}
public static bool MazeMapEquals(bool[, ,] a, bool[, ,] b)
{
if (a.GetLength(0) != b.GetLength(0) || a.GetLength(1) != b.GetLength(1) || a.GetLength(2) != b.GetLength(2))
{
return(false);
}
for (int i = 0; i < a.GetLength(0); ++i)
{
for (int j = 0; j < a.GetLength(1); ++j)
{
for (int k = 0; k < a.GetLength(2); ++k)
{
if (a [i, j, k] != b [i, j, k])
{
return(false);
}
}
}
}
return(true);
}
public static bool RunTests(int pid, NktRemoteBridge remoteBridge)
{
//bool<->bool test
Console.Write(" Boolean single value test... ");
try
{
bool bBaseBool = true;
object res;
res = remoteBridge.InvokeJavaStaticMethod(pid, "JavaBooleanTest", "Test", bBaseBool);
if (res.GetType() != typeof(bool))
{
Console.WriteLine("Error: Invalid returned type");
return(false);
}
if ((bool)res != (!bBaseBool))
{
Console.WriteLine("Error: Returned data mismatch");
return(false);
}
}
catch (System.Exception ex)
{
Console.WriteLine("failed.");
Console.WriteLine(ex.ToString());
return(false);
}
Console.WriteLine(" OK");
//bool<->bool array test
Console.Write(" Boolean array test... ");
try
{
bool[, ,] arrayBool = new bool[4, 6, 5];
object res;
int i, j, k;
for (i = 0; i < 4; i++)
{
for (j = 0; j < 6; j++)
{
for (k = 0; k < 5; k++)
{
arrayBool[i, j, k] = (((i + j + k) & 1) != 0) ? true : false;
}
}
}
res = remoteBridge.InvokeJavaStaticMethod(pid, "JavaBooleanTest", "Test3D", new object[] { arrayBool });
if (res.GetType() != typeof(bool[, , ]))
{
Console.WriteLine("Error: Invalid returned type");
return(false);
}
bool[, ,] arrayBoolRes = (bool[, , ])res;
if (arrayBoolRes.GetLength(0) != 4 || arrayBoolRes.GetLength(1) != 6 || arrayBoolRes.GetLength(2) != 5)
{
Console.WriteLine("Error: Returned array size mismatch");
return(false);
}
for (i = 0; i < 4; i++)
{
for (j = 0; j < 6; j++)
{
for (k = 0; k < 5; k++)
{
if (arrayBoolRes[i, j, k] != (!arrayBool[i, j, k]))
{
Console.WriteLine("Error: Returned data mismatch (" + i.ToString() + "," + j.ToString() + "," + k.ToString() + ")");
return(false);
}
}
}
}
}
catch (System.Exception ex)
{
Console.WriteLine("failed.");
Console.WriteLine(ex.ToString());
return(false);
}
Console.WriteLine(" OK");
return(true);
}
void UpdateSplatTextures()
{
if (ContentLoader.Instance == null)
{
return;
}
UnityEngine.Profiling.Profiler.BeginSample("UpdateTerrainTextures", this);
var timer = System.Diagnostics.Stopwatch.StartNew();
for (int z = terrainDirtyBits.GetLength(2) - 1; z >= 0; z--)
{
bool setTerrain = false;
bool setGrass = false;
bool setSplat = false;
for (int y = 0; y < terrainDirtyBits.GetLength(1); y++)
{
for (int x = 0; x < terrainDirtyBits.GetLength(0); x++)
{
if (terrainDirtyBits[x, y, z])
{
GenerateTerrainTexture(x, y, z);
setTerrain = true;
terrainDirtyBits[x, y, z] = false;
if (timer.ElapsedMilliseconds > timeout)
{
break;
}
}
if (grassDirtyBits[x, y, z])
{
setGrass |= GenerateGrassTexture(x, y, z);
grassDirtyBits[x, y, z] = false;
if (timer.ElapsedMilliseconds > timeout)
{
break;
}
}
if (spatterDirtyBits[x, y, z])
{
GenerateSpatterTexture(x, y, z);
setSplat = true;
spatterDirtyBits[x, y, z] = false;
if (timer.ElapsedMilliseconds > timeout)
{
break;
}
}
if (timer.ElapsedMilliseconds > timeout)
{
break;
}
}
}
if (setTerrain || setGrass || setSplat)
{
UnityEngine.Profiling.Profiler.BeginSample("Apply terrain textures.", this);
if (setTerrain)
{
UpdateTerrainSplatTexture(z);
UpdateTerrainTintTexture(z);
}
if (setGrass)
{
UpdateGrassTexture(z);
}
if (setSplat)
{
UpdateSplatterTexture(z);
}
UnityEngine.Profiling.Profiler.EndSample();
}
}
UnityEngine.Profiling.Profiler.EndSample();
}