public static MeshData GenerateTerrainMesh(Vector3[,] points) { int width = points.GetLength(0); int height = points.GetLength(1); int vertexIndex = 0; MeshData meshData = new MeshData(width, height); for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { meshData.vertices[vertexIndex] = points[x, y]; meshData.uvs[vertexIndex] = new Vector2(x / (float)width, 1f - y / (float)height); if (x < width - 1 && y < height - 1) { meshData.AddTriangle(vertexIndex, vertexIndex + width, vertexIndex + width + 1); meshData.AddTriangle(vertexIndex + width + 1, vertexIndex + 1, vertexIndex); } vertexIndex++; } } return(meshData); }
public void generateCaves(Vector3[,] caveVoidPoints, int radius) { int numberOfCaves = caveVoidPoints.GetLength(0); int numberOfVoidPoints = caveVoidPoints.GetLength(1); for (int i = 0; i < numberOfCaves; i++) { for (int j = 0; j < numberOfVoidPoints; j++) { Vector3 voidPoint = caveVoidPoints [i, j]; for (int x = -1 * radius; x <= radius; x++) { for (int y = -1 * radius; y <= radius; y++) { for (int z = -1 * radius; z <= radius; z++) { Vector3 temp = new Vector3(voidPoint.x + x, voidPoint.y + y, voidPoint.z + z); Instantiate(undergroundBlock, temp, Quaternion.identity); Debug.Log(temp.x + " " + temp.y + " " + temp.z + " "); worldBlocks [(int)voidPoint.x + x, (int)voidPoint.y + y, (int)voidPoint.z + z] = null; } } } } } }
public void updateMesh() { Vector3[] vs = new Vector3[vertices.Length]; Vector3[,] mat = getMatrix(vertices, MAX_COUNT); int i = 0; for (int j = 0; j < mat.GetLength(0); j++) { for (int k = 0; k < mat.GetLength(1); k++, i++) { float perlin = 0; perlin = perlinOffset + perlinAmp1 * Mathf.PerlinNoise(getFloat(j + pos[0] + 5) * perlinDensity1 / 100f, getFloat(k + pos[1]) * perlinDensity1 / 100f) / 100f; perlin += perlinAmp2 * Mathf.PerlinNoise(getFloat(j + pos[0] + 5) * perlinDensity2 / 10f, getFloat(k + pos[1]) * perlinDensity2 / 10f) / 100f; perlin += perlinAmp3 * Mathf.PerlinNoise(getFloat(j + pos[0] + 5) * perlinDensity3 / 10f, getFloat(k + pos[1]) * perlinDensity3 / 10f) / 100f; vs[i] = vertices[i]; vs[i].y = hMultiplier * perlin; } } mesh.vertices = vs; mf.mesh = mesh; mesh.RecalculateBounds(); mesh.RecalculateNormals(); mesh.RecalculateTangents(); }
public Vector3 GetWorldPositionOfCenterOfTile(Vector2Int tile) { /* * for(int i = 0; i < walkableTiles.Count; i++) * { * if(walkableTiles[i].x == tile.x) * { * if(walkableTiles[i].y == tile.y) * { * float halfTilesize = tileSize / 2; * return new Vector3(worldWalkableTiles[i].x + halfTilesize, worldWalkableTiles[i].y + halfTilesize); * } * } * } * * return Vector3.zero; */ if ((tile.x < worldWalkableTilesArray.GetLength(0)) && (tile.x >= 0) && (tile.y < worldWalkableTilesArray.GetLength(1)) && (tile.y >= 0)) { float halfTilesize = tileSize / 2; Vector3 bottomLeft = worldWalkableTilesArray[tile.x, tile.y]; return(new Vector3(bottomLeft.x + halfTilesize, bottomLeft.y + halfTilesize)); } else { return(Vector3.zero); } }
/// <summary> /// Converts vertex graph to on dimensional vertex array /// </summary> /// <param name="gridVertexGraph"></param> /// <returns></returns> private Vector3[] CreateGridVertexGraphArray(Vector3[,] gridVertexGraph) { int columnCount = gridVertexGraph.GetLength(0); int rowCount = gridVertexGraph.GetLength(1); List <Vector3> vertices = new List <Vector3>(); for (int i = 0; i < columnCount - 1; i++) { for (int j = 0; j < rowCount - 1; j++) { for (int k = 0; k < 2; k++) { vertices.Add(gridVertexGraph[i + k, j]); vertices.Add(gridVertexGraph[i + k, j + 1]); } } } Vector3[] gridVertexArray = new Vector3[vertices.Count]; for (int i = 3; i < vertices.Count; i += 4) { gridVertexArray[i - 3] = vertices[i - 3]; gridVertexArray[i - 2] = vertices[i - 1]; gridVertexArray[i - 1] = vertices[i - 2]; gridVertexArray[i] = vertices[i]; } return(gridVertexArray); }
//Subdivide the landmass into a grid of 3D positions for agents to move to //Check using a raycast if there is ground underneath, if not specify that area as a place for water void createGrid() { grid = new Vector3[h, w]; for (int j = 0; j < grid.GetLength(0); j++) { for (int i = 0; i < grid.GetLength(1); i++) { float x = (i - landmass.transform.localScale.x / 2) + tile.transform.localScale.x / 2; float z = (j - landmass.transform.localScale.z / 2) + tile.transform.localScale.y / 2; int occupiedVal = occupied[j, i]; grid[j, i] = new Vector3(x, 2.75f, z); r = new Ray(new Vector3(x, 2.75f, z), Vector3.down); RaycastHit hit; if (Physics.Raycast(r.origin, Vector3.down, out hit, 2f)) { var currentTile = Instantiate(water, new Vector3(x, 2.75f, z), tile.transform.rotation); currentTile.transform.parent = GameObject.FindGameObjectWithTag("Tiles").transform; occupied[j, i] = -1; } if (showGrid) { if (occupied[j, i] == 1) { var currentTile = Instantiate(visitedTile, new Vector3(x, 2.75f, z), tile.transform.rotation); currentTile.transform.parent = GameObject.FindGameObjectWithTag("Tiles").transform; } else if (occupied[j, i] != -1) { var currentTile = Instantiate(tile, new Vector3(x, 2.75f, z), tile.transform.rotation); currentTile.transform.parent = GameObject.FindGameObjectWithTag("Tiles").transform; } } } } }
private void PlaceItems(Vector3[,] positionMatrix, GameObject parent, GameObject itemPrefab, int itemCount) { if (itemCount > positionMatrix.Length) { throw new Exception("There are too few rows in comparison to the itemCount in car."); } int a = 0; int b = positionMatrix.GetLength(1) - 1; for (int i = 0; i < itemCount; i++) { GameObject obj = Instantiate(itemPrefab); obj.transform.position = positionMatrix[a, b]; obj.transform.SetParent(parent.transform); a += 1; if (a >= positionMatrix.GetLength(0)) { a = 0; b -= 1; } } }
public static Bitmap GetImage(this Vector3[,] array) { int width = array.GetLength(0); int height = array.GetLength(1); Bitmap map = new Bitmap(width, height); BitmapData data = map.LockBits(new Rectangle(0, 0, map.Width, map.Height), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb); unsafe { byte *byte_data = (byte *)data.Scan0.ToPointer(); int pos; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { pos = (y * width + x) * 4; byte_data[pos] = (byte)(array[x, y].z * 255); pos++; byte_data[pos] = (byte)(array[x, y].y * 255); pos++; byte_data[pos] = (byte)(array[x, y].x * 255); pos++; byte_data[pos] = 255; pos++; } } } map.UnlockBits(data); return(map); }
private void button6_Click(object sender, EventArgs e) { if (openFileDialog1.ShowDialog() == DialogResult.OK) { Vector3[,] val = Procedurs.Medium(openFileDialog1.FileName); Morf morf = Morf.GenerateKMean(val, 5); morf.RemoveEmptyRegions(); List <Vector3> avrs = new List <Vector3>(); for (int i = 0; i < morf.regions.Count; i++) { avrs.Add(morf.regions[i].GetAverage(val)); } float[,] temp = new float[val.GetLength(0), val.GetLength(1)]; float[,] temp2 = new float[val.GetLength(0), val.GetLength(1)]; VideoProcessig videoProcessig = new VideoProcessig(openFileDialog1.FileName, (map) => { val.WriteRGB(map); Procedurs.MorfSubtract(morf, avrs, val, temp); temp2.ForEach(() => 0); Procedurs.BlockSum(temp, temp2, 5); temp2.RegMaximum(); return(temp2); }); videoProcessig.Show(); } }
public Vector3[,] DistInAvr(Vector3[,] map, Vector3 color) { int width = map.GetLength(0); int height = map.GetLength(1); Vector3[,] result = new Vector3[width, height]; List <float> dist = new List <float>(); for (int i = 0; i < regions.Count; i++) { Vector3 avr = regions[i].GetAverage(map); dist.Add((avr - color).Magnitude()); } //int minIndex = 0; for (int i = 0; i < regions.Count; i++) { float val = 1 / (1 + dist[i]); val = val > 0.92f ? val : 0; regions[i].Fill(new Vector3(val, val, val), result); } //regions[minIndex].Fill(new Vector3(1, 1, 1), result); return(result); }
private Transform[] GenerateBones(Vector3[,] vertices) { Transform[] bones = new Transform[vertices.GetLength(1)]; Vector3 bonePosition = new Vector3(); for (int j = 0; j < vertices.GetLength(1); j++) { bonePosition.Set(0, 0, 0); for (int i = 0; i < vertices.GetLength(0); i++) { bonePosition += vertices[i, j]; } bonePosition /= vertices.GetLength(0); bones[j] = new GameObject("Bone" + j).transform; bones[j].parent = transform; bones[j].localRotation = Quaternion.identity; bones[j].localPosition = bonePosition; bones[j].gameObject.layer = LayerMask.NameToLayer("MassSpring"); } return(bones); }
public Mesh MakeMesh() { var m = new Mesh(); var verts = new List <Vector3>(); var triangles = new List <int>(); for (int y = 0; y < pointsReal.GetLength(1) - 1; y++) { for (int x = 0; x < pointsReal.GetLength(0) - 1; x++) { verts.Add(pointsReal[x, y]); verts.Add(pointsReal[x, y + 1]); verts.Add(pointsReal[x + 1, y + 1]); verts.Add(pointsReal[x + 1, y]); triangles.Add(x * 4); triangles.Add(x * 4 + 1); triangles.Add(x * 4 + 2); triangles.Add(x * 4 + 0); triangles.Add(x * 4 + 2); triangles.Add(x * 4 + 3); } } m.SetVertices(verts); m.SetTriangles(triangles.ToArray(), 0); m.RecalculateTangents(); m.RecalculateNormals(); return(m); }
public Vector3[] CameraPointsToAudioLocations(Vector3[,] depthMap, int resolution) { int yOSize = depthMap.GetLength(0); int xOSize = depthMap.GetLength(1); int ySize = (int)Math.Ceiling((double)yOSize / resolution); int xSize = (int)Math.Ceiling((double)xOSize / resolution); int[] maxes = new int[resolution * resolution]; Vector3[] maxIndicies = new Vector3[maxes.Length]; for (int i = 0; i < maxes.Length; i++) { maxes[i] = 100000; } for (int i = 0; i < yOSize; i++) { for (int j = 0; j < xOSize; j++) { int tempCell = i / ySize * resolution + j / xSize; Vector3 pt = depthMap[i, j]; int dist = (int)Math.Sqrt(pt.x * pt.x + pt.y * pt.y + pt.z * pt.z); // Debug.Log(pt); if (dist >= 0 && dist < maxes[tempCell]) { maxes[tempCell] = dist; maxIndicies[tempCell] = new Vector3(pt.x, pt.y, pt.z); } } } return(maxIndicies); }
public static MeshData generateMesh(Vector3[,] heightMap) { int width = heightMap.GetLength(0); int height = heightMap.GetLength(1); float topLeftX = (width - 1) / -2f; float topLeftZ = (height - 1) / 2f; MeshData meshData = new MeshData(width, height); int vertexIndex = 0; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { meshData.vertices [vertexIndex] = new Vector3(topLeftX + heightMap[x, y].x, heightMap[x, y].y, topLeftZ - heightMap[x, y].z); meshData.uvs [vertexIndex] = new Vector2(x / (float)width, y / (float)height); if (x < width - 1 && y < height - 1) { meshData.AddTriangle(vertexIndex, vertexIndex + width + 1, vertexIndex + width); meshData.AddTriangle(vertexIndex + width + 1, vertexIndex, vertexIndex + 1); } vertexIndex++; } } return(meshData); }
public static MeshData GenerateMeshData(Vector3[,] verticesMatrix, Vector2[,] uvs, Color color, NeighBoursDirection direction) { int width = verticesMatrix.GetLength(0); int height = verticesMatrix.GetLength(1); MeshData meshData = new MeshData(width, height); int vertexIndex = 0; for (int y = 0; y < height; ++y) { for (int x = 0; x < width; ++x) { meshData.Vertices[vertexIndex] = verticesMatrix[x, y]; meshData.UVS[vertexIndex] = uvs[x, y]; meshData.Colors[vertexIndex] = color; if (x < width - 1 && y < height - 1) { if (direction == NeighBoursDirection.BOTTOM || direction == NeighBoursDirection.LEFT) { meshData.AddTriangle(vertexIndex, vertexIndex + width + 1, vertexIndex + width); meshData.AddTriangle(vertexIndex + width + 1, vertexIndex, vertexIndex + 1); } else { meshData.AddTriangle(vertexIndex, vertexIndex + width, vertexIndex + width + 1); meshData.AddTriangle(vertexIndex + width + 1, vertexIndex + 1, vertexIndex); } } vertexIndex++; } } return(meshData); }
// ienumeradores privados private IEnumerator CalculateCellPositions() { // precorre a lista de celulas e atribui a posiçao para cada uma delas // segundo a coluna for (int x = 0; x < projecter_cell_position.GetLength(0); x++) { // segundo a linha for (int y = 0; y < projecter_cell_position.GetLength(1); y++) { // define a posiçao da celula // posiçao local projecter_cell_position[x, y] = new Vector3((-projecter_area_.x * 0.5f) + projecter_cell_size_ * 0.5f + projecter_cell_size_ * x, (-projecter_area_.y * 0.5f) + projecter_cell_size_ * 0.5f + projecter_cell_size_ * y, -0.5f * projecter_area_.z); // calcula a posiçao no mundo relativa ao objecto projecter_cell_position[x, y] = this.transform.TransformPoint(projecter_cell_position[x, y]); } // aguarda o proximo frame yield return(null); } //degub Debug.Log($"{projecter_cell_position.Length} Calculated positions"); // ao terminar de calcular as posiçoes para cada uma das celulas // activa os elementos projectores foreach (ProjectedSystem projected_system in project_to_) { // inicia estas areas projected_system.ActivateProjectedArea(this, projecter_cell_position.GetLength(0), projecter_cell_position.GetLength(1)); } // inicia a projecçao StartCoroutine(ProjectionActivity()); }
public void PokazPozycje() { for (int i = 0; i < positions.GetLength(0); i++) { for (int j = 0; j < positions.GetLength(1); j++) { bool ignore = false; for (int k = 0; k < toIgnore.GetLength(0); k++) { if (i == toIgnore[k, 0] && j == toIgnore[k, 1]) { ignore = true; break; } } if (!ignore) { GameObject z = Instantiate(pointOnBoard, positions[i, j], Quaternion.FromToRotation(Vector3.forward, transform.up)) as GameObject; z.transform.parent = this.transform; z.GetComponent <PointOnBoardScript>().gridI = i; z.GetComponent <PointOnBoardScript>().gridJ = j; points[i, j] = z.GetComponent <PointOnBoardScript>(); } } } }
//Awake()で走っていたスクリプト public void FirstMethod() { //スタート位置を生成 railPos = cellPoint[UnityEngine.Random.Range(cellPoint.GetLength(0) - 1, 0), UnityEngine.Random.Range(0, cellPoint.GetLength(1) - 1)]; mapData.Add(railPos); param = mapData[mapData.Count - 1]; //cellPointのIndexを取得するためのリストに値を入れる for (int i = 0; i <= cellPoint.GetLength(0) - 1; i++) { for (int j = 0; j <= cellPoint.GetLength(1) - 1; j++) { xIndex.Add(i); zIndex.Add(j); } } //mapDataにデータを格納 for (int i = 1; i <= maxRail - 1; i++) { railPos = RandomMaker(zIndex, xIndex); mapData.Add(railPos); param = mapData[mapData.Count - 2]; } }
private void Start() { tiles = new Tile[xLength * space.GetLength(1)]; float xOffset = xLength / 2f - 0.5f; float yOffset = space.GetLength(1) / 2f - 0.5f; levelIndex = Random.Range(0, Levels.templates.Length); for (int y = 0; y < space.GetLength(1); y++) { for (int x = 0; x < xLength; x++) { var index = x + (y * xLength); if (Levels.templates[levelIndex][index] == 1) { var pos = new Vector3(x - xOffset, y - yOffset, 0); var temp = Instantiate(bg_prefab, pos, Quaternion.identity); temp.transform.parent = transform; var typeIndex = Random.Range(0, tile_prefabs.Length); var tile = Instantiate(tile_prefabs[typeIndex], pos, Quaternion.identity); tile.transform.parent = transform; var tileComponent = tile.AddComponent <Tile>(); tileComponent.indexX = x; tileComponent.indexY = y; tileComponent.typeIndex = typeIndex; tiles[index] = tileComponent; } } } }
public Vector3[,] BestInAvr(Vector3[,] map, Vector3 color) { int width = map.GetLength(0); int height = map.GetLength(1); Vector3[,] result = new Vector3[width, height]; List <float> dist = new List <float>(); for (int i = 0; i < regions.Count; i++) { Vector3 avr = regions[i].GetAverage(map); dist.Add((avr - color).Magnitude()); } int minIndex = 0; for (int i = 0; i < regions.Count; i++) { regions[i].Fill(new Vector3(), result); if (dist[minIndex] > dist[i]) { minIndex = i; } } regions[minIndex].Fill(new Vector3(1, 1, 1), result); return(result); }
// Use this for initialization void Awake() { audioManager = FindObjectOfType <AudioManager>(); enemyObjects = new GameObject[enemyPosArray.GetLength(1)]; for (int i = 0; i < enemyPosArray.GetLength(1); i++) { enemyObjects[i] = Instantiate(enemyPrefab, Vector3.down * 2, Quaternion.identity); } }
public void SetIfUserCanInput(bool isUserCanInput, Vector3[,] cellsPositions) { _isInputUserActive = isUserCanInput; _cellsPosition = cellsPositions; _currentPositionI = _cellsPosition.GetLength(0) / 2; _currentPositionJ = _cellsPosition.GetLength(1) / 2; RefreshPositionOfPlayer(); }
public Vector3[] getPos(int body) { Vector3[] temp = new Vector3[positions.GetLength(1)]; for (int i = 0; i < positions.GetLength(1); i++) { temp[i] = positions[body - 1, i]; } return(temp); }
//---------------------- //----------------------- Vector3[] GetLineToPass(Vector3[,] bMatrix, int reflIndex) { Vector3[] lineContainer = new Vector3[bMatrix.GetLength(1)]; for (int points = 0; points < bMatrix.GetLength(1); points++) { lineContainer[points] = bMatrix[reflIndex, points]; } return(lineContainer); }
/// <summary> /// Removes No Data values by filling in from average of surrounding pixels /// </summary> /// <param name="ret"></param> void RemoveNaNs(Vector3[,] ret, List <XY> nanIndices) { int[] valid = new int[nanIndices.Count]; for (int i = 0; i < nanIndices.Count; i++) { XY xy = nanIndices[i]; int s = 0; if ((xy.x > 0) && (ret[xy.y, xy.x - 1].Z != NoData)) { s++; } if ((xy.x < ret.GetLength(1) - 1) && (ret[xy.y, xy.x + 1].Z != NoData)) { s++; } if ((xy.y > 0) && (ret[xy.y - 1, xy.x].Z != NoData)) { s++; } if ((xy.y < ret.GetLength(0) - 1) && (ret[xy.y + 1, xy.x].Z != NoData)) { s++; } valid[i] = s; } for (int i = 0; i < nanIndices.Count; i++) { if (valid[i] == 0) { continue; } XY xy = nanIndices[i]; double sum = 0; int s = 0; if ((xy.x > 0) && ret[xy.y, xy.x - 1].Z != NoData) { sum += ret[xy.y, xy.x - 1].Z; s++; } if ((xy.x < ret.GetLength(1) - 1) && ret[xy.y, xy.x + 1].Z != NoData) { sum += ret[xy.y, xy.x + 1].Z; s++; } if ((xy.y > 0) && ret[xy.y - 1, xy.x].Z != NoData) { sum += ret[xy.y - 1, xy.x].Z; s++; } if ((xy.y < ret.GetLength(0) - 1) && ret[xy.y + 1, xy.x].Z != NoData) { sum += ret[xy.y + 1, xy.x].Z; s++; } ret[xy.y, xy.x].Z = (float)(sum / s); } }
///<summary> /// Renvoie un iterateur sur l'array 2D qui va d'abord dans le sens oblique puis dans le sens tangent ///</summary> public IEnumerable <Vector3> Flatten(Vector3[,] arr2D) { for (int i = 0; i < arr2D.GetLength(0); i++) { for (int j = 0; j < arr2D.GetLength(1); j++) { yield return(arr2D[i, j]); } } }
void CalculatePoints() { for (int i = 0; i < points.GetLength(0); i++) { for (int j = 0; j < points.GetLength(1); j++) { pointsReal[i, j] = Vector3.Lerp(points[i, j], pointsSphere[i, j], Lerp); } } }
// Generate ofc public void Generate() { for (int i = 0; i < blocks.GetLength(0); i++) { for (int j = 0; j < blocks.GetLength(1); j++) { blocks[i, j] = GenerateBlock(i, j, seed); } } }
private IEnumerator SpawnTreesAsync(Vector3[,] globalVertexPositions) { var operations = 0; for (var zInd = 0; zInd < globalVertexPositions.GetLength(0) / tiling; zInd++) { for (var xInd = 0; xInd < globalVertexPositions.GetLength(1) / tiling; xInd++) { var heightSum = 0f; for (var zStart = zInd * tiling; zStart < (zInd + 1) * tiling; zStart++) { for (var xStart = xInd * tiling; xStart < (xInd + 1) * tiling; xStart++) { heightSum += globalVertexPositions[zStart, xStart].y; } } heightSum /= tiling * tiling; /* * if(heightSum <= treeMaxBound && heightSum >= treeMinBound) * { * Instantiate(treePrefab, * globalVertexPositions[zInd * tiling + tiling / 2, xInd * tiling + tiling / 2], * Quaternion.Euler(0f, Random.Range(0f, 360f), 0f)); * } */ for (var i = 0; i < spawnableObjects.Length; i++) { var so = spawnableObjects[i]; if (so.maxBound > heightSum) { if (Random.Range(0f, 1f) <= so.probability && so.vars.Length > 0) { Instantiate(so.vars[Random.Range(0, so.vars.Length)], globalVertexPositions[zInd * tiling + tiling / 2, xInd * tiling + tiling / 2], Quaternion.Euler(0f, Random.Range(0f, 360f), 0f)); } break; } } if (operations >= asyncOperations) { operations = 0; yield return(null); } } } // //placing the stars //starsTf.position = transform.position + new Vector3(levelSize.x * mapWidth / 2, 0f, levelSize.y * mapDepth / 2); Debug.LogWarning("Trees gened async!"); yield break; }
public Vector3 VectorFromPosition(int x, int y) { try { return(centers[y, x]); } catch (System.Exception error) { return(centers[centers.GetLength(0) - 1, centers.GetLength(1) - 1]); } }
private void setParticleStartLocations(){ endLocations = new Vector3[widthOfParticals, widthOfParticals]; Vector3 particelStartLocation = gridBlockMovingTo.transform.position; //particelStartLocation = new Vector3(particelStartLocation.x, 0.01f, particelStartLocation.y); int x, y; for(x = 0; x < widthOfParticals; x++){ for(y = 0; y < widthOfParticals; y++){ endLocations[x, y] = particelStartLocation; float posX, posY; posX = x * offsetAmount; posX -= ((widthOfParticals - 1f) * offsetAmount) / 2f; posY = y * offsetAmount; posY -= ((widthOfParticals - 1f) * offsetAmount) / 2f; endLocations[x, y] += new Vector3(posX, 0, posY); } } #region semi randomize end locations int n = endLocations.GetLength(0); Vector3[,] temp = new Vector3[n, n]; Vector3 endTemp; x = 0; y = 0; int x1, y1; if(directionMoving == Direction.UP){ for(int i = 0; i < endLocations.Length * 3; i++){ x = Random.Range(0, widthOfParticals); y = Random.Range(0, widthOfParticals); x1 = Random.Range(0, widthOfParticals); endTemp = endLocations[x, y]; // swap 2 x values in a single y column endLocations[x, y] = endLocations[x1, y]; endLocations[x1, y] = endTemp; } } else if(directionMoving == Direction.RIGHT){ for(int i = 0; i < n; ++i){ for(int j = 0; j < n; ++j){ temp[i, j] = endLocations[j, i]; } } endLocations = temp; for(int i = 0; i < endLocations.Length * 3; i++){ x = Random.Range(0, widthOfParticals); y = Random.Range(0, widthOfParticals); x1 = Random.Range(0, widthOfParticals); endTemp = endLocations[x, y]; // swap 2 y values in a single x column endLocations[x, y] = endLocations[x1, y]; endLocations[x1, y] = endTemp; } } else if(directionMoving == Direction.LEFT){ for(int i = 0; i < n; ++i){ for(int j = 0; j < n; ++j){ temp[i, j] = endLocations[n - j - 1, i]; } } endLocations = temp; for(int i = 0; i < endLocations.Length * 3; i++){ x = Random.Range(0, widthOfParticals); y = Random.Range(0, widthOfParticals); x1 = Random.Range(0, widthOfParticals); endTemp = endLocations[x, y]; // swap 2 y values in a single x column endLocations[x, y] = endLocations[x1, y]; endLocations[x1, y] = endTemp; } } else if(directionMoving == Direction.DOWN){ for(int i = 0; i < n; ++i){ for(int j = 0; j < n; ++j){ temp[i, j] = endLocations[i, n - j - 1]; } } endLocations = temp; for(int i = 0; i < endLocations.Length * 3; i++){ x = Random.Range(0, widthOfParticals); y = Random.Range(0, widthOfParticals); x1 = Random.Range(0, widthOfParticals); endTemp = endLocations[x, y]; // swap 2 x values in a single y column endLocations[x, y] = endLocations[x1, y]; endLocations[x1, y] = endTemp; } } #endregion }