IEnumerator GenerateGrid(int columnCount) { grid.m_Column = columnCount; cellArray = new GameObject[columnCount*columnCount, columnCount*columnCount]; yield return new WaitForEndOfFrame (); for (var i = 0; i < columnCount; i++) { for(var j = 0; j < columnCount; j++) { cellArray[i,j] = (GameObject)Instantiate(cell, new Vector3(1, 1, 1), Quaternion.identity); cellArray[i,j].transform.SetParent(grid.transform); cellArray[i,j].transform.localScale = new Vector3(1, 1, 1); cellArray[i,j].name = "Cell[" + i + "][" + j + "]"; cellList.Add (cellArray[i,j]); cellHandler = cellArray[i,j].GetComponent<CellHandler> (); cellHandler.CoordX = i; cellHandler.CoordY = j; // Add color: var rand = Random.Range (0,2); if (rand == 1) { cellHandler.cellStatus = CellHandler.Status.On; cellArray[i,j].GetComponent<CanvasRenderer> ().SetColor (new Color32 (135, 204, 196, 255)); } else { cellHandler.cellStatus = CellHandler.Status.Off; cellArray[i,j].GetComponent<CanvasRenderer>().SetColor (new Color32 (128, 128, 128, 128)); } } } }
/*int GetAliveNeighbours (int _iColumn, int _iRow) { int iAliveNeighbours = 0; //nachbarn für feld 3,8 wäre column 2-4 und row 7-9 (im range 1) for (int iColumn = _iColumn -1; iColumn <= _iColumn +1; iColumn++) { for (int iRow = _iRow -1; iRow <= _iRow -1; iRow++) { if (iColumn == _iColumn && iRow == _iRow) continue; if (iColumn >= 0 && iColumn < m_iSize && iRow >= 0 && iRow < m_iSize && m_Grid[iColumn, iRow].GetComponent<Renderer>().material.color == Color.blue) //Check Range/Bounce iAliveNeighbours++; } } return iAliveNeighbours; }*/ // Use this for initialization void Start() { m_Grid = new GameObject[m_iSize, m_iSize]; for (int i = 0; i < m_iSize; i++) for (int j = 0; j < m_iSize; j++) { GameObject kachel = GameObject.CreatePrimitive(PrimitiveType.Quad); kachel.name = "Kachel(" + i + "," + j + ")"; m_Grid[i, j] = kachel; kachel.transform.position = new Vector3 (i, j, 0); kachel.transform.parent = this.transform; } Camera.main.transform.position = new Vector3 (m_iSize/2, m_iSize/2, -100); Camera.main.orthographicSize = m_iSize; transform.position = new Vector3 (0.5f, 0.5f, 0); for (int i = 0; i < m_iSize; i++) for (int j = 0; j < m_iSize; j++) { float farben = Random.value; if (farben <= 0.5) SetAlive (i, j, true);//m_Grid [i, j].GetComponent<Renderer>().material.color = Color.blue; else SetAlive (i, j, false);//m_Grid [i, j].GetComponent<Renderer>().material.color = Color.white; } print ("Anzahl Nachbarn: " + GetAliveNeighbours (1, 1)); Debug.Log (GetAliveNeighbours (9, 9)); //KillAll (); }
void Awake() { //Get size of sprite Renderer rend = (Renderer)Tile.GetComponent(typeof(Renderer)); tileSize = rend.bounds.size.x; //Debug.Log("TileSize: " + tileSize); //Create Arrays coordinates = new Vector3[4, 4]; tileGrid = new GameObject[4, 4]; //Initialize Arrays initArrays(); //Update edges BotLeft = coordinates[0, 0]; BotLeft.x -= (float)tileSize / 2; BotLeft.y -= (float)tileSize / 2; TopRight = coordinates[3, 3]; TopRight.x += (float)tileSize / 2; TopRight.y += (float)tileSize / 2; //The distance between two tile tileDistance = tileSize + margin; //Debug.Log("tileDistance: " + tileDistance); }
void CreateHexGrid() { hexes = new GameObject[gridWidthInHexes, gridHeightInHexes]; //Loop for Hex Rows for (int y = 0; y < gridHeightInHexes; y++) { //Loop for Hex Columns for (int x = 0; x < gridWidthInHexes; x++) { Vector2 gridPosition = new Vector2(x, y); //Create a clone of the supplied Hex object //GameObject hex = (GameObject)Instantiate(Hex); hexes[x, y] = (GameObject)Instantiate(hex); hexes[x, y].GetComponent<GridTile>().myGridPosition = gridPosition; //Get the current x,y of loop to place Hex | column 5, row 3, etc. //Vector2 gridPosition = new Vector2(x, y); //Center of grid is 0,0,0 figure out the pixel coordinates of this hex based on it's x,y //hex.transform.position = calculateWorldCoordinates(gridPosition); hexes[x, y].transform.position = CalculateWorldCoordinates(gridPosition); //Add the hex to the parent ojbect //hex.transform.parent = gridParent.transform; hexes[x, y].transform.parent = gridParent.transform; } } }
void Start() { boxesArray = new GameObject[100, 100]; for (int i = 0; i < 100; i++) { for (int j = 0; j < 100; j++) { GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube); boxesArray[i, j] = cube; cube.transform.position = new Vector3(i, 30, j); cube.AddComponent<BoxCollider>(); cube.name = i + " " + j; cube.layer = 8; cube.GetComponent<Renderer>().material.color = Color.gray; } } // fogOfWarColor = new Color (170, 170, 170, 1); // transparentColor = new Color (200, 200, 200, 0.5f); // // renders the objects // var renderer = GetComponent<Renderer> (); // // get the material of object // Material fogOfWarMat = null; // if (renderer != null) { // fogOfWarMat = renderer.material; // } // texture = new Texture2D (100, 100, TextureFormat.RGBA32, false); // texture.wrapMode = TextureWrapMode.Clamp; // fogOfWarMat.mainTexture = texture; }
void Awake() { towers = new GameObject[MapData.rows,MapData.columns]; for (int i = 0; i < MapData.rows; i++) for (int a = 0; a < MapData.columns; a++) towers[i, a] = null; }
// Use this for initialization void Start() { timeToAct += turnTime; airplane = new Airplane (); grid = new GameObject[numCubesX, numCubesY]; //setting airplane location airplane.x = 0; airplane.y = 8; //setting cargo info airplane.cargo = 0; airplane.cargoCapacity = 90; //spawn all the grid for (int x = 0; x < numCubesX; x++) { for (int y = 0; y < numCubesY; y++) { grid[x,y] = (GameObject) Instantiate (cubePrefab, new Vector3(x*2 - 14, y*2 - 8, 10), Quaternion.identity); grid[x,y].GetComponent<CubeBehavior>().x = x; grid[x,y].GetComponent<CubeBehavior>().y = y; } } //set airplane as red grid [0, 8].GetComponent<Renderer>().material.color = Color.red; //set depot as black grid [15, 0].GetComponent<Renderer>().material.color = Color.black; }
// Use this for initialization void Start() { Renderer tileRenderer = tileA.GetComponent<Renderer>(); tileWidth = tileRenderer.bounds.size.x; tileHeight = tileRenderer.bounds.size.y; float anchorX = anchor.transform.position.x; float anchorY = anchor.transform.position.y; Debug.Log (anchorX); Debug.Log (anchorY); tiles = new GameObject[columns, rows]; for (int i = 0; i < columns; ++i) { for (int j = 0; j < rows; j++) { float x = ((tileWidth) * i) - (anchorX / 2); float y = ((tileHeight) * j) - (anchorY / 2); if (i == 0 && j == 0) { //Debug.Log (bgX); //Debug.Log (bgY); Debug.Log (tileWidth); Debug.Log (tileHeight); //Debug.Log (x); //Debug.Log (y); } // alternating tiles var tile = tileA; if ((j % 2) == 0) { tile = tileB; } tiles[i, j] = (GameObject)Instantiate(tile, new Vector3(x, y, tileLayer), Quaternion.identity); } } }
void Start() { world = WorldControler.Instance.World; go_actor = new Dictionary<Actors.Actor, GameObject>(); if (world == null) { Debug.LogError("No world?!"); return; } go_tiles = new GameObject[world.Width, world.Hight]; System.Random rnd = new System.Random(); //Create game objets for each tile for (int x = 0; x < world.Width; x++) { for (int y = 0; y < world.Hight; y++) { GameObject tile_go = new GameObject(); tile_go.name = "Tile_" + x + "_" + y; tile_go.transform.position = new Vector3(world[x, y].X, world[x, y].Y); tile_go.transform.SetParent(this.transform, true); SpriteRenderer tile_sr = tile_go.AddComponent<SpriteRenderer>(); tile_sr.sortingLayerName = "Tiles"; go_tiles[x, y] = tile_go; SetTileSprite(x, y, tile_go, rnd); } } SetHeroSprite(); world.TileTypeChanged += w_TileTypeChange; world.ActorMoved += MoveActorSprite; }
void Start() { //Set up NodeMap xOffSet = 1-(Node.minX); yOffSet = 1-(Node.minY); nodeMap = new GameObject[(Node.maxX+xOffSet+2),(Node.maxY+yOffSet+2)]; //+2 is to create a buffer edge //Populate empty map for(int x=0;x<(nodeMap.GetLength(0));x++){ for(int y=0;y<(nodeMap.GetLength(1));y++){ nodeMap[x,y] = null; } } //Stick nodes in the map GameObject[] temp = GameObject.FindGameObjectsWithTag("Node"); for(int i=0;i<temp.Length;i++){ Node node = temp[i].GetComponent<Node>(); node.refactorX(xOffSet); node.refactorY(yOffSet); nodeMap[node.getX(),node.getY()]=temp[i]; } //Now that they're in the big map, tell them who //the neighbours are. for(int i=0;i<temp.Length;i++){ Node node = temp[i].GetComponent<Node>(); node.mapNeighbours(); } //Identify the Player. player = GameObject.FindGameObjectWithTag("Player"); //PrintDimensions(); PrintMap(); }
void Start () { BoardCreator bc = gameObject.GetComponent<BoardCreator>(); int size=bc.getBoardSize(); print(size); tileSheet = new GameObject[size,size]; }
// Use this for initialization void Start() { var arenaSize = Arena.Instance.GetArenaSize(); var gridSize = mapSize / arenaSize.y; GridMap = new GameObject[(int)arenaSize.x, (int)arenaSize.y]; // create the minimap grid squares to match arena size for(var x = 0; x < arenaSize.x; x++) { for(var y = 0; y < arenaSize.y; y++) { var sq = (GameObject)Instantiate(GridSquarePrefab); sq.transform.SetParent(transform); var rect = sq.GetComponent<RectTransform>(); rect.sizeDelta = new Vector2(gridSize, gridSize); var posx = (x * gridSize) + (x); //<-- leave a gap of 1px for every sq except the first one var posy = (y * gridSize) + (y); //<-- leave a gap of 1px for every sq except the first one sq.transform.localPosition = new Vector3(posx, posy, 0); GridMap[x,y] = sq; var info = Arena.Instance.GetGridSquare(x, y); GridContentsChanged(info); } } var myrect = GetComponent<RectTransform>(); myrect.sizeDelta = new Vector2((arenaSize.x * gridSize) + arenaSize.x, (arenaSize.y * gridSize) + arenaSize.y); myrect.localPosition = new Vector3(-myrect.sizeDelta.x / 2, myrect.localPosition.y + 16, 0); Arena.Instance.OnGridContentsChanged.AddListener(GridContentsChanged); }
public void JewelMapCreate(int[,] Map) { JewelGrib = new GameObject[GameController.WIDTH, GameController.HEIGHT]; JewelGribScript = new JewelObj[GameController.WIDTH, GameController.HEIGHT]; for (int x = 0; x < GameController.WIDTH; x++) { int s = 0; for (int y = 0; y < GameController.HEIGHT; y++) { if (GribManager.cell.GribCellObj[x, y] != null && GribManager.cell.GribCellObj[x, y].cell.CellEffect == 4) s = y; } for (int y = s; y < GameController.HEIGHT; y++) { if (Map[x, y] > 0) { RJewelInstantiate(x, y); } } } while (!Supporter.sp.isNoMoreMove()) { RemakeGrib(); JewelMapCreate(Map); } }
// Use this for initialization void Start() { m_Grid = new GameObject[m_iSize, m_iSize]; for (int i = 0; i <m_iSize; i++) for (int j = 0; j <m_iSize; j++) { GameObject kachel = GameObject.CreatePrimitive (PrimitiveType.Quad); m_Grid [i, j] = kachel; kachel.transform.position = new Vector3 (i, j, 0); kachel.transform.parent = this.transform; kachel.name = "kachel(" + i + "," + j + ")"; if (Random.value < 0.5) { kachel.GetComponent<Renderer> ().material.color = Color.black; } Camera.main.transform.position = new Vector3 (m_iSize / 2, m_iSize / 2, -10); Camera.main .orthographicSize = m_iSize; } transform.position = new Vector3 (0.5f, 0.5f, 0); int iCol = 3; int iRow = 3; print ("Anzahl Nachbarn (" + iCol + "," + iRow + "): " + GetAliveN (iCol, iRow)); }
void Start() { GameObject tempPar = new GameObject("ElasticLine"); _lineParts = new GameObject[10, 2]; for (int j = 0; j < 2; j++) { for (int i = 0; i < (int)(_elasticLengthInUnits * 0.5f * 10); i++) { GameObject temp = _lineParts[i, j]; temp.transform.parent = tempPar.transform; temp = GameObject.CreatePrimitive(PrimitiveType.Cube); if (j == 0) temp.transform.position = new Vector3(temp.transform.position.x + i,temp.transform.position.y,temp.transform.position.z); //Set these up on the left else temp.transform.position = new Vector3(temp.transform.position.x + -i,temp.transform.position.y,temp.transform.position.z); //set these up on the right. temp.AddComponent<ElasticBehaviour>(); temp.GetComponent<ElasticBehaviour>().MaxElasticLength = 2; temp.GetComponent<ElasticBehaviour>().MinElasticLength = 1; temp.AddComponent<BoxCollider>(); _lineParts[i,j] = temp; } } }
public GameObjectGrid(int rows, int columns, string id = "") { grid = new GameObject[columns, rows]; for (int x = 0; x < columns; x++) for (int y = 0; y < rows; y++) grid[x, y] = null; }
// Use this for initialization void Start() { tileViewers = new GameObject[width, height]; elementViewers = new GameObject[width, height]; GameObject mapViewer = new GameObject("MapViewer"); GameObject tiles = new GameObject("Tiles"); GameObject elements = new GameObject("Elements"); tiles.transform.parent = mapViewer.transform; elements.transform.parent = mapViewer.transform; for(int Y = 0; Y < height; Y++) { for(int X = 0; X < width; X++) { GameObject newTile = Instantiate(Resources.Load ("Tiles/Tile")) as GameObject; newTile.transform.position = new Vector3(X, -Y, 0); newTile.name = "Tile " + X + ", " + Y; newTile.transform.parent = tiles.transform; tileViewers[X,Y] = newTile; GameObject newElement = Instantiate(Resources.Load ("Tiles/Tile")) as GameObject; newElement.transform.position = new Vector3(X, -Y, -1); newElement.name = "Element " + X + ", " + Y; newElement.transform.parent = elements.transform; elementViewers[X,Y] = newElement; } } InvokeRepeating("Refresh", 0, refreshRate); }
void createCube() { cubeTileArray = new GameObject[width, height]; Vector3 size = cube.GetComponent<Renderer>().bounds.size; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { Vector3 pos = new Vector3(posX, 0, posZ); GameObject newTile = Instantiate(cube, pos, cube.transform.rotation) as GameObject; newTile.transform.SetParent(this.transform, false); cubeTileArray[x, y] = newTile; posX += size.x; } posZ += size.z; posX = 0; } }
private void initLevelData() { tileEarth = Resources.Load("Sprite_Earth") as GameObject; tileBlockade1 = Resources.Load("Blockade_1") as GameObject; tileBlockade2 = Resources.Load("Blockade_2") as GameObject; tileBlockade3 = Resources.Load("Blockade_3") as GameObject; tileStart = Resources.Load("Sprite_Player01_Start") as GameObject; tileEvent = Resources.Load("Sprite_Player02_Start") as GameObject; levelVisualisation = new GameObject[maxSizeElementsArray,maxSizeElementsArray]; try { for (int x = 0; x < 10; x++) { for (int y = 0; y <10; y++) { GameObject newtile = Instantiate(selectTile(lvlInformation[x, y]), new Vector3(x + 5, y + 5, 0) + zeroPointLevel, Quaternion.Euler(Vector3.zero)) as GameObject; levelVisualisation[x, y] = newtile; } } } catch (System.Exception e) { Debug.Log(e.Message); } }
//when player clicks on plane, make the color change/have airplane glow to show it's activated //if player clicks active plane it deactivates (changes back to red/stop glowing) //if there is no active airplane, don't do anything, no teleportation, nothing // Use this for initialization void Start() { allCubes = new GameObject[gridWidth,gridHeight]; for(int x = 0; x < gridWidth; x++) { for (int y = 0; y < gridHeight; y++){ allCubes[x,y] = (GameObject) Instantiate (Cube, new Vector3 (x*2, y*2, 0), Quaternion.identity); allCubes[x,y].GetComponent<CubeBehavior>().x = x; allCubes[x,y].GetComponent<CubeBehavior>().y = y; } print ("Cubes spawned"); //reaching into CubeBehavior script, which is tracking the plane position //uses those coordinates in cubes spawned here (in allCubes) } airplane = new Aiplane (); airplane.x = 0; airplane.y = 8; if(airplane.x == 0 && airplane.y == 8){ allCubes[airplane.x,airplane.y].GetComponent<Renderer>().material.color = Color.red; } print ("load airplane"); }
public void LoadMap() { var path = EditorUtility.OpenFilePanel("Select a Map", @"\Assets\Maps", "map"); if (path.Length == 0) return; StreamReader Mapreader = new StreamReader(path); Mapreader.ReadLine(); var htext = Mapreader.ReadLine().Split(' ')[1]; var wtext = Mapreader.ReadLine().Split(' ')[1]; Mapreader.ReadLine(); var height = Int32.Parse(htext); var width = Int32.Parse(wtext); Char[] mapline = new char[width]; Char[,] FinalMap = new char[height,width]; for (int i = 0; i < height; ++i) { mapline = Mapreader.ReadLine().ToCharArray(); for (int j = 0; j < width; ++j) { FinalMap[i, j] = mapline[j]; } } AiMap = FinalMap; DrawMap(FinalMap, GameMap = CreateGrid(tilesize, height, width)); }
// Use this for initialization public GameObject[,] createGameGrid() { grid = new GameObject[gridWidth,gridHeight]; for(int i = 0; i < gridWidth; i++) { for(int j = 0; j < gridHeight; j++) { GameObject tile = (GameObject)Instantiate(gridTile); tile.transform.position = new Vector3(i,0,j); tile.tag = "Tile"; grid[i,j] = tile; } } /* for(float i = 0.0f; i <= gridWidth*1.1f; i+=2.2f) { for(float j = 0.0f; j <= gridHeight*1.1f; j+=2.2f) { GameObject light = (GameObject)Instantiate(edgeLight); light.transform.position = new Vector3(i-0.5f,0,j-2f); } } */ GameObject light = (GameObject)Instantiate(GlobalLight); light.transform.position = light.transform.position; return grid; }
public void generateNewStage(GameObject floorTile, GameObject wallBlock, GameObject coin, GameObject player, GameObject targetSprite, GameObject door, int difficulty, int maxDifficulty) { // Grab prefabs from function call _floorTile = floorTile; _wallBlock = wallBlock; _coin = coin; _player = player; _targetSprite = Instantiate(targetSprite); _door = door; // Determine size and num coins for this stage determineParamsBasedOnDifficulty(difficulty, maxDifficulty); // Create our maze _maze = new Maze(_size, difficulty, maxDifficulty); _maze.generateMap(); // Allocate our arrays _coins = new GameObject[_numCoins]; _components = new GameObject[(int)_size.x,(int)_size.y]; // Instantiate our prefabs placeComponentsFromMap(); }
void Start() { int numQuadX = camera.pixelWidth / quadPixelSize + 1; int numQuadY = camera.pixelHeight / quadPixelSize + 1; quads = new GameObject[numQuadX + 1, numQuadY + 1]; Vector3 worldStartPosition = camera.ViewportToWorldPoint(Vector3.zero); Vector3 worldOffset = camera.ScreenToWorldPoint(new Vector3(quadPixelSize, quadPixelSize, 2)) - camera.ScreenToWorldPoint(Vector3.zero); baseScale = new Vector3(worldOffset.x + overlap, worldOffset.y + overlap, 1); for (int xi = 0; xi <= numQuadX; xi++) { for (int yi = 0; yi <= numQuadY; yi++) { Vector3 position = worldStartPosition + Vector3.Scale(worldOffset, new Vector3(xi, yi, 1)); quads[xi, yi] = (GameObject)Instantiate(screenTransitionQuad, position, Quaternion.identity); quads[xi, yi].name = "Screen Transition Quad (" + xi + ", " + yi + ")"; quads[xi, yi].transform.parent = transform; quads[xi, yi].transform.localScale = baseScale; } } time = domainMin; targetTime = domainMax; nextSceneName = ""; instance = this; isTransitioning = true; StartCoroutine(setTransitioningFalse(0.5f)); }
public void criarMapas() { Mapas = new GameObject[3, 3]; for (int cont = 0; cont < 3; cont++) { for (int cont2 = 0; cont2 < 3; cont2++) { GameObject mapa = GameObject.Instantiate(MapaPadrao) as GameObject; mapa.GetComponent<Mapa>().CriarMapa(); if(cont == 1 && cont2 == 1) { mapa.GetComponent<Mapa>().comprado = true; mapa.GetComponent<Mapa>().setComprador(true); } else { mapa.GetComponent<Mapa>().comprado = false; mapa.GetComponent<Mapa>().setComprador(false); } //mapa.GetComponent<Mapa>().Save(cont,cont2); Mapas[cont, cont2] = mapa; } } saveMapas(); destroiMapas(); load(1, 1); gerenciadorObjetosCenario.clonesEstruturaEmPosicao(); }
private void MakeMap(Map map) { mapped = new GameObject[map.map_w,map.map_h]; //Create Map for (int i=0; i<map.map_h; i++) { for (int j=0; j<map.map_w; j++) { GameObject hex; if (Misc.IsEven (j)) { hex = (GameObject)Instantiate (hexPrefab, new Vector3 (j * Config.hex_x_offset, 0, -Config.hex_h * i), Quaternion.identity); } else { hex = (GameObject)Instantiate (hexPrefab, new Vector3 (j * Config.hex_x_offset, 0, -(Config.hex_h * i) - Config.hex_y_offset), Quaternion.identity); } mapped[j,i] = hex; //put hex as child of map hex.transform.parent = this.gameObject.transform; SDL_Surface hexTex; //Draw Terrain hexTex = map.map_draw_terrain (j, i); if (map.map [j, i].g_unit != null || map.map [j, i].a_unit != null) { hexTex = map.map_draw_units (hexTex, j, i, !Engine.Air_mode, false); } hex.renderer.material = hexTex.BitmapMaterial; } } Engine.status = STATUS.STATUS_NONE; }
// Use this for initialization void Start() { _rowSelector = GameObject.Find("PuzzleGrid/RowSelector"); _currentlySelectedRow = 1; _gridVerticalSize = 4; //instantiate puzzle grid _puzzleGrid = new PuzzleNode[4,GridHorizontalSize]; //Create array of gameobjects in game where puzzle nodes are placed _anchors = new GameObject[_gridVerticalSize,GridHorizontalSize]; for (int row = 0; row < _anchors.GetLength(0); row++) { for (int col = 0; col < _anchors.GetLength(1); col++) { //find current lane's left and right anchors var currentLaneLeftAnchor = GameObject.Find("LaneAnchors/Row" + row + "/Left"); var currentLaneRightAnchor = GameObject.Find("LaneAnchors/Row" + row + "/Right"); //divide the distance of anchors by amount of anchors to determine spacing between them float rowAnchorSpacing = Vector3.Distance(currentLaneLeftAnchor.transform.position,currentLaneRightAnchor.transform.position)/GridHorizontalSize; //create new vector3 for where the current anchor will be placed var putAnchorAt = new Vector3(currentLaneLeftAnchor.transform.position.x + rowAnchorSpacing * col,0); //create game object, name it, make it's parent the parent of the rest of the row elements var currentAnchor = (GameObject) Instantiate(Resources.Load<GameObject>("Prefabs/PuzzleNode")); currentAnchor.name = row + "_" + col; currentAnchor.transform.parent = GameObject.Find("LaneAnchors/Row" + row).transform; //change it's position currentAnchor.transform.localPosition = putAnchorAt; //add game object to array _anchors[row, col] = currentAnchor; } } }
//called as constructor public void Awake() { //rows = 10; //columns = 10; entrance = new Vector2(-1, -1); exit = new Vector2(-1, -1); cases = new GameObject[columns, rows]; walls = new Wall[columns, rows]; deadends = new List<Vector2>(); visited = new bool[columns, rows]; for (int i = 0; i < columns; i++) { for (int j = 0; j < rows; j++) { visited[i, j] = false; walls[i, j] = Wall.RD; } } //Instantiate cells for (int i = 0; i < columns; i++) { for (int j = 0; j < rows; j++) { cases[i, j] = (GameObject) Instantiate(cell, new Vector3(i - 4.5f, 0f, j - 4.5f), Quaternion.identity); } } }
public void RealStart(bool[,] blockArray, int direction, int team_id, Color color) { // blockArray should be 5x5 blocks = new GameObject[5, 5]; System.Random rand = new System.Random(); string[] FileList = Directory.GetFiles(@"C:\temp2\", "*.png"); byte[] bytes; bytes = System.IO.File.ReadAllBytes(FileList[rand.Next(0, FileList.Length -1)]); for (int i = 0; i < 5; i++) { for (int j = 0; j < 5; j++) { if(blockArray[i, j]){ Vector3 newPos = transform.position + new Vector3(direction*j*block.GetComponent<Renderer>().bounds.size.x, -i*block.GetComponent<Renderer>().bounds.size.y, 0); GameObject b = (GameObject)Instantiate(block, newPos, Quaternion.identity); b.GetComponent<Mover>().MoveSpeed = direction * 1.5f; b.GetComponent<Mover>().team_id = team_id; Texture2D tex = new Texture2D(12, 12); ///while(!www.isDone) { } ///www.LoadImageIntoTexture(tex); tex.LoadImage(bytes); TextureScale.Bilinear(tex, 12, 12); Sprite sprite = Sprite.Create(tex, new Rect(0, 0, 12, 12), new Vector2(0, 0)); b.GetComponent<SpriteRenderer>().sprite = sprite; b.GetComponent<SpriteRenderer>().color = color; blocks[i, j] = b; } } } LastBlocks = BlockAmount(); }
public void Begin() { Debug.Log (text.text); string[] strs = text.text.Split ('\n'); row = strs.Length; col = strs [0].Length; mArray = new int[row, col]; for (int i=0; i<row; i++) for (int j=0; j <col ; j++) { mArray[j,row-1-i]=(int)strs[i][j]-48; // Debug.Log(i+","+j+","+strs[i][j]+","); // Debug.Log(row-1-i+","+j+","+strs[i][j]+","); } cellGameObjects=new GameObject[row,col]; for (int i=0; i<row; i++) for (int j=0; j<col; j++) { GameObject quad = GameObject.CreatePrimitive(PrimitiveType.Quad); quad.transform.position=new Vector3(i+spacing*i,j+spacing*j); cellGameObjects[i,j]=quad; } Camera.main.transform.position = new Vector3 ((row-1 + spacing * (row - 1)) / 2, (col-1 + spacing * (col - 1)) / 2,-10); Camera.main.orthographicSize = 1f+Mathf.Max ((row-1 + spacing * (row - 1)) / 2, (col-1 + spacing * (col - 1)) / 2); //GameOfLife2 (mArray); //ShowResult(); StartCoroutine (Calculate ()); }
// Use this for initialization void Start() { Grid = new GameObject[rows, columns]; BuildGrid(); }
// Use this for initialization void Start() { grid = new GameObject[width, height]; xGrid = width / 2; CreateShape(); }
// Use this for initialization void Start() { grid = new GameObject[planeSize * 2, planeSize * 2]; }
//Generating the field - solution always visible void GenerateMineField(int width, int height, int totalMines) { grid = new GameObject[width, height]; //Generating the grid RectTransform rtPanel = (RectTransform)minesweeperPanel.transform; for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { // --BUTTON CREATION-- // GameObject newButton = Instantiate(prefabButtons, minesweeperPanel.transform) as GameObject; RectTransform rtButton = (RectTransform)newButton.transform; newButton.GetComponent <RectTransform>().sizeDelta = new Vector2(rtPanel.rect.width / width, rtPanel.rect.width / width); float startingPos = minesweeperPanel.transform.localPosition.x - (rtPanel.rect.width / 2) + (rtButton.rect.width / 2); float buttonXPosition = startingPos + (rtPanel.rect.width / width * x); float buttonYPosition = startingPos + (rtPanel.rect.height / height * y); newButton.transform.localPosition = new Vector3(buttonXPosition, buttonYPosition, newButton.transform.position.z); // -- // //Grid reference grid[x, y] = newButton; grid[x, y].GetComponent <CellData>().cellType = Cell.EMPTY; grid[x, y].GetComponent <CellData>().x = x; grid[x, y].GetComponent <CellData>().y = y; Button button = newButton.GetComponent <Button>(); button.onClick.AddListener(delegate { TaskOnClick(newButton); }); } } //Creating the mines for (int index = 0; index < totalMines; index++) { int x = Random.Range(0, width - 1); int y = Random.Range(0, height - 1); GameObject mine = grid[x, y]; mine.GetComponent <CellData>().cellType = Cell.MINE; grid[x, y].GetComponentInChildren <Text>().text = "MINE"; tilesSurrounding.Add(grid[x, (y < height? y + 1 : y)]); //up tilesSurrounding.Add(grid[x, (y > 0 ? y - 1 : y)]); //down tilesSurrounding.Add(grid[(x > 0 ? x - 1 : x), y]); //left tilesSurrounding.Add(grid[(x < width ? x + 1 : x), y]); //right tilesSurrounding.Add(grid[(x > 0 && y < height ? x - 1 : x), (x > 0 && y < height ? y + 1 : y)]); //topLeft tilesSurrounding.Add(grid[(x < width && y < height ? x + 1 : x), (x < width && y < height ? y + 1 : y)]); //topRight tilesSurrounding.Add(grid[(x > 0 && y > 0 ? x - 1 : x), (x > 0 && y > 0 ? y - 1 : y)]); //bottomLeft tilesSurrounding.Add(grid[(x < width && y > 0 ? x + 1 : x), (x < width && y > 0 ? y - 1 : y)]); //bottomRight for (int index2 = 0; index2 < tilesSurrounding.Count; index2++) { if (tilesSurrounding[index2].GetComponent <CellData>().cellType != Cell.MINE) { AddEnumNumber(tilesSurrounding[index2]); } } tilesSurrounding.Clear(); } }
public void Restore() { Transform palt = transform.Find("palette"); if (palt != null) { GameObject.DestroyImmediate(palt.gameObject); } GameObject pal = new GameObject("palette"); pal.hideFlags = HideFlags.HideInHierarchy; BoxCollider bc = pal.AddComponent <BoxCollider>(); bc.size = new Vector3(palette.Count * gridsize, gridsize, 0f); bc.center = new Vector3((palette.Count - 1f) * gridsize * 0.5f, 0f, 0f); pal.transform.parent = this.gameObject.transform; pal.transform.localPosition = new Vector3(0f, -gridsize * 2, 0f); pal.transform.rotation = transform.rotation; int palette_folder = -1; for (int i = 0; i < palette.Count; i++) { UnityEngine.Object o = palette[i]; if (IsAssetAFolder(o)) { palette_folder = i; } else { if (o != null) { GameObject g = CreatePrefab(o, new Vector3(), transform.rotation); g.transform.parent = pal.transform; g.transform.localPosition = new Vector3(i * gridsize, 0f, 0f); } } } if (palette_folder != -1) { string path = AssetDatabase.GetAssetPath(palette[palette_folder].GetInstanceID()); path = path.Trim().Replace("Assets/Resources/", ""); palette.RemoveAt(palette_folder); UnityEngine.Object[] contents = (UnityEngine.Object[])Resources.LoadAll(path); foreach (UnityEngine.Object o in contents) { if (!palette.Contains(o)) { palette.Add(o); } } Restore(); } tileobs = new GameObject[width, height]; if (tiles == null) { tiles = new GameObject("tiles"); tiles.transform.parent = this.gameObject.transform; tiles.transform.localPosition = new Vector3(); } int cnt = tiles.transform.childCount; List <GameObject> trash = new List <GameObject>(); for (int i = 0; i < cnt; i++) { GameObject tile = tiles.transform.GetChild(i).gameObject; Vector3 tilepos = tile.transform.localPosition; int X = (int)(tilepos.x / gridsize); int Y = (int)(tilepos.y / gridsize); if (ValidCoords(X, Y)) { tileobs[X, Y] = tile; } else { trash.Add(tile); } } for (int i = 0; i < trash.Count; i++) { if (Application.isPlaying) { Destroy(trash[i]); } else { DestroyImmediate(trash[i]); } } if (color == null) { if (palette.Count > 0) { color = palette[0]; } } }
// Start is called before the first frame update void Start() { generateBoxes = new GameObject[GeneratePlaces.GetLength(0), GeneratePlaces.GetLength(1)]; }
// Find Match-3 Tile private ArrayList FindMatch(GameObject[,] cells) {//creating an arraylist to store the matching tiles ArrayList stack = new ArrayList(); //Checking the vertical tiles for (var x = 0; x <= cells.GetUpperBound(0); x++) { for (var y = 0; y <= cells.GetUpperBound(1); y++) { var thiscell = cells[x, y]; //If it's an empty tile continue //if (thiscell.name == "Empty(Clone)") continue; if (null == thiscell.GetComponent <PoolObject>()) { continue; } int matchCount = 0; int y2 = cells.GetUpperBound(1); int y1; //Getting the number of tiles of the same kind for (y1 = y + 1; y1 <= y2; y1++) { //if (cells[x, y1].name == "Empty(Clone)" || thiscell.name != cells[x, y1].name) break; if (cells[x, y1].GetComponent <PoolObject>() == null || thiscell.name != cells[x, y1].name) { break; } matchCount++; } //If we found more than 2 tiles close we add them in the array of matching tiles if (matchCount >= 2) { y1 = Mathf.Min(cells.GetUpperBound(1), y1 - 1); for (var y3 = y; y3 <= y1; y3++) { if (!stack.Contains(cells[x, y3])) { stack.Add(cells[x, y3]); } } } } } //Checking the horizontal tiles , in the following loops we will use the same concept as the previous ones for (var y = 0; y < cells.GetUpperBound(1) + 1; y++) { for (var x = 0; x < cells.GetUpperBound(0) + 1; x++) { var thiscell = cells[x, y]; if (thiscell.name == "Empty(Clone)") { continue; } int matchCount = 0; int x2 = cells.GetUpperBound(0); int x1; for (x1 = x + 1; x1 <= x2; x1++) { if (cells[x1, y].name == "Empty(Clone)" || thiscell.name != cells[x1, y].name) { break; } matchCount++; } if (matchCount >= 2) { x1 = Mathf.Min(cells.GetUpperBound(0), x1 - 1); for (var x3 = x; x3 <= x1; x3++) { if (!stack.Contains(cells[x3, y])) { stack.Add(cells[x3, y]); } } } } } return(stack); }
public void PlaceUnits() { UnitManager = UnitManagerGO.GetComponent <UnitManager>(); TheGrid = UnitManager.placeUnits(TheGrid, terrain_generator.map_width, terrain_generator.map_height); }
// Use this for initialization void Start() { cells = new GameObject[poleRazmer, poleRazmer]; Generate(); pointsText.text = string.Format("{0}", points); }
public void CreateTilemapMesh(GameObject[,] tiles) { CombineInstance combine = new CombineInstance(); List <CombineInstance> lush = new List <CombineInstance>(); List <CombineInstance> grass = new List <CombineInstance>(); List <CombineInstance> mud = new List <CombineInstance>(); List <CombineInstance> sand = new List <CombineInstance>(); List <CombineInstance> water = new List <CombineInstance>(); int verticesSoFar = 0; int meshListCounter = 0; //for each tile, grab their meshfilter and add according to their material type foreach (GameObject go in tiles) { Tile tile = go.GetComponent <Tile>(); tile.id = meshListCounter; //hide original tile object go.SetActive(false); MeshFilter mf = go.GetComponent <MeshFilter>(); string material = mf.GetComponent <MeshRenderer>().material.name.Replace(" (Instance)", ""); combine.mesh = mf.mesh; combine.transform = mf.transform.localToWorldMatrix; if (tile.terrainType == Terrain.Lush) { lush.Add(combine); } else if (tile.terrainType == Terrain.Grass) { grass.Add(combine); } else if (tile.terrainType == Terrain.Mud) { mud.Add(combine); } else if (tile.terrainType == Terrain.Sand) { sand.Add(combine); } else if (tile.terrainType == Terrain.Water) { water.Add(combine); } verticesSoFar += mf.mesh.vertexCount; if (verticesSoFar >= vertexLimit) { CombineMesh(lush, lushMeshPrefab, lushHolder); CombineMesh(grass, grassMeshPrefab, grassHolder); CombineMesh(mud, mudMeshPrefab, mudHolder); CombineMesh(sand, sandMeshPrefab, sandHolder); CombineMesh(water, waterMeshPrefab, waterHolder); lush.Clear(); grass.Clear(); mud.Clear(); sand.Clear(); water.Clear(); verticesSoFar = 0; meshListCounter++; } } CombineMesh(lush, lushMeshPrefab, lushHolder); CombineMesh(grass, grassMeshPrefab, grassHolder); CombineMesh(mud, mudMeshPrefab, mudHolder); CombineMesh(sand, sandMeshPrefab, sandHolder); CombineMesh(water, waterMeshPrefab, waterHolder); }
void Start() { //Distance of crystal fall distanceY = 2; //cell width colW = 1; //cell height rowH = 1; //number of rows rowLen = 8; //number of columns colLen = 8; //declarate an initial background cell cellId = 0; //Determining the grid size CrystalsList = new GameObject[rowLen, colLen]; //Prefab loader, load all cells prefabs from the Prefab/Crystals folder prefabLoader("Prefabs/UI/Cells", Cells); //Prefab loader, load all crystals prefabs from the Prefab/Crystals folder prefabLoader("Prefabs/Crystals", Crystals); //This 'for' bellow instantiate the background cells and the crystals in the canvas preventing a repetitive crystals sequence in the first turn. //There we increment lines for (int i = 0; i < rowLen; i++) { //There increment columns for (int j = 0; j < colLen; j++) { if (cellId == 0) { Instantiate(Cells[cellId], new Vector3(colW * j, rowH * i, 1), Quaternion.identity); if (j < colLen - 1) { cellId++; } } else { Instantiate(Cells[cellId], new Vector3(colW * j, rowH * i, 1), Quaternion.identity); if (j < colLen - 1) { cellId = 0; } } //This is a cristalId, this number will be cached for comparsion reasons. crystalId = Random.Range(0, 5); //The crystal is loaded and positioned in the canvas using a temporary crystalId CrystalsList[i, j] = (GameObject)Instantiate(Crystals[crystalId], new Vector3(colW * j, rowH * i + distanceY, 0), Quaternion.identity); if (j > 1) { //After the second iteration starts a test if exists two left crystals with a same name, never before this iteration because we whould get an 'Out of Bounds Error' in Array. if (CrystalsList[i, j].name == CrystalsList[i, j - 1].name && CrystalsList[i, j].name == CrystalsList[i, j - 2].name) { //If the gameobjects have the same name the gameoobject will be destroyed, the crystalId will be changed and a new crystal will be loaded. Destroy(CrystalsList[i, j]); crystalId = (crystalId == 0 ? crystalId = Crystals.Count - 1 : crystalId - 1); CrystalsList[i, j] = (GameObject)Instantiate(Crystals[crystalId], new Vector3(colW * j, rowH * i + distanceY, 0), Quaternion.identity); } } //Now, after the second line interation, we need find the repeated crystals vertically if (i > 1) { if (CrystalsList[i, j].name == CrystalsList[i - 1, j].name && CrystalsList[i, j].name == CrystalsList[i - 2, j].name) { Destroy(CrystalsList[i, j]); //No chance to sort a same crystal that was destroyed before because I walk in the list step by step from the end to the beginning. Certally, in this case, the destroyed crystal had another index. crystalId = (crystalId == 0 ? crystalId = Crystals.Count - 1 : crystalId - 1); CrystalsList[i, j] = (GameObject)Instantiate(Crystals[crystalId], new Vector3(colW * j, rowH * i + distanceY, 0), Quaternion.identity); } } } } }
// Use this for initialization void Start() { board = new GameObject[boardDimensions, boardDimensions]; }
//temp public void ActivateAroundTile(GameObject[,] grid, int range, Vector2Int start) { //get origin var origin = grid[start.x, start.y]; float[,] g = new float[gridSize, gridSize]; for (var x = 0; x < gridSize; x++) { for (var y = 0; y < gridSize; y++) { g[x, y] = Mathf.Infinity; } } g[start.x, start.y] = 0; //a star get range List <GameObject> closed = new List <GameObject>(); PriorityQueue <GameObject> open = new PriorityQueue <GameObject>(); open.Clear(); open.Add(origin, 0); //for (var t = 0; t < range; t++) { while (open.Count > 0) { float currentTileG = open.GetPriorityMin(); var currentTile = open.GetElementPriorityMin(); open.Sort(); open.Remove(open.GetElementPriorityMin()); closed.Add(currentTile); //Handle neighbors for (var i = 0; i < 4; i++) { var neighbor = GetNeighbor(grid, currentTile, i); if (neighbor == null) { continue; } //check if it's in closed if (closed.Contains(neighbor)) { continue; } float tentativeG = currentTileG + 1; //can add terrain costs here //attack tiles could be handled here if (tentativeG > range) { continue; } //if neighbor is not in open, add to open queue if (!open.Contains(neighbor)) { open.Add(neighbor, tentativeG); } else if (tentativeG >= currentTileG) { continue; } open.SetPriority(neighbor, tentativeG); Vector2Int neighborPos = GetTilePosition(neighbor); g[neighborPos.x, neighborPos.y] = tentativeG; } } } //activate for (var x = 0; x < gridSize; x++) { for (var y = 0; y < gridSize; y++) { if (g[x, y] <= range) { ActivateTile(grid[x, y]); } } } }
public GameObjectGrid(int rows, int columns, int layer = 0, string id = "") : base(layer, id) { grid = new GameObject[columns, rows]; }
// Use this for initialization void Start() { n = 5; //n x n grid grid = new GameObject[n, n]; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { int whichPrefab = 0; //boring spots int diff = Mathf.Abs(i - j); if ((diff == 0 || diff == n - 1) && (i == 0 || i == n - 1)) //corners { whichPrefab = 3; } else if (diff == 1 && (i == n / 2 || j == n / 2)) //plus sign not center { whichPrefab = 1; } else if (((diff == 1 || diff == n - 2) && (i <= 1 || i == n - 1 || i == n - 2)) || (diff == 1 || diff == n - 2) && (j <= 1 || j == n - 1 || j == n - 2)) //surrounding corners { whichPrefab = 2; } else if (i == n / 2 && j == n / 2) //mid { whichPrefab = 4; } Vector3 pos = new Vector3(transform.position.x + 1.1f * j * transform.localScale.x - 0.5f, transform.position.y - 1.1f * i * transform.localScale.y, zDist); // Quaternion rot = Quaternion.AngleAxis (180f, transform.up); grid[i, j] = (GameObject)Instantiate(cellPrefabs[whichPrefab], pos, transform.rotation); cellBehavior cellScript = grid [i, j].GetComponent <cellBehavior> (); cellScript.Init(); cellScript.i = i; cellScript.j = j; } } currPlayer = 0; foreach (playerBehavior playerScript in players) { playerScript.grid = grid; } score = new int[players.Length]; for (int i = 0; i < score.Length; i++) { score [i] = 0; } tutorialMode = tutorials.Length > 0; currTut = 0; tutModeFin = false; needNewTut = true; origScoreColor = new Color[2]; origScoreColor [0] = textFields [0].GetComponent <Text> ().color; origScoreColor [1] = textFields [1].GetComponent <Text> ().color; origTurnLightColors = new Color[2]; origTurnLightColors [0] = turnLights [0].GetComponent <Light> ().color; origTurnLightColors [1] = turnLights [1].GetComponent <Light> ().color; turnLights [1].GetComponent <Light> ().color = Color.black; endSpriteSoundPlaying = false; showHomeButtonTimer = 0f; showHomeButtonWaitTime = 1f; }
public void InitSwap(Board board, Tile[,] tiles, Drop[,] drops, int width, int height, GameObject[,] dropsGameObjects) { _board = board; _width = width; _height = height; _dropsGameObjects = dropsGameObjects; _activatedTilesForSwapping = new List <Tile>(); _tiles = tiles; _drops = drops; }
//ステージ初期化 void initStage() { GameObject currentScene = ApplicationManagerController.Instance.currentSceneManager; this.sceneManager = currentScene.GetComponent <GameSceneManager>(); //ステージデータ読み込み string stageName = "Map/Stage" + this.app.playingStageNumber; this.panelData = new MapReader(stageName + "_panel"); this.itemData = new MapReader(stageName + "_item"); //ステージパネルデータ配列 this.stageMap = new GameObject[this.stageWidth, this.stageHeight]; //パネルの準備 for (int y = 0; y < this.stageHeight; y++) { for (int x = 0; x < this.stageWidth; x++) { float delay = Random.Range(0.0f, 1.0f); int idx = this.panelData.mapData[x, y]; GameObject p = this.enterPanel(idx, x, y); //落下演出 Vector3 pos = p.transform.position; pos.y += 10.0f; p.transform.position = pos; p.transform.DOLocalMove(new Vector3(0, -10.0f, 0.0f), 1.0f) .SetEase(Ease.OutBounce) .SetDelay(delay) .SetRelative(); PanelController pc = p.GetComponent <PanelController>(); //初期アイテムセットとパネル設定 int id = this.itemData.mapData[x, y]; switch (id) { case 0: break; case 1: case 2: this.enterItem(id, x, y, 3.0f); pc.isOnItem = true; break; //スタートパネル case 8: this.startX = x; this.startY = y; pc.isStart = true; pc.isDisableMove = true; break; //ゴールパネル case 9: this.goalX = x; this.goalY = y; pc.isStart = true; pc.isDisableMove = true; break; } if (this.itemData.mapData[x, y] != 0) { pc.isDisableShaffle = true; } this.stageMap[x, y] = p; } } //パネルシャッフル for (int i = 0; i < 20; i++) { int x1 = Random.Range(0, 5), y1 = Random.Range(0, 5); int x2 = Random.Range(0, 5), y2 = Random.Range(0, 5); this.swapPanel(x1, y1, x2, y2); } this.transform.parent.gameObject.SendMessage("OnAlreadyStartView"); //ゴールパネル標識 GameObject canvasText = Instantiate((GameObject)Resources.Load("Prefabs/GoalText")); canvasText.transform.SetParent(this.transform); canvasText.transform.position = new Vector3(this.goalX + 0.5f, 5.0f, -5.0f); DOVirtual.DelayedCall(2.0f, () => { canvasText.transform.DOMove(new Vector3(this.goalX + 0.5f, -this.goalY + 0.5f, -5.0f), 2.0f) .SetEase(Ease.OutBounce); Destroy(canvasText, 7.0f); }); //早送りボタン GameObject ffb = Instantiate((GameObject)Resources.Load("Prefabs/FFButton")); ffb.transform.SetParent(this.transform); ffb.transform.position = new Vector3(2.5f, -6.5f, -5.0f); }
// Start is called before the first frame update void Start() { //load savedata data = GameController.Instance.data; data.Load(); tiles = new int[mapSizeX, mapSizeY]; for (int x = 0; x < mapSizeX; x++) { for (int y = 0; y < mapSizeY; y++) { tiles[x, y] = 0; } } //initialize as all 0 units units = new Character[mapSizeX, mapSizeY]; for (int i = 0; i < mapSizeX; i++) { for (int j = 0; j < mapSizeY; j++) { units[i, j] = new Character(Alignment.Terrain, "", 0, 0, 0, 0, 0, 0); } } if (SceneManager.GetActiveScene().name == "Tutorial") { //set unit type 1 //units[0, 0] = data.characters.Find(c => c.name == "Phos"); //human units[2, 1] = data.characters.Find(c => c.name == "Tisiphone"); //elf sister //units[3, 5] = data.characters.Find(c => c.name == "Sisyphus"); //elf brother //units[4,0] = data.characters.Find(c => c.name == "Iphi"); //dwarf //units[6,0] = data.characters.Find(c => c.name == "Dartfoot"); //halfling //set enemy type 2 units[2, 4] = new Character(Alignment.Enemy, "Sisyphus", 3, 3, 1, 0, 2, 2); //elf king //units[5, 7] = new Character(Alignment.Enemy, "Gorb", 2, 2, 2, 0, 2, 1); //goblin //units[3, 7] = new Character(Alignment.Enemy, "Gorb", 2, 2, 2, 0, 2, 1); //goblin //units[1, 7] = new Character(Alignment.Enemy, "Gorb", 2, 2, 2, 0, 2, 1); //goblin } if (SceneManager.GetActiveScene().name == "Fellowship") { //set unit type 1 //units[0, 0] = data.characters.Find(c => c.name == "Phos"); //human units[1, 1] = data.characters.Find(c => c.name == "Tisiphone"); //elf sister //units[3, 5] = data.characters.Find(c => c.name == "Sisyphus"); //elf brother //units[4,0] = data.characters.Find(c => c.name == "Iphi"); //dwarf //units[6,0] = data.characters.Find(c => c.name == "Dartfoot"); //halfling //set enemy type 2 //units[2, 4] = new Character(Alignment.Enemy, "Sisyphus", 3, 3, 1, 0, 2, 2); //elf king units[4, 6] = new Character(Alignment.Enemy, "Gurd", 4, 4, 3, 0, 2, 1); //goblin units[2, 6] = new Character(Alignment.Enemy, "Gorb", 4, 4, 2, 1, 2, 1); //goblin units[3, 7] = new Character(Alignment.Enemy, "Garb", 6, 6, 2, 0, 2, 1); //goblin //tiles[0, 2] = 1; //tiles[1, 3] = 1; //tiles[4, 3] = 1; //tiles[5, 3] = 1; //tiles[6, 3] = 1; } unitObjects = new GameObject[mapSizeX, mapSizeY]; tileObjects = new GameObject[mapSizeX, mapSizeY]; GenerateMap(); GenerateCharacters(); }
private void Start() { // if (this.baseTile == null && this.pathTile) // return; // if (tiles != null) // foreach (var tile in tiles) // if (tile != null) // UnityEditor.EditorApplication.delayCall += () => StartCoroutine(destroyObject(tile)); MapGenerator mapGenerator = new MapGenerator(Random.Range(0, 99999999)); mapGenerator.GenerateMap(mapSize, mapLength, false, 0.0f, 0.3f); char[, ] result = mapGenerator.Display(); int dim = (int)result.GetLength(0); tiles = new GameObject[dim, dim]; for (int x = 0; x < dim; x++) { for (int y = 0; y < dim; y++) { GameObject toInstantiate; Quaternion quaternion = Quaternion.identity; switch (mapGenerator.GetTile(x, y)) { case TileType.EmptySpace: toInstantiate = baseTile; break; case TileType.Decor: toInstantiate = baseTile; break; case TileType.Decor2: toInstantiate = baseTile; break; case TileType.ElbowLeftDown: case TileType.ElbowLeftUp: case TileType.ElbowRightDown: case TileType.ElbowRightUp: toInstantiate = cornerTile; break; case TileType.HorizPath: toInstantiate = pathTile; break; case TileType.VertPath: quaternion = Quaternion.Euler(0, 90, 0); toInstantiate = pathTile; break; default: toInstantiate = baseTile; break; } GameObject tile = (GameObject)Instantiate(toInstantiate, buildPos + new Vector3(-x * 4, 0, y * 4), quaternion, parent.transform); tiles[x, y] = tile; } } }
void Start() { // Position the camera float tempZ = Camera.main.transform.position.z; Camera.main.transform.position = new Vector3((mapWidth - 1) / 2.0f, (mapHeight) / 2.0f, tempZ); tileArray = new GameObject[mapWidth, mapHeight]; spriteArray = new SpriteRenderer[mapWidth, mapHeight]; tileLayerMask = LayerMask.GetMask("Tile"); lineRenderer = GetComponent <LineRenderer>(); lineRenderer.enabled = false; turnChangeCanvas.SetActive(true); // Generate the map for (int i = 0; i < mapWidth; i++) { for (int j = 0; j < mapHeight; j++) { Vector3 pos = new Vector3(i, j, 0); tileArray[i, j] = (GameObject)Instantiate(tile, pos, Quaternion.identity); spriteArray[i, j] = tileArray[i, j].GetComponent <SpriteRenderer>(); } } TileDirection tileDir = TileDirection.UpToLeft; // By default, make borders on the grid for (int i = 1; i < mapWidth - 1; i++) { GameObject go = (GameObject)Instantiate(bounceTile, new Vector3(i, 0), Quaternion.identity); go.GetComponent <BounceTile>().setDirection(tileDir); go.GetComponent <BounceTile>().destructible = false; bounceTiles.Add(go); tileDir = (TileDirection)(((int)tileDir + 1) % 2); // switch tiledir to get a zigzag go = (GameObject)Instantiate(bounceTile, new Vector3(i, mapHeight - 1), Quaternion.identity); go.GetComponent <BounceTile>().setDirection(tileDir); go.GetComponent <BounceTile>().destructible = false; bounceTiles.Add(go); } for (int i = 1; i < mapHeight - 1; i++) { GameObject go = (GameObject)Instantiate(bounceTile, new Vector3(0, i), Quaternion.identity); go.GetComponent <BounceTile>().setDirection(tileDir); go.GetComponent <BounceTile>().destructible = false; bounceTiles.Add(go); tileDir = (TileDirection)(((int)tileDir + 1) % 2); // switch tiledir to get a zigzag go = (GameObject)Instantiate(bounceTile, new Vector3(mapWidth - 1, i), Quaternion.identity); go.GetComponent <BounceTile>().setDirection(tileDir); go.GetComponent <BounceTile>().destructible = false; bounceTiles.Add(go); } // Corners GameObject go2 = (GameObject)Instantiate(bounceTile, new Vector3(0, 0), Quaternion.identity); go2.GetComponent <BounceTile>().setDirection(TileDirection.UpToLeft); go2.GetComponent <BounceTile>().destructible = false; bounceTiles.Add(go2); go2 = (GameObject)Instantiate(bounceTile, new Vector3(0, mapHeight - 1), Quaternion.identity); go2.GetComponent <BounceTile>().setDirection(TileDirection.UpToRight); go2.GetComponent <BounceTile>().destructible = false; bounceTiles.Add(go2); go2 = (GameObject)Instantiate(bounceTile, new Vector3(mapWidth - 1, 0), Quaternion.identity); go2.GetComponent <BounceTile>().setDirection(TileDirection.UpToRight); go2.GetComponent <BounceTile>().destructible = false; bounceTiles.Add(go2); go2 = (GameObject)Instantiate(bounceTile, new Vector3(mapWidth - 1, mapHeight - 1), Quaternion.identity); go2.GetComponent <BounceTile>().setDirection(TileDirection.UpToLeft); go2.GetComponent <BounceTile>().destructible = false; bounceTiles.Add(go2); // Place bounce tiles according to custom position array for (int i = 0; i < bounceTilePos.Length; i++) { // we use the z component to determine the type of bounce tile // janky, or efficient? who knows? TileDirection dir = (TileDirection)bounceTilePos[i].z; bounceTilePos[i].z = 0; buildBounceTile(bounceTilePos[i], dir); //tileArray[(int)bounceTilePos[i].x, (int)bounceTilePos[i].y] = go; spawnedTerrains++; } Invoke("NextTurn", turnChangeDuration); }
private void SpawnTiles() { mapTiles = new GameObject[mapSize, mapSize]; for (int i = 0; i < mapSize; i++) { for (int j = 0; j < mapSize; j++) { if (map[i, j] != (int)Tiles.none) { Vector3 angle = new Vector3(0, 0, 0); //Debug.Log(map[i, j]); if (map[i, j] == (int)Tiles.end || map[i, j] == (int)Tiles.spawn) { if ((int)i - 1 >= 0 && map[i - 1, j] != (int)Tiles.border && map[i - 1, j] != (int)Tiles.none) { angle = new Vector3(0, -90f, 0); } if (i + 1 < mapSize && map[i + 1, j] != (int)Tiles.border && map[i + 1, j] != (int)Tiles.none) { angle = new Vector3(0, 90f, 0); } if (j - 1 >= 0 && map[i, j - 1] != (int)Tiles.border && map[i, j - 1] != (int)Tiles.none) { angle = new Vector3(0, 180f, 0); } } else { angle = new Vector3(0, Random.Range(0, 5) * 90f, 0); } GameObject tile = Instantiate(tiles[map[i, j]], new Vector3( tiles[(int)Tiles.basic].transform.localScale.x * i, 0, tiles[(int)Tiles.basic].transform.localScale.z * j), Quaternion.Euler(angle)); tile.transform.SetParent(this.transform); tile.name = (((Tiles)map[i, j]).ToString()); mapTiles[i, j] = tile; if (map[i, j] == (int)Tiles.spawn) { spawnObject = tile; } if (map[i, j] == (int)Tiles.end) { endObject = tile; } } } } endPointNeighbours = new List <GameObject>(); for (int i = endPoint.x - 10; i <= endPoint.x + 10; i++) { for (int j = endPoint.y - 10; j <= endPoint.y + 10; j++) { if (i >= 0 && i < mapSize && j >= 0 && j < mapSize) { if (map[i, j] == (int)Tiles.border) { endPointNeighbours.Add(mapTiles[i, j]); } } } } }
public void generateLevel(string seed) { // string seed = "112433abcc120b474d189a6979247624"; Random.InitState(seed.GetHashCode()); map = new GameObject[levelYSize, levelXSize]; for (int ii = 0; ii < levelYSize; ii++) { int[] tilesLocationsCoordX = NumberSpread(Random.Range((int)(levelXSize * minRowFill), levelXSize), levelXSize); foreach (int locationX in tilesLocationsCoordX) { GameObject obj = Instantiate(levelObj, environment); obj.name = "Tile " + locationX + ", " + ii; map[ii, locationX] = obj; obj.transform.position = new Vector3(locationX * squaredOffset, 0, ii * squaredOffset); Tile tile = obj.GetComponent <Tile>(); tile.Position = new Vector2Int(locationX, ii); } } for (int iii = 0; iii < smoothingPasses; iii++) { int c = 0; for (int i = 0; i < levelYSize; i++) { for (int ii = 0; ii < levelXSize; ii++) { if (map[i, ii] == null) { continue; } int totalNeighbouringTiles = 0; Vector2Int pos = new Vector2Int(ii, i); foreach (Vector2Int neighbourTile in neighbouringTiles) { Vector2Int checkPos = pos + neighbourTile; if (checkPos.x < 0 || checkPos.y < 0 || checkPos.x >= levelXSize || checkPos.y >= levelYSize) { continue; } bool tileExists = map[checkPos.y, checkPos.x] != null; totalNeighbouringTiles += tileExists ? 1 : 0; map[i, ii].GetComponent <Tile>().setDirectionTile(neighbourTile, tileExists); } if (totalNeighbouringTiles <= smoothIntensity) { c++; Destroy(map[i, ii]); map[i, ii] = null; } } } } Vector3 max = Vector3.zero; Vector3 min = Vector3.zero; for (int i = 0; i < levelYSize; i++) { for (int ii = 0; ii < levelXSize; ii++) { GameObject obj = map[i, ii]; if (obj != null) { spawnLocations.Add(obj.transform.position + new Vector3(0, 5, 0)); if (Random.value > 1.0f - barrelSpawnProbability) { // Put a barrel in the middle of the tile. GameObject barrel = Instantiate(sciFiBarrel, environment); barrel.transform.position = new Vector3(obj.transform.position.x, -0.7f, obj.transform.position.z); barrel.transform.Translate(Random.insideUnitCircle * squaredOffset * new Vector3(1, 0, 1)); } if (obj.transform.position.z > max.z) { max.z = obj.transform.position.z; } if (obj.transform.position.z < min.z) { min.z = obj.transform.position.z; } } } } Vector3 cameraMove = (max - min) / 2; mainCamera.transform.position = cameraMove - new Vector3(12.5F, -22, 0); }
void Start() { grid = new GameObject[gridSize, gridSize]; }
void Start() { //1.起点 //2.终点 //3.障碍 //4.道具(必走) //构建数字地图 //通过代码生成,这里手动生成。 //这里的11和6对应地图的宽度和高度 numberMap = new int[11, 6] { { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0 }, { 0, 3, 4, 0, 3, 0 }, { 0, 3, 0, 0, 3, 0 }, { 0, 3, 3, 3, 3, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 2, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0, 0 } }; int mapWidth = 11; int mapHeight = 6; map = new GameObject[mapWidth, mapHeight]; Transform mapBG = GameObject.Find("Map").transform; Color[] colors = new Color[5] { Color.white, Color.green, Color.red, Color.blue, Color.gray }; for (int i = 0; i < mapWidth; i++) { for (int j = 0; j < mapHeight; j++) { GameObject temp = Instantiate(MapTiled, mapBG); temp.transform.localPosition = new Vector3(i, j, 0); temp.GetComponent <SpriteRenderer>().color = colors[numberMap[i, j]]; map[i, j] = temp; } } for (int i = 0; i < mapWidth; i++) { for (int j = 0; j < mapHeight; j++) { GameObject temp = Instantiate(MapTiled, mapBG); temp.transform.localPosition = new Vector3(i, j, 0); temp.GetComponent <SpriteRenderer>().color = colors[numberMap[i, j]]; map[i, j] = temp; } } BFSTest(); DFSTest(); }
void CreateGrid() { positions = new Vector3[gridWidth, gridHeigth]; testGrid = new GameObject[gridWidth, gridHeigth]; //CALCULATE CENTER OFFSET //float centerOffsetX = ((gridWidth * gridHeigth)/4 * tileWidth )/ 2; float centerOffsetX = 10; float centerOffsetY = 0; //CREATE GRID ITSELF for (int x = 0; x < gridWidth; x++) { for (int y = 0; y < gridHeigth; y++) { positions[x, y] = new Vector3(transform.position.x - centerOffsetX + (tileWidth * x) + (tileWidth * y), transform.position.y - centerOffsetY + (tileHeight * x) - (tileHeight * y), 0); } } //"REMOVE" CORNER POSITIONS rockFolder = Instantiate(new GameObject(), transform.position, transform.rotation); rockFolder.name = "Rock Folder"; if (roundCorners) { for (int i1 = 0; i1 < roundCornerBy; i1++) { for (int i2 = 0; i2 < roundCornerBy; i2++) { if (!(i1 == i2 && i1 == roundCornerBy - 1) || (i1 == 0 && i2 == 0)) { positions[i1, i2] = new Vector3(positions[i1, i2].x, positions[i1, i2].y, 2); PlaceRockToPlace(positions[i1, i2], new Vector2(i1, i2)); positions[i1, positions.GetLength(1) - 1 - i2] = new Vector3(positions[i1, positions.GetLength(1) - 1 - i2].x, positions[i1, positions.GetLength(1) - 1 - i2].y, 2); PlaceRockToPlace(positions[i1, positions.GetLength(1) - 1 - i2], new Vector2(i1, positions.GetLength(1) - 1 - i2)); positions[positions.GetLength(0) - 1 - i1, i2] = new Vector3(positions[positions.GetLength(0) - 1 - i1, i2].x, positions[positions.GetLength(0) - 1 - i1, i2].y, 2); PlaceRockToPlace(positions[positions.GetLength(0) - 1 - i1, i2], new Vector2(positions.GetLength(0) - 1 - i1, i2)); positions[positions.GetLength(0) - 1 - i1, positions.GetLength(1) - 1 - i2] = new Vector3(positions[positions.GetLength(0) - 1 - i1, positions.GetLength(1) - 1 - i2].x, positions[positions.GetLength(0) - 1 - i1, positions.GetLength(1) - 1 - i2].y, 2); PlaceRockToPlace(positions[positions.GetLength(0) - 1 - i1, positions.GetLength(1) - 1 - i2], new Vector2(positions.GetLength(0) - 1 - i1, positions.GetLength(1) - 1 - i2)); } } } } //CREATE TEST GRID testGridFolder = Instantiate(new GameObject(), Vector3.zero, transform.rotation); testGridFolder.name = "Test Grid"; for (int x = 0; x < gridWidth; x++) { for (int y = 0; y < gridHeigth; y++) { if (positions[x, y].z == 3) { testGrid[x, y] = null; } else { Vector3 newPos = new Vector3(positions[x, y].x, positions[x, y].y, transform.position.z); testGrid[x, y] = Instantiate(emptyPre, newPos, Quaternion.identity); testGrid[x, y].transform.parent = testGridFolder.transform; testGrid[x, y].name = x + " , " + y; //testGrid[x, y].transform.localScale = new Vector3(tileWidth * 0.35f, (tileHeight * 2) * 0.35f, testGrid[x, y].transform.localScale.z); } } } //PLACE SURRONDING ROCKS //Place on top width alinged lines for (int rowNo = 0; rowNo < borderHeight; rowNo++) { for (int i = 0; i < gridWidth; i++) { if (!(positions[i, rowNo].z == 2)) { PlaceRockToPlace(new Vector3(positions[i, rowNo].x, positions[i, rowNo].y, transform.position.z), new Vector2(i, rowNo)); } } } //Place on right height alinged lines for (int rowNo = 0; rowNo < borderWidth; rowNo++) { for (int i = 0; i < gridHeigth; i++) { if (!(positions[rowNo, i].z == 2)) { PlaceRockToPlace(new Vector3(positions[rowNo, i].x, positions[rowNo, i].y, transform.position.z), new Vector2(rowNo, i)); } } } //Place on left height alinged lines for (int rowNo = gridWidth - 1; rowNo > (gridWidth - borderWidth - 1); rowNo--) { for (int i = 0; i < gridHeigth; i++) { if (!(positions[rowNo, i].z == 2)) { PlaceRockToPlace(new Vector3(positions[rowNo, i].x, positions[rowNo, i].y, transform.position.z), new Vector2(rowNo, i)); } } } //Place on bottom width alinged lines for (int rowNo = gridHeigth - 1; rowNo > (gridHeigth - borderHeight - 1); rowNo--) { for (int i = 0; i < gridWidth; i++) { if (!(positions[i, rowNo].z == 2)) { PlaceRockToPlace(new Vector3(positions[i, rowNo].x, positions[i, rowNo].y, transform.position.z), new Vector2(i, rowNo)); } } } List <Vector2> temp = new List <Vector2>() { new Vector2(gridWidth / 2, gridHeigth / 2), new Vector2(gridWidth / 2 + 1, gridHeigth / 2), new Vector2(gridWidth / 2, gridHeigth / 2 + 1), new Vector2(gridWidth / 2 + 1, gridHeigth / 2 + 1) }; SpawnStructure(mysticPlace, temp, new Vector2(2, 2)); SetTestGridActive(false); RandomGen(); PlaceGrass(); gridDone = true; }
public GameObject(GameObject[,] map, Point location, bool isEnemy) : this(map, location, isEnemy, Textures.Floor) { }
public void setGridArray(GameObject[,] gridarray) { gridArray = gridarray; }
private void Draw(ref List <ItemObject> content, int height = 4, int width = 6) { Generator.GetComponent <Generator>().MenuOpened = true; Height = height; Width = width; Items = new GameObject[Height, Width]; for (int y = 0; y < Height; ++y) { for (int x = 0; x < Width; ++x) { int Xpos = 0, Ypos = 0; if (Width % 2 == 1) { Xpos = 100 * (x - Width / 2); } else { Xpos = 50 + 100 * (x - Width / 2); } if (Height % 2 == 1) { Ypos = 100 * ((Height - y - 1) - Height / 2); } else { Ypos = 50 + 100 * ((Height - y - 1) - Height / 2); } Items[y, x] = Instantiate(InventoryCellPrefab, transform.position, Quaternion.identity); Items[y, x].transform.SetParent(transform); Items[y, x].GetComponent <RectTransform>().anchoredPosition = new Vector2(Xpos, Ypos); Items[y, x].GetComponent <RectTransform>().localScale = SampleB.GetComponent <RectTransform>().localScale; if (y == 0) { if (x == 0) { Items[y, x].GetComponent <Image>().sprite = MenuCellSprite[0]; } else if (x == Width - 1) { Items[y, x].GetComponent <Image>().sprite = MenuCellSprite[2]; GameObject CI = Instantiate(CloseInventory, transform.position, Quaternion.identity); CI.transform.SetParent(Items[y, x].transform); CI.GetComponent <RectTransform>().anchoredPosition = new Vector2(32F, 32F); CI.GetComponent <RectTransform>().localScale = SampleB.GetComponent <RectTransform>().localScale; Generator.GetComponent <Generator>().SetCloseButton(CI); } else { Items[y, x].GetComponent <Image>().sprite = MenuCellSprite[1]; } } else if (y == Height - 1) { if (x == 0) { Items[y, x].GetComponent <Image>().sprite = MenuCellSprite[6]; } else if (x == Width - 1) { Items[y, x].GetComponent <Image>().sprite = MenuCellSprite[8]; } else { Items[y, x].GetComponent <Image>().sprite = MenuCellSprite[7]; } } else { if (x == 0) { Items[y, x].GetComponent <Image>().sprite = MenuCellSprite[3]; } else if (x == Width - 1) { Items[y, x].GetComponent <Image>().sprite = MenuCellSprite[5]; } else { Items[y, x].GetComponent <Image>().sprite = MenuCellSprite[4]; } } } } for (int i = 0; i < Mathf.Min(Width * Height, content.Count); ++i) { Items[i / Width, i % Width].GetComponent <InventoryCell>().Content = content[i]; } }
public void ActivateFrontierTiles(GameObject[,] referenceGrid, GameObject[,] attackGrid, int moveRange)//, int attackRange) { //if (attackRange < 1) // return; List <GameObject> open = new List <GameObject>(); List <GameObject> closed = new List <GameObject>(); //Range 1 //check activated tiles for (var x = 0; x < gridSize; x++) { for (var y = 0; y < gridSize; y++) { if (referenceGrid[x, y].activeSelf) { closed.Add(referenceGrid[x, y]); for (var i = 0; i < 4; i++) { var neighbor = GetNeighbor(referenceGrid, referenceGrid[x, y], i); if (neighbor == null) { continue; } var neighborPos = GetTilePosition(neighbor); //if (neighborPos == null) // continue; if (!neighbor.activeSelf && !attackGrid[neighborPos.x, neighborPos.y].activeSelf) { open.Add(ActivateTile(attackGrid[neighborPos.x, neighborPos.y])); } } } } } #region trash code /* * //Range > 1 --- Currently don't need that, doesn't work for range > 2 yet * if (attackRange>1) * { * for (var r = 0; r < attackRange - 1; r++) * { * for (var x = 0; x < gridSize; x++) * { * for (var y = 0; y < gridSize; y++) * { * if (closed.Contains(attackGrid[x, y])) * continue; * if (attackGrid[x, y].activeSelf && open.Contains(attackGrid[x, y])) * { * closed.Add(attackGrid[x, y]); * open.Remove(attackGrid[x, y]); * for (var i = 0; i < 4; i++) * { * var neighbor = GetNeighbor(attackGrid, attackGrid[x, y], i); * if (neighbor == null) * continue; * var neighborPos = GetTilePosition(neighbor); * if (neighborPos == null) * continue; * if (!neighbor.activeSelf && !referenceGrid[neighborPos.x, neighborPos.y].activeSelf && !closed.Contains(attackGrid[neighborPos.x, neighborPos.y])) * { * ActivateTile(attackGrid[neighborPos.x, neighborPos.y]); * } * } * } * } * } * * //foreach closed tile * foreach (var t in closed) * { * if (open.Contains(t)) * continue; * * for (var i = 0; i < 4; i++) * { * var neighbor = GetNeighbor(attackGrid, attackGrid[GetTilePosition(t).x, GetTilePosition(t).y], i); * if (neighbor == null) * continue; * * var neighborPos = GetTilePosition(neighbor); * if (neighborPos == null) * continue; * * //if neighbor is empty * if (!neighbor.activeSelf) * { * if (!referenceGrid[neighborPos.x, neighborPos.y].activeSelf) * { * //re add to open list * open.Add(t); * Debug.Log("added tile to open " + GetTilePosition(t).x + ", " + GetTilePosition(t).y); * } * } * * } * } * * foreach (var t in open) * { * if (closed.Contains(t)) * closed.Remove(t); * } * } * }*/ #endregion }
void Start() { tokens = new GameObject[numberOfGridColumns, numberOfGridRows]; }