// Start is called before the first frame update void Start() { tileGrid = new Transform[gridWidth, gridHeight]; for (int i = 0; i != gridHeight; ++i) { for (int j = 0; j != gridWidth; ++j) { var pos = new Vector3( -gridWidth * gridSpacing / 2 + gridSpacing / 2 + j * gridSpacing, -gridWidth * gridSpacing / 2 + gridSpacing / 2 + i * gridSpacing, 0 ); var obj = Instantiate(tileObject, pos, Quaternion.identity, transform); obj.name = $"Damage Tile [{i}, {j}]"; tileGrid[i, j] = obj.transform; //checkerboard //if ((i % 3) != 0 || (j % 3) != 0) { obj.SetActive(false); //} //size obj.transform.localScale = new Vector3(16.0f / ((float)gridWidth), 16.0f / ((float)gridHeight), 1.0f); } } }
void Start() { if (row1 == null || row2 == null || row3 == null || row4 == null) { Debug.Log("Row objects are missing!"); return; } // create a multi-dimensional array that includes all the tubes' transform informations rowTransformArray = new Transform[4, 3] { { row1.gameObject.transform.GetChild(0), row1.gameObject.transform.GetChild(1), row1.gameObject.transform.GetChild(2) }, { row2.gameObject.transform.GetChild(0), row2.gameObject.transform.GetChild(1), row2.gameObject.transform.GetChild(2) }, { row3.gameObject.transform.GetChild(0), row3.gameObject.transform.GetChild(1), row3.gameObject.transform.GetChild(2) }, { row4.gameObject.transform.GetChild(0), row4.gameObject.transform.GetChild(1), row4.gameObject.transform.GetChild(2) }, }; //No need // row1TubePositionY = new Vector3 (0,rowTransformArray[0,0].position.y,0); // row2TubePositionY = new Vector3 (0,rowTransformArray[1,0].position.y,0); //row3TubePositionY = new Vector3 (0,rowTransformArray[2,0].position.y,0); // row4TubePositionY = new Vector3 (0,rowTransformArray[3,0].position.y,0); // restartLoopingDistance = new Vector3(50, 0, 0); }
private void Start() { cubes = new Transform[sideLength, sideLength]; float offset = (float)sideLength / 2f - .5f; // Instantiate array of cubes for (int x = 0; x < sideLength; x++) { for (int z = 0; z < sideLength; z++) { Transform cube = Instantiate(cubePrefab); cube.transform.parent = transform; cube.localPosition = new Vector3(x - offset, 0, z - offset); cube.localScale = Vector3.one * cubeScale; // Make a checkerboard layer change to demo the layer segmentation if ((x + z) % 2 == 0) { cube.gameObject.layer = 3; } cubes[x, z] = cube; } } }
public void generateMap() { clearMap(); map = new Transform[map_width, map_height]; usedMap = new bool[map_width, map_height]; var container = GameObject.Find("CellContainer"); //普通MAP初始化 for (int i = 0; i < map.GetLength(0); i++) { for (int j = 0; j < map.GetLength(1); j++) { //初始化MAP,生成CELL var cell = Instantiate(cellPrefeb, container.transform); cell.GetComponent <Cell>().Initilize(); cell.transform.localPosition = new Vector3(i * cell_delta + origin.x, 0.1f, j * cell_delta + origin.y); cell.GetComponent <Cell>().mapPos = new Vector2(i, j); map[i, j] = cell.transform; //初始化UsedMap为False usedMap[i, j] = false; } } }
public void GenerateMap() { currentMap = maps[mapIndex]; tileMap = new Transform[currentMap.mapSize.x, currentMap.mapSize.y]; if (currentMap.seed == "") { currentMap.seed = Ultility.GetRandomString(rnd, 64); } CoordAllTitles(); shuffledTitleCoords = new Queue <Coord>(Ultility.ShuffleArray(allTitleCoords.ToArray(), currentMap.seed)); string holderName = "Generated Map"; if (transform.FindChild(holderName)) { DestroyImmediate(transform.FindChild(holderName).gameObject); } Transform mapHolder = new GameObject(holderName).transform; mapHolder.parent = transform; CreateFloor(mapHolder, new System.Random(currentMap.seed.GetHashCode())); CreateObstacles(mapHolder); CreateBorder(mapHolder); }
//从当前已生成的CELL构建出MAP public void ReadMapFromEditor() { if (map == null) { map = new Transform[map_width, map_height]; } if (usedMap == null) { usedMap = new bool[map_width, map_height]; } for (int i = 0; i < usedMap.GetLength(0); i++) { for (int j = 0; j < usedMap.GetLength(1); j++) { usedMap[i, j] = false; } } var cells = this.GetComponentsInChildren <Cell>(); foreach (var cell in cells) { var mappos = cell.mapPos; map[(int)mappos.x, (int)mappos.y] = cell.transform; } }
// Start is called before the first frame update void Start() { previous_object_transform = new Transform[100, 100]; //if (go != null) //{ // for (int x = 0; x < 10; x++) // { // double z_angle = Random.Range(-30, 30); // go.transform.rotation = Quaternion.Euler(0, 0, (float)z_angle); // double x_len = 1 / Mathf.Cos((float)z_angle); // double y_pos = (x_len * Mathf.Sin((float)z_angle)) / 0.2; // go.transform.position = new Vector3(x * 10, (float)y_pos, 0); // go.transform.localScale = new Vector3((float)x_len, 1, 1); // //new Quaternion(0, 0, Random.Range(-1, 1), 1); // Instantiate(go, go.transform); // } /*int max = 100; * * for (int x = 0; x < max; x++) * { * for (int z = 0; z < max; z++) * { * go.transform.position = new Vector3(x, Random.Range(-1, 1), z); * go.transform.rotation = new Quaternion(Random.Range(-1, 1), Random.Range(-1, 1), Random.Range(-1, 1), 1); * Instantiate(go, go.transform); * } * }*/ //} }
void Start() { //Load prefab "Grass" from "Resources/Prefabs/" folder. tilePrefab = Resources.Load<Transform>("Prefabs/GrassTile"); //If we can't find the prefab then log a warning. if (!tilePrefab) Debug.LogWarning("Unable to find TilePrefab in your Resources folder."); //Initialize our 2D Transform array with the width and height map = new Transform[mapWidth, mapHeight]; //Iterate over each future tile positions for x and y for (int y = 0; y < mapHeight; y++) { for (int x = 0; x < mapWidth; x++) { //Instantiate tile prefab at the desired position as a Transform object Transform tile = Instantiate(tilePrefab, new Vector3(x * tileSize, y * tileSize, 0), Quaternion.identity) as Transform; //Set the tiles parent to the GameObject this script is attached to tile.parent = transform; //Set the 2D map array element to the current tile that we just created. map[x, y] = tile; } } BoxCollider box = gameObject.AddComponent<BoxCollider>(); box.size = new Vector3(mapWidth * tileSize, mapHeight * tileSize, 0.5f); box.center = transform.localPosition + new Vector3((mapWidth * tileSize) * 0.5f, (mapHeight * tileSize) * 0.5f, 0); }
void Start() { nodeArr = new Node[lX, lY]; blockArr = new int[lX, lY]; itemsArr = new Transform[lX, lY]; started = false; }
private IEnumerator CreateAsteroids() { asteroids = new Asteroid[gridSize, gridSize]; deathTimers = new float[gridSize, gridSize]; transforms = new Transform[gridSize, gridSize]; int asteroidsCreated = 0; for (int i = 0; i < gridSize; i++) { for (int j = 0; j < gridSize; j++) { asteroids[i, j] = Instantiate(asteroidPrefab); asteroids[i, j].gameObject.SetActive(false); deathTimers[i, j] = float.MinValue; transforms[i, j] = asteroids[i, j].transform; asteroidsCreated++; if (asteroidsCreated % spawnPerFrame == 0) { yield return(null); } } } gameManager.StartGame(); areAllCreated = true; RestartAsteroids(); }
void Update() { // Choose the next destination point when the agent gets // close to the current one. cash = Random.Range (-10, 25); if (agent.remainingDistance < 0.05f) { timer--; if(timer <= 0) { GotoNextPoint(); Money.profit += cash; timer = Random.Range (80,180); } } if(Router.onion [ID] == true && !started) { points = Router.Route; for(int i = 0; i < points.GetLength(1); i++) { Debug.Log(points[ID,i]); if(points[ID,i] != null) { index++; } else { Debug.Log (index); } } GotoNextPoint(); started = true; } }
void Start() { rigidBody = this.GetComponent<Rigidbody>(); JetLocations = new Transform[2,2]; DesiredDist = new float[2,2]; DesiredDist[0,0] = DesiredDist[0,1] = DesiredDist[1,0] = DesiredDist[1,1] = DefaultDesiredDist; //[0,0] = front left, [0,1] = front right, [1,0] = back left, [1,1] = back right var transforms = this.GetComponentsInChildren<Transform>(); foreach (var t in transforms){ switch(t.name){ case "JetFrontLeft": JetLocations[0,0] = t; break; case "JetFrontRight": JetLocations[0,1] = t; break; case "JetBackLeft": JetLocations[1,0] = t; break; case "JetBackRight": JetLocations[1,1] = t; break; case "Front": Front = t; break; case "Back": Back = t; break; } } }
private void SetActiveFalse(Transform[,] container) { foreach (var item in container) { item.gameObject.SetActive(false); } }
// Creates the grid by instantiating provided cell prefabs. void CreateGrid() { Grid = new Transform[(int)Size.x,(int)Size.z]; MiniMap = new Transform[(int)Size.x,(int)Size.z]; // Places the cells and names them according to their coordinates in the grid. for (int x = 0; x < Size.x; x++) { for (int z = 0; z < Size.z; z++) { Transform newCell; newCell = (Transform)Instantiate(CellPrefab, new Vector3(((float)x)*scaling, 0, ((float)z)*scaling), Quaternion.identity); newCell.localScale = new Vector3(scaling, newCell.localScale.y, scaling); newCell.name = string.Format("({0},0,{1})", x, z); newCell.parent = transform; newCell.GetComponent<CellScript>().Position = new Vector3(((float)x)*scaling, 0, ((float)z)*scaling); newCell.GetComponentInChildren<TextMesh>().renderer.enabled = false; Grid[x,z] = newCell; //Create physical minimap Transform MMCell; MMCell = (Transform)Instantiate(CellPrefab, new Vector3(((float)x)*scaling, -40, ((float)z)*scaling), Quaternion.identity); MMCell.localScale = new Vector3(scaling, MMCell.localScale.y, scaling); MMCell.name = string.Format("mm({0},0,{1})", x, z); MMCell.parent = MMContainer.transform; //MMCell.GetComponent<CellScript>().Position = new Vector3(x, -40, z); MMCell.GetComponentInChildren<TextMesh>().renderer.enabled = false; MiniMap[x,z] = MMCell; } } // Centers the camera on the maze. // Feel free to adjust this as needed. Camera.main.transform.position = Grid[(int)(Size.x / 2f),(int)(Size.z / 2f)].position - Vector3.up * 20f; Camera.main.orthographicSize = Mathf.Max(Size.x * scaling * 0.6f, Size.z * scaling * 0.4f); //adds borders around the Grid Transform border1, border2, border3, border4; border1 = (Transform)Instantiate (CellPrefab, new Vector3 (((Size.x / 2) * scaling) - 1.5f, 0, -1 * (scaling / 2) - 0.5f), Quaternion.identity); //Vector3 is position border1.localScale = new Vector3 (scaling * Size.x, 5, 1); border1.GetComponentInChildren<TextMesh>().renderer.enabled = false; border1.renderer.material = WallMat; border1.transform.tag = "Wall"; border1.parent = transform; border2 = (Transform)Instantiate (CellPrefab, new Vector3(Size.x * scaling - 1f, 0, ((Size.z / 2) * scaling) - 1.5f), Quaternion.identity); border2.localScale = new Vector3 (1, 5, scaling * Size.z + 2f); border2.GetComponentInChildren<TextMesh>().renderer.enabled = false; border2.renderer.material = WallMat; border2.transform.tag = "Wall"; border2.parent = transform; border3 = (Transform)Instantiate (CellPrefab, new Vector3(((Size.x / 2) * scaling) - 1.5f, 0, Size.z * scaling - 1f), Quaternion.identity); border3.localScale = new Vector3 (scaling * Size.x, 5, 1); border3.GetComponentInChildren<TextMesh>().renderer.enabled = false; border3.renderer.material = WallMat; border3.transform.tag = "Wall"; border3.parent = transform; border4 = (Transform)Instantiate(CellPrefab, new Vector3(-2, 0, ((Size.z / 2) * scaling) - 1.5f), Quaternion.identity); border4.localScale = new Vector3 (1, 5, scaling * Size.z + 2f); border4.GetComponentInChildren<TextMesh>().renderer.enabled = false; border4.renderer.material = WallMat; border4.transform.tag = "Wall"; border4.parent = transform; }
// Use this for initialization void Start() { _color = new Color[64]; //zet lengte array _material = new Material[64]; // zet lengte array for (int i = 0; i < 64; i++) { _color[i] = _gradient.Evaluate(i * (1f / 64)); //handige manier om van een gradient veel kleuren te maken _material[i] = new Material(_baseMaterial); //maak 64 materials aan voor iedere kleur of audioband _material[i].EnableKeyword("_EMISSION"); //zet emission optie aan in de standard surface shader } _prefabTransform = new Transform[_gridSize.x, _gridSize.y]; //zet lengte array for (int x = 0; x < _gridSize.x; x++) { for (int z = 0; z < _gridSize.y; z++) { GameObject prefabInstance = (GameObject)Instantiate(_prefab); //instantiate game object prefabInstance.transform.parent = this.transform; // maak het nieuwe object een child van het object waar dit script op zit prefabInstance.transform.localPosition = new Vector3(x * _spaceInBetween, 0, z * _spaceInBetween); //zet positie in de grid prefabInstance.transform.GetChild(0).GetComponent <MeshRenderer>().material = _material[Random.Range(0, 64)]; //verdeel een random kleur //gebruik onderstaande regel om rijen van dezelfde kleur/band te maken //probeer zelf om een interessante verdeling van kleuren te maken //prefabInstance.transform.GetChild(0).GetComponent<MeshRenderer>().material = _material[x]; _prefabTransform[x, z] = prefabInstance.transform; } } }
// Start is called before the first frame update void Start() { map = new Transform[Width, Height]; map = Generator.Instance.GenerateMap(map); while (isStart) { if (!isMoving) { Match(); } bool firstTime = true; for (int i = 0; i < map.GetLength(0); i++) { for (int j = 0; j < map.GetLength(1); j++) { if (Move(map[i, j], i, j, 10000000000f)) { if (firstTime) { isMoving = false; firstTime = false; } } else { isMoving = true; } } } } }
// Use this for initialization void Start() { // Placeholder map int xSize = 100; int ySize = 100; int roomCount = 100; int maxSize = 20; Transform[,] emptyMap = MakeEmptyMap(xSize, ySize); MapData mapData = RoomListGenerator(xSize, ySize, maxSize, roomCount, emptyMap); map = mapGenerator(mapData.roomList, mapData.map); Instantiate(floor, new Vector3(0, 0, 0), Quaternion.identity); for (int i = 0; i < xSize; i++) { for (int j = 0; j < ySize; j++) { if (map[i, j] == wall) { Instantiate(wall, new Vector3(i, 1, j), Quaternion.identity); } } } Instantiate(player, new Vector3(mapData.roomList[0].center.x, 1, mapData.roomList[0].center.y), Quaternion.identity); for (int i = 1; i < mapData.roomList.Count - 1; i++) { Instantiate(monsterGeneric, new Vector3(mapData.roomList[i].center.x, 1, mapData.roomList[i].center.y), Quaternion.identity); } }
public void Restart() { GameContext.GameOver = false; view.HideGameOverUI(); Transform[,] modelMap = model.map; for (int i = 0; i < 10; i++) { for (int j = 0; j < 18; j++) { Transform shape = modelMap[i, j]; if (shape) { Destroy(shape.gameObject); modelMap[i, j] = null; } } } if (gameManager.currentShape) { Destroy(gameManager.currentShape.gameObject); gameManager.currentShape = null; } fsm.PerformTransition(Transition.StartButtonClicked); }
public void Restart() { NowScore = 0; LoadData(); Ctrl.Instance.MainGameManager.CleanChild(); map = new Transform[max_Columns, max_Rows]; }
void Start() { grid = new Transform[mapWidth, mapHeight]; BuildGrid(); SetNeighbors(); }
private void Awake() { graph = new Transform[mapSize, mapSize]; cellNumber = new int[mapSize, mapSize]; for (int i = 0; i < mapSize; i++) { for (int j = 0; j < mapSize; j++) { GameObject instance = Instantiate(quad); instance.transform.position = new Vector2(j, i); GameObject groundInst = Instantiate(ground); groundInst.transform.position = new Vector2(j, i); graph[i, j] = instance.transform; graph[i, j].gameObject.SetActive(false); cellNumber[i, j] = cell++; } } for (int i = 0; i < randomNumSize; i++) { randomNum1 = Random.Range(0, mapSize); randomNum2 = Random.Range(0, mapSize); while (randomNum1 == tempNum1) { randomNum1 = Random.Range(0, mapSize); } while (randomNum2 == tempNum2) { randomNum2 = Random.Range(0, mapSize); } tempNum1 = randomNum1; tempNum2 = randomNum2; graph[randomNum1, randomNum2].gameObject.SetActive(true); } }
void fillStrategies() { foreach (IGunStrategy strat in GetComponentsInChildren <IGunStrategy>()) { strategies.Add(strat); strat.getGameObject().SetActive(false); } Helper.FindComponentsInChildrenWithTag <Transform>(gameObject, "barrelEnd"); List <Transform> transf = new List <Transform>(); //There we go: Add every component from generic static method into a list of transforms. This List contains the barrelEnds with which we wanna shoot. foreach (Component c in Helper.masterList) { if (c.GetType() == typeof(Transform)) { transf.Add(c.transform); } } guns = new Transform[strategies.Count, 2]; int count = 0; for (int i = 0; i < strategies.Count; i++) { for (int j = 0; j < AMOUNT_OF_GUNS; j++) { guns[i, j] = Helper.masterList[count].transform; count++; } } strategies[0].getGameObject().SetActive(true); }
void Start() { //Load prefab "Grass" from "Resources/Prefabs/" folder. tilePrefab = Resources.Load <Transform>("Prefabs/GrassTile"); //If we can't find the prefab then log a warning. if (!tilePrefab) { Debug.LogWarning("Unable to find TilePrefab in your Resources folder."); } //Initialize our 2D Transform array with the width and height map = new Transform[mapWidth, mapHeight]; //Iterate over each future tile positions for x and y for (int y = 0; y < mapHeight; y++) { for (int x = 0; x < mapWidth; x++) { //Instantiate tile prefab at the desired position as a Transform object Transform tile = Instantiate(tilePrefab, new Vector3(x * tileSize, y * tileSize, 0), Quaternion.identity) as Transform; //Set the tiles parent to the GameObject this script is attached to tile.parent = transform; //Set the 2D map array element to the current tile that we just created. map[x, y] = tile; } } BoxCollider box = gameObject.AddComponent <BoxCollider>(); box.size = new Vector3(mapWidth * tileSize, mapHeight * tileSize, 0.5f); box.center = transform.localPosition + new Vector3((mapWidth * tileSize) * 0.5f, (mapHeight * tileSize) * 0.5f, 0); }
void Awake() { digits = new bool[11][]; digits[0] = new bool[] { true, true, true, false, true, true, true }; digits[1] = new bool[] { false, false, true, false, false, false, true }; digits[2] = new bool[] { false, true, true, true, true, true, false }; digits[3] = new bool[] { false, true, true, true, false, true, true }; digits[4] = new bool[] { true, false, true, true, false, false, true }; digits[5] = new bool[] { true, true, false, true, false, true, true }; digits[6] = new bool[] { true, true, false, true, true, true, true }; digits[7] = new bool[] { false, true, true, false, false, false, true }; digits[8] = new bool[] { true, true, true, true, true, true, true }; digits[9] = new bool[] { true, true, true, true, false, true, true }; digits[10] = new bool[] { false, false, false, true, false, false, false }; digits_Lights = new Transform[digitsNumber, 7]; Transform[] all_transforms = GetComponentsInChildren <Transform>(); foreach (Transform current in all_transforms) { if (current.name == "Panel") { panel = current; } else { string[] current_tab = current.name.Split("_".ToCharArray(), 2); if (current_tab.Length == 2) { digits_Lights[int.Parse(current_tab[0]) - 1, int.Parse(current_tab[1]) - 1] = current; } } } }
//This generates our initial map for us and starts placing the terrain based on the tileset. //It also sets up our Pathfinding map "nodeMap". void LayoutMap() { boardHolder = new GameObject("Board").transform; nodeMap = new Transform[mapsizeX, mapsizeY]; for (int x = -1; x < mapsizeX + 1; x++) { for (int y = -1; y < mapsizeY + 1; y++) { GameObject toInstantiate = floorTiles[Random.Range(0, floorTiles.Length)]; if (x == -1 || x == mapsizeX || y == -1 || y == mapsizeY) { toInstantiate = boundaryTiles [Random.Range(0, boundaryTiles.Length)]; GameObject instance = Instantiate(toInstantiate, new Vector3(x, y, 1f), Quaternion.identity) as GameObject; instance.transform.SetParent(boardHolder); } else { GameObject instance = Instantiate(toInstantiate, new Vector3(x, y, 1f), Quaternion.identity) as GameObject; nodeMap [x, y] = instance.transform; instance.transform.SetParent(boardHolder); instance.transform.position = new Vector2(x, y); } } } }
public void CreateGrid() { int x = (int)GridSize.x; int y = (int)GridSize.y; int maxXZ = Mathf.Max(x, y); Camera.main.transform.position = new Vector3(maxXZ / 2f, maxXZ * Buffer, maxXZ / 8f); GridArray = new Transform[x, y]; Transform newHex; for (int i = 0; i < x; i++) { for (int j = 0; j < y; j++) { if (j % 2 == 0) newHex = (Transform)Network.Instantiate(Tile, new Vector3(i + Offset, 0, j) * Buffer, Quaternion.Euler(90, 90, 180), 0); else newHex = (Transform)Network.Instantiate(Tile, new Vector3(i, 0, j) * Buffer, Quaternion.Euler(90, 90, 180), 0); newHex.name = string.Format("({0},{1})", i, j); newHex.parent = transform; newHex.GetComponent<Tile>().Position = new Vector2(i, j); GridArray[i, j] = newHex; //nView.RPC("addList",RPCMode.AllBuffered, new object[] {nView.viewID, newHex.GetComponent<NetworkView>().viewID, i, j}); } } }
MapData RoomListGenerator(int xSize, int ySize, int maxSize, int roomCount, Transform[,] emptyMap) { List <Room> roomList = new List <Room>(); for (int i = 0; i < roomCount; i++) { Room room = new Room(); room.xSize = (int)Mathf.Floor(Random.Range(2, maxSize)); room.ySize = (int)Mathf.Floor(Random.Range(2, maxSize)); room.xCorner = (int)Mathf.Floor(Random.Range(2, xSize - maxSize)); room.yCorner = (int)Mathf.Floor(Random.Range(2, ySize - maxSize)); Transform[,] emptyMapCopy = new Transform[emptyMap.GetLength(0), emptyMap.GetLength(1)]; System.Array.Copy(emptyMap, emptyMapCopy, emptyMap.Length); emptyMap = room.MakeRoom(emptyMap); if (CompareMaps(emptyMap, emptyMapCopy)) { roomList.Add(room); } } MapData mapData = new MapData(); mapData.roomList = roomList; mapData.map = emptyMap; return(mapData); }
public void Initialize(Transform[,] _grid) { grid = _grid; width = grid.GetLength(0); height = grid.GetLength(1); fullRowCount = 0; }
// Use this for initialization void Start() { Grid = new Transform[width, width]; for (int x = 0; x < width; x++) { for (int y = 0; y < width; y++) { Transform item = Instantiate(bricks); SpriteRenderer sprite = item.GetComponent <SpriteRenderer>(); float sizeX = sprite.bounds.size.x; float xCoordinate = bricks.localPosition.x + (sizeX * (x)); float size = sprite.bounds.size.y; sprite.sprite = colors[Random.Range(0, colors.Length)]; item.localPosition = new Vector3(xCoordinate, -(bricks.localPosition.y + (size * (y))), 1); moving movingClass = item.GetComponent <moving>(); movingClass.type = sprite.sprite.name; movingClass.x = x; movingClass.y = y; item.name = sprite.sprite.name + "-" + x + "-" + y; Grid [x, y] = item; } } gridmanager.setGrid(Grid); }
public void SpawnNextTetromino() // спавнит фигуры { if (!gameStarted) // если игра только началась, создает фигуру для управления и показывает следующую фигуру { grid = new Transform[gridWidth, gridHeight]; currentScore = 0; numLineCleared = 0; gameStarted = true; previewTetromino = Instantiate(GetRandomTetromino(), previewPoint, Quaternion.identity, locationspawn); nextTetromino = Instantiate(GetRandomTetromino(), spawnPoint, Quaternion.identity, locationspawn); previewTetromino.GetComponent <Tetromino>().enabled = false; previewTetromino.GetComponent <GhostTetromino>().enabled = false; nextTetromino.GetComponent <GhostTetromino>().enabled = false; GlobalScore.Instance.Global(this, nextTetromino); nextTetromino.Initialize(this); SpawnGhostTetromino(); } else//если игра уже идет, следующую фигуру перемещает под управление игрока и показывает следующую фигуру { previewTetromino.transform.position = spawnPoint; nextTetromino = previewTetromino; nextTetromino.GetComponent <Tetromino>().enabled = true; previewTetromino = Instantiate(GetRandomTetromino(), previewPoint, Quaternion.identity, locationspawn); previewTetromino.GetComponent <Tetromino>().enabled = false; previewTetromino.GetComponent <GhostTetromino>().enabled = false; nextTetromino.GetComponent <GhostTetromino>().enabled = false; GlobalScore.Instance.Global(this, nextTetromino); nextTetromino.Initialize(this); SpawnGhostTetromino(); } }
public void Setup(GridArray <TileArrayObject> grid) { this.grid = grid; visualNodeList = new List <Transform>(); visualNodeArray = new Transform[grid.GetHeight(), grid.GetWidth()]; // Initialize for (int row = 0; row < grid.GetHeight(); row++) { for (int col = 0; col < grid.GetWidth(); col++) { Vector3 gridPosition = grid.GetWorldPosition(row, col) + 0.5f * new Vector3(grid.GetCellSize(), grid.GetCellSize()); Transform visualNode = CreateVisualNode(gridPosition); visualNodeArray[row, col] = visualNode; visualNodeList.Add(visualNode); } } UpdateVisual(grid); grid.OnGridObjectChanged += (object sender, GridArray <TileArrayObject> .OnGridObjectChangedEventArgs eventArgs) => { updateVisual = true; }; }
public void GenerateMap() { LoadMap(); //If current map is created, destroy string mapHolder = "Generated Map"; if (transform.FindChild(mapHolder)) { DestroyImmediate(transform.FindChild(mapHolder).gameObject); } //Generate new map Transform newMap = new GameObject(mapHolder).transform; newMap.parent = transform; m_tileMap = new Transform[m_currentMap.m_mapSize.m_x, m_currentMap.m_mapSize.m_y]; AssignAllTiles(); GenerateNavMeshFloor(newMap); GenerateNavMeshWalls(newMap); GenerateTiles(newMap); m_obstacleMap = new bool[m_currentMap.m_mapSize.m_x, m_currentMap.m_mapSize.m_y]; m_mapCentre = new Coord(m_currentMap.m_mapSize.m_x / 2, m_currentMap.m_mapSize.m_y / 2); m_allOpenTileCoords = new List <Coord>(m_allTileCoords); m_shuffledObstacleCoords = new Queue <Coord>(Utility.ShuffleArray(m_allTileCoords.ToArray(), m_currentMap.m_seed)); m_shuffledOpenTileCoords = new Queue <Coord>(Utility.ShuffleArray(m_allOpenTileCoords.ToArray(), m_currentMap.m_seed)); m_rand = new System.Random(m_currentMap.m_seed); GenerateObstacles(newMap); }
public FloydWarshall() { destination = GameObject.FindGameObjectWithTag("Destination").GetComponent <Transform>(); npc = GameObject.FindGameObjectsWithTag("NPC"); foreach (GameObject n in npc) { nodeList.Add(n.transform); } node = nodeList.ToArray(); minDist = new float[node.Length, npc.Length]; dest = new Transform[node.Length, npc.Length]; for (int k = 0; k < node.Length; k++) { for (int i = 0; i < npc.Length; i++) { minDist[i, k] = Vector3.Distance(node[i].position, destination.position); float dist1 = minDist[i, k]; float dist2 = Vector3.Distance(npc[i].transform.position, node[k].position) + Vector3.Distance(node[k].position, destination.position); minDist[i, k] = Mathf.Min(dist1, dist2); dest[i, k] = (minDist[i, k] == dist1) ? destination : node[k].transform; destination = dest[i, k]; destList.Add(dest[i, k]); _dest = destList.ToArray(); } } dest1 = _dest; }
void Start() { cube_grid_ = new Transform[gridHeight + 2, gridWidth + 2]; for (int r = 0; r < gridHeight + 2; ++r) { for (int c = 0; c < gridWidth + 2; ++c) { cube_grid_[r, c] = transform; } } float center_x = gridWidth * cellWidth / 2.0f; float center_y = gridHeight * cellHeight / 2.0f; // Setup the cube grid. for (int r = 1; r <= gridHeight; ++r) { for (int c = 1; c <= gridWidth; ++c) { Vector3 location = new Vector3(c * cellWidth - center_x, 0, r * cellHeight - center_y); cube_grid_[r, c] = Instantiate(model, transform.position + location, transform.rotation * model.transform.rotation) as Transform; cube_grid_[r, c].parent = transform; } } }
private void InitGrids() { // cache dimentions this.width = floorCellWidth * cellCols; this.depth = floorCellDepth * cellRows; // Init cells grid gridCells = new Cell[floorCellWidth, floorCellDepth]; // Init basic grid gridBase = new int[width, depth]; // Biome identities grid gridBiomes = new int[width, depth]; // Massives to be added to the map gridMassives = new int[width, depth]; // Angles for each massive - only the origin is marked; teh value is the angle gridAngles = new int[width, depth]; gridLock = new bool[width, depth]; // locks positions for use to prevent overlapping of massives -- true = used // used for creating borders gridBorders = new int[width, depth]; // Init final grid finalGrid = new int[width, depth]; // Init object grid gridElements = new Transform[width, depth]; }
private int m_score = 0; // 점수 (라인을 채운 횟수) private void Start() { grid = new Transform[width, height]; blocks = new Queue <SpriteRenderer>(); holdPoint.gameObject.SetActive(false); foreach (Tetromino tetromino in tetrominos) { tetromino.spawner = this; tetromino.gameObject.SetActive(false); } // 오브젝트 풀링 생성 for (int i = 0; i < 200; i++) { // 블럭 생성 SpriteRenderer renderer = GameObject.Instantiate(blockOriginal, transform).GetComponent <SpriteRenderer>(); renderer.gameObject.SetActive(false); blocks.Enqueue(renderer); } SpawnBlock(); }
// Use this for initialization void Start () { startingPoint = this.transform.position; grid = new Transform[rows,columns]; size = space.GetComponent<Renderer>().bounds.size; makeGrid(); sendGrid(); }
// Use this for initialization void Start() { gameBoard = new CubeSpaceScript[8,8]; boardPieces = new Transform[8,8]; player1 = new Player(1); player2 = new Player(2); board = GameObject.FindGameObjectWithTag ("Board").transform; turn = 1; }
public void ClearGrid() { foreach (var i in Grid){ if (i!=null){ DestroyImmediate(i.gameObject); } } s_x=s_y=0; Grid=new Transform[grid_width,grid_height]; }
void Start() { Route = new Transform[1000, 20]; onion = new bool[1000]; BusAnimationBoolGetter = GameObject.Find("RotaManager"); BusButton = GameObject.Find("SetBusButton"); anim = BusButton.GetComponent <Animator> (); //SetTextFinal = false; // Person = GameObject.Find ("Timer").GetComponent<Time> ().person; }
// Use this for initialization void Awake () { instance = this; locations = new Transform[rows, cols]; yackers = new Yacker[rows, cols]; for(int x = 0; x < rows; x++) { for(int y = 0; y < cols; y++) { locations[x,y] = transform.FindChild( x + " - " + y); } } }
// Use this for initialization void Awake () { instance = this; locations = new Transform[rows, cols]; yackers = new Yacker[rows, cols]; for(int x = 1; x <= rows; x++) { for(int y = 1; y <= cols; y++) { locations[x - 1,y - 1] = transform.FindChild( x + " - " + y); } } }
void Start() { int rows = transform.childCount; int cols = transform.GetChild (0).childCount; RawBoard = new Transform[rows, cols]; UpdateRawBoardValues (); if( TypeOfAnalysisToUse != AnalysisType.HardCodedValues) AnalyzeTerrain (); PlayerInfluence = new PlayerInfluenceMap(rows, cols, PlayerCenterInfluence, PlayerInfluenceRadius, HighGroundInfluenceBonus, RawBoard); players = GetComponent<PlayerManager> (); }
void GenerateGrid() { if (grid != null) { for (int j = 0; j < grid.GetLength(0); j++) { for (int i = 0; i < grid.GetLength(1); i++) { if (grid[j,i] != null) { Destroy(grid[j,i].gameObject); } } } } grid = new Transform[dimZ, dimX]; }
void Start() { agent = GetComponent<NavMeshAgent>(); RouteManager = GameObject.Find ("GameManager"); // Disabling auto-braking allows for continuous movement // between points (ie, the agent doesn't slow down as it // approaches a destination point). points = new Transform[1000,20]; Router = RouteManager.GetComponent<RouteManager> (); ID = Router.routeID; agent.speed = 5; money = GameObject.Find ("fad"); GotoNextPoint(); }
void Update() { board = GameObject.Find ("Level").GetComponent<TerrainManager> ().RawBoard; players = GameObject.Find ("Players").transform; if (HP <= 0) Destroy(gameObject); if (ShotCooldown > 0) ShotCooldown -=Time.deltaTime; Fire (); UpdatePosition (); }
void SetUpBoard() { board = new Transform[width, length]; for (int x = 0; x < width; x++) { for (int y = 0; y < length; y++) { Transform newSquare; newSquare = (Transform)Instantiate(squarePrefab, new Vector3 (x + xPos, y + yPos, heightPos), Quaternion.identity); newSquare.parent = transform; //puts grid as parent of gameSquare newSquare.name = sayName(newSquare); newSquare.GetComponent<TerrainTileScript>().base_energy = 10; newSquare.GetComponent<TerrainTileScript>().base_regen_rate = 1; board[x, y] = newSquare; //note that this array is x by z so layout (column, row) instead of (row, column) } } }
void createGrid() { Grid = new Transform[(int)Size.x,(int)Size.y]; for(int x = 0; x < Size.x ; x++){ for(int y = 0; y <Size.y ; y++){ Transform newCell; newCell = (Transform)Instantiate(CellPrefab, new Vector3(x,y,0), Quaternion.identity); newCell.name = "{"+x+","+y+"}"; newCell.parent = transform; newCell.GetComponent<cellscript>().position = new Vector3(x,y,0); //newCell.GetComponent<cellscript>().ball = ball; Grid[x,y] = newCell; } } }
public PlayerInfluenceMap(int length, int width, float pCenterInfluence, int pInfluenceRadius, float hGroundBonus, Transform[,] brd) { PlayerCenterInfluence = pCenterInfluence; PlayerInfluenceRadius = pInfluenceRadius; HighGroundBonus = hGroundBonus; board = brd; InfluenceMap = new float[length,width]; rawBoardValues = new float[length, width]; InitializeRawBoard (); ResetPlayerInfluenceMap (); }
void Start() { map = new Transform[mapWidth, mapHeight]; for (int y = 0; y < mapHeight; y++) { for (int x = 0; x < mapWidth; x++) { Transform tile = Instantiate(tilePrefab, new Vector3(x * tileSize, y * tileSize, 0), Quaternion.identity) as Transform; tile.parent = transform; map[x, y] = tile; } } }
// Creates the grid by instantiating provided cell prefabs. void CreateGrid() { Grid = new Transform[(int)Size.x,(int)Size.z]; // Places the cells and names them according to their coordinates in the grid. for (int x = 0; x < Size.x; x++) { for (int z = 0; z < Size.z; z++) { Transform newCell; newCell = (Transform)Instantiate(CellPrefab, new Vector3(4*x, 0, 4*z), Quaternion.identity); newCell.name = string.Format("({0},0,{1})", 4*x, 4*z); newCell.parent = transform; newCell.GetComponent<CellScript>().Position = new Vector3(4*x, 0, 4*z); Grid[x,z] = newCell; } } }
// initialization void Start () { clickType = TileType.NULL; click = false; map = new Transform[width, height]; // create array for tile objects for(int i = 0; i < width; ++i) { for(int j = 0; j < height; ++j) { // use grass prefab for tile model map[i, j] = Instantiate(prefs[3], new Vector3(i, 0, j), Quaternion.identity) as Transform; map[i, j].gameObject.AddComponent<Tile>(); map[i, j].GetComponent<Tile>().Init(this, TileType.grass); } } }
private void AnalyzeTerrain() { if (TypeOfAnalysisToUse == AnalysisType.Height) analyzer = gameObject.AddComponent<HeightAnalyzer>(); else if (TypeOfAnalysisToUse == AnalysisType.ViewDistance || TypeOfAnalysisToUse == AnalysisType.ShootingDistance) { analyzer = gameObject.AddComponent<ViewDistanceAnalyzer>(); if(TypeOfAnalysisToUse == AnalysisType.ViewDistance) GetComponent<ViewDistanceAnalyzer>().UnitViewRadius = 99999; else // shooting distance GetComponent<ViewDistanceAnalyzer>().UnitViewRadius = PlayerInfluenceRadius; } analyzer.level = RawBoard; analyzer.maxTerrainHeat = maxTerrainHeat; // must be > 0 analyzer.AnalyzeTerrain (); RawBoard = analyzer.level; DetermineEdges (); }
void CreateGrid() { Grid = new Transform[(int)Size.x,(int)Size.z]; for(int x = 0; x < Size.x; x++){ for(int z = 0; z < Size.z; z++){ Transform newCell; newCell = (Transform)Instantiate(CellPrefab, new Vector3(x, 0, z), Quaternion.identity); newCell.name = string.Format("({0},0,{1})",x,z); newCell.parent = transform; newCell.GetComponent<CellScript>().Position = new Vector3(x, 0, z); Grid[x,z] = newCell; } } Camera.mainCamera.transform.position = Grid[(int)(Size.x/2f),(int)(Size.z/2f)].position + Vector3.up*20f; Camera.mainCamera.orthographicSize = Mathf.Max(Size.x, Size.z); }
public static void initGrid(Transform instance, float densityOfAtmosphere, float heightOfAtomosphere, float gravityOfEarth, float gravityOfSun, float fixRate, float squaredAngularVelocity, int xDivision = 36, int yDivision = 36) { prefab = instance; density = densityOfAtmosphere; height = heightOfAtomosphere; gridX = xDivision; gridY = yDivision; gravity = gravityOfEarth; sunGravity = gravityOfSun; fixForce = fixRate; lastUpdate = Time.time; squaredOmega = squaredAngularVelocity; Transform earth = GameObject.Find ("Earth").transform; gridPosition = new Vector3[gridX, gridY]; gridItem = new Transform[gridX, gridY]; gridDensity = new Vector3[gridX, gridY]; for (int x = 0; x < gridX; ++x) { for (int y = 1; y < gridY; ++y){ //if (y == gridY / 2) continue; float alpha = 1.0f * x / gridX * Mathf.PI * 2.0f; float beta = 1.0f * y / gridY * Mathf.PI; gridPosition[x, y] = new Vector3(height * Mathf.Sin(beta) * Mathf.Cos(alpha), height * Mathf.Cos(beta), height * Mathf.Sin(beta) * Mathf.Sin(alpha)); gridItem[x, y] = Transform.Instantiate(prefab, gridPosition[x, y] + earth.position, Quaternion.identity) as Transform; } } }
// Creates the grid by instantiating provided cell prefabs. void CreateGrid() { Grid = new Transform[(int)Size.x,(int)Size.z]; // Places the cells and names them according to their coordinates in the grid. for (int x = 0; x < Size.x; x++) { for (int z = 0; z < Size.z; z++) { Transform newCell; newCell = (Transform)Instantiate(CellPrefab, new Vector3(x, 0, z), Quaternion.identity); newCell.name = string.Format("({0},0,{1})", x, z); newCell.parent = transform; newCell.GetComponent<CellScript>().Position = new Vector3(x, 0, z); Grid[x,z] = newCell; } } // Centers the camera on the maze. // Feel free to adjust this as needed. //Camera.main.transform.position = Grid[(int)(Size.x / 2f),(int)(Size.z / 2f)].position + Vector3.up * 20f; //Camera.main.orthographicSize = Mathf.Max(Size.x * 0.55f, Size.z * 0.5f); }
public void CreateGrid() { int x = (int)gridSize.x; int z = (int)gridSize.y; int maxXZ = Mathf.Max(x, z); topDown.transform.position = new Vector3 (maxXZ / 2f, maxXZ * buffer, maxXZ / 8f); gridArray = new Transform[x, z]; Transform newCell; for (int ix = 0; ix < x; ix++) { for (int iz = 0; iz < z; iz++) { newCell = (Transform)Instantiate(cell, new Vector3(ix, 0, iz) * buffer, Quaternion.identity); newCell.name = string.Format("({0},{1})", ix, iz); newCell.parent = transform; newCell.GetComponent<Cell>().Position = new Vector3(ix, iz); gridArray[ix, iz] = newCell; } } }
public void GenerateMaze(){ if (!mazeHolder) { mazeHolder = new GameObject (); mazeHolder.name = "mazeHolder"; } mazeComplete = false; maxStackAmount = 0; cellWidth = cellPrefab.transform.lossyScale.x; outputStack.Clear (); sortingStack.Clear (); cellGrid = new Transform[(int)gridSize.x, (int)gridSize.z]; SetupCells (); SetAdjacents (); SetDiagonals (); ApplyMazeEffect (); //put c_MazeEffect on normal for default generation SetStart (); //starts the generation process }
public void UpdateGrid() { Grid=new Transform[grid_width,grid_height]; List<Transform> list = new List<Transform>(); foreach (Transform t in transform) { list.Add(t); } int i=0; for (int y=0;y<grid_height;y++){ for (int x=0;x<grid_width;x++){ if (i<list.Count){ Grid[x,y]=list[i]; i++; } else Grid[x,y]=null; } } }