public void CreateMap() { controlTileMap.CompressBounds(); int countHorizontalSide = (int)(controlTileMap.size.x / 2f); int countVerticalSide = (int)(controlTileMap.size.y / 2f); }
private void Start() { player = FindObjectOfType <PlayerManager>(); grid = EnemyManager.Instance.grid; walkableTilemap = EnemyManager.Instance.walkableTilemap; _animator = this.transform.GetComponentInChildren <Animator>(); _healthBar = this.GetComponentInChildren <HealthBar>(); _healthBar.SetBarPoints(enemyData.health, enemyData.defense); if (this.gameObject.GetComponentInChildren <SpriteRenderer>().gameObject.name == "EnemySprite") { spriteRenderer = this.gameObject.GetComponentInChildren <SpriteRenderer>(); } else { Debug.Log("Sprite of player not found"); } mainCamera = Camera.main; if (mainCamera) { shaker = mainCamera.GetComponent <CameraShaker>(); } #region Astar Start Setup walkableTilemap.CompressBounds(); // réduit la taille de la tilemap à là où des tiles existent //roadMap.CompressBounds(); bounds = walkableTilemap.cellBounds; CreateGrid(); astar = new Astar(walkableTilesArray, bounds.size.x, bounds.size.y); #endregion }
void GetTiles(List <TileSingle> tileList) { tilemap.CompressBounds(); bounds = tilemap.cellBounds; allTiles = tilemap.GetTilesBlock(bounds); for (int x = 0; x < bounds.size.x; x++) { for (int y = 0; y < bounds.size.y; y++) { TileBase tile = allTiles[x + y * bounds.size.x]; if (tile != null) { //tileList.Add(new TileSingle(x, y, true)); //Debug.Log(this.name +"x:" + x + " y:" + y + " tile:" + tile.name); tileArr[x, y] = true; } else { //tileList.Add(new TileSingle(x, y, false)); //Debug.Log(this.name + "x:" + x + " y:" + y + " tile: (null)"); tileArr[x, y] = false; } } } }
public void getName() { Tilemap tiles = GameObject.FindGameObjectWithTag("TileGrid").GetComponentInChildren <Tilemap>(); tiles.CompressBounds(); BoundsInt bounds = tilemap.cellBounds; TileBase[] allTiles = tilemap.GetTilesBlock(bounds); for (int x = 0; x < bounds.size.x; x++) { for (int y = bounds.size.y - 1; y > 0; y--) { TileBase tile = allTiles[x + y * bounds.size.x]; if (tile != null) { setType(tile.name, x, bounds.size.y - y); } else { print("Casilla " + x + "," + y + " no encontrada"); } } } }
/// <summary> /// Convert a LayoutGrid to Pathfinding Grid. /// </summary> private Node[,] GenerateGrid(Tilemap tilemap) { tilemap.CompressBounds(); //Recalculates this tilemap's bounds. BoundsInt cellBounds = tilemap.cellBounds; Vector2Int nodesLength = new Vector2Int( Mathf.Abs(cellBounds.xMax) + Mathf.Abs(cellBounds.xMin), Mathf.Abs(cellBounds.yMax) + Mathf.Abs(cellBounds.yMin)); //Get bounds size Node[,] nodes = new Node[nodesLength.x, nodesLength.y]; //tilemap.cellBounds.allPositionsWithin.GetEnumerator(); ?? int numberOfTiles = 0; foreach (Vector3Int position in cellBounds.allPositionsWithin) { numberOfTiles++; Vector2Int gridIndex = TileIndexOnNavGrid(cellBounds, position); nodes[gridIndex.x, gridIndex.y] = new Node() { Walkable = tilemap.HasTile(position) }; } Debug.Log(string.Format("NumberofTiles = {0}", numberOfTiles)); return(nodes); }
public static bool IsGridPassableAtCoordinate(Grid gameWorldGrid, Vector2Int position) { bool foundPassible = false; for (var i = 0; i < gameWorldGrid.transform.childCount; i++) { Tilemap child = gameWorldGrid.transform.GetChild(i).GetComponent <Tilemap>(); child.CompressBounds(); TileBase tile = child.GetTile(new Vector3Int(position.x, position.y, 0)); if (tile == null) { continue; } BlockingTile convertedTile = tile as BlockingTile; if ((convertedTile != null) && (convertedTile.isImpassible)) { // Debug.Log("Tile is impassible: " + convertedTile.isImpassible); return(false); } else { foundPassible = true; } } return(foundPassible); }
void CreateWorld() { Debug.Log("SCClient.CreateWorld - All data received! Creating world."); Ground = Instantiate(GroundPrefab); Tilemap tilemap = Ground.GetComponentInChildren <Tilemap>(); tilemap.ClearAllTiles(); TileStore tileStore = GameObject.Find("Tile Registry").GetComponent <TileStore>(); foreach (SCTileData data in tileDataBuffer) { tilemap.SetTile(new Vector3Int { x = data.X, y = data.Y, z = data.Z }, tileStore.Get(data.TileID)); } tilemap.CompressBounds(); Vector3 center = tilemap.cellBounds.center; Vector3 camPos = tilemap.CellToWorld(new Vector3Int((int)center.x, (int)center.y, 0)); camPos.z = -10; Camera.main.transform.position = camPos; loadingWorld = false; //GameObject.Find("Loading Screen").SetActive(false); }
// Start is called before the first frame update void Start() { tilemap.CompressBounds(); bounds = tilemap.cellBounds; grid = GetComponent <Grid>(); aStar = new AStar(bounds.size.x, bounds.size.y); }
void CalculateCollision() { collisionMap = transform.parent.Find("Colider").gameObject.GetComponent <Tilemap>(); collisionMap.CompressBounds(); respawnMap = GetComponent <Tilemap>(); int xMin = collisionMap.cellBounds.xMin; int xMax = collisionMap.cellBounds.xMax; int yMin = collisionMap.cellBounds.yMin; int yMax = collisionMap.cellBounds.yMax; for (int x = xMin; x < xMax; x++) { for (int y = yMin; y < yMax; y++) { Vector3Int pos = new Vector3Int(x, y, 0); TileBase tile = collisionMap.GetTile(pos); if (tile != null) { Vector3Int newPos = new Vector3Int(x * 3 + 1, y * 3 + 1, 0); respawnMap.SetTile(newPos, tile); } } } }
void Grid_Inicializator() { tilemapPercolation.origin = tilemapFloor.origin; tilemapPercolation.size = tilemapFloor.size; tilemapFloor.CompressBounds(); tilemapPercolation.CompressBounds(); bound = tilemapFloor.cellBounds; limitLine = transform.gameObject.GetComponent <LineRenderer>(); //Getting corners Vector3 gridOrigin = tilemapFloor.GetCellCenterWorld(tilemapFloor.origin); float gridHip = ((tilemapFloor.size.x - 1) * tilemapFloor.cellSize.y); float limitAjustY = tilemapFloor.cellSize.y * (limit - .5f); float limitAjustX = tilemapFloor.cellSize.x * (limit - .5f); homePlate = gridOrigin + new Vector3(0, limitAjustY, 0); firstBase = gridOrigin + new Vector3(gridHip, gridHip / 2, 0) - new Vector3(limitAjustX, 0, 0); secondBase = gridOrigin + new Vector3(0, gridHip, 0) - new Vector3(0, limitAjustY, 0); thirdBase = gridOrigin + new Vector3(-gridHip, gridHip / 2, 0) + new Vector3(limitAjustX, 0, 0); if (debugPrintBallsCorner) { Instantiate(debugBallOrange, homePlate, Quaternion.identity, transform.Find("DEBUG")); Instantiate(debugBallGreen, firstBase, Quaternion.identity, transform.Find("DEBUG")); Instantiate(debugBallOrange, secondBase, Quaternion.identity, transform.Find("DEBUG")); Instantiate(debugBallGreen, thirdBase, Quaternion.identity, transform.Find("DEBUG")); } }
public void InitFromArray(Vector2Int dimensions, int[] typeArray, Vector2Int playerStart, bool arrayOriginTopLeft) { _mapView.ClearAllTiles(); int width = dimensions.y; int height = dimensions.x; if (typeArray.Length != width * height) { Debug.LogError("Array dimensions not matching provided size"); return; } _playerStart = playerStart; if (arrayOriginTopLeft) { _playerStart.x = height - (_playerStart.x + 1); } for (int row = 0; row < height; ++row) { for (int col = 0; col < width; ++col) { int rowCoord = (arrayOriginTopLeft) ? height - (row + 1) : row; _mapView.SetTile(new Vector3Int(rowCoord, col, 0), GetTileByType((KrbTileType)typeArray[width * row + col])); } } _mapView.CompressBounds(); }
private void Start() { var sizes = _gameData.Size.Split('x'); var origin = _gameZoneTilemap.origin; var cellSize = _gameZoneTilemap.cellSize; _gameZoneTilemap.ClearAllTiles(); var currentCellPosition = origin; var width = int.Parse(sizes[0]); var height = int.Parse(sizes[1]); for (var h = 0; h < height; h++) { for (var w = 0; w < width; w++) { _gameZoneTilemap.SetTile(currentCellPosition, _tilesHolder.GetBaseTile()); currentCellPosition = new Vector3Int( (int)(cellSize.x + currentCellPosition.x), currentCellPosition.y, origin.z); } currentCellPosition = new Vector3Int(origin.x, (int)(cellSize.y + currentCellPosition.y), origin.z); } _gameZoneTilemap.CompressBounds(); ModifyCamera(width); }
public string ConvertTilemap(Tilemap tilemap) { tilemap.CompressBounds(); var bounds = tilemap.cellBounds; var allTiles = tilemap.GetTilesBlock(bounds); var width = bounds.xMax - bounds.xMin; var height = bounds.yMax - bounds.yMin; string output = ""; for (int y = 0; y < height; ++y) { for (int x = 0; x < width; ++x) { var tile = allTiles[x + width * y]; if (tile != null) { var tileID = tiles.FirstOrDefault(t => t.Value == tile); output += tileID.Key + ":" + (bounds.xMin + x) + "," + (bounds.yMin + y) + " "; } } output += Environment.NewLine; } return(output); }
private void UpdateTunnel() { _tunnelTileMap.CompressBounds(); _tunnelTileMap.ResizeBounds(); ClearTunnelColumn(_centerTileX - _tunnelSize.x - 1); GenerateTunnelColumn(_centerTileX + _tunnelSize.x); }
private void ReadBoard() { var tilemaps = _grid.GetComponentsInChildren <Tilemap>(); foreach (var tileMap in tilemaps) { if (tileMap.name == "Board") { _board = tileMap; break; } } if (_board == null) { throw new Exception("No Board tilemap found"); } _board.CompressBounds(); foreach (var position in _board.cellBounds.allPositionsWithin) { if (_board.GetTile(position) != null) { _boardTilesCubeCoordinates.Add(CoordinateUtils.OffsetToCube(position)); } } }
private void GetTilemapTiles(Tilemap tileMap, Dictionary <Vector3, WorldTile> tileDict) { tileMap.CompressBounds(); Tilemap groundTile = instance.groundTilemap; foreach (Vector3Int pos in groundTile.cellBounds.allPositionsWithin) { var localPlace = new Vector3Int(pos.x, pos.y, pos.z); /*if (!tileMap.HasTile(localPlace){ * continue; * }*/ var tile = new WorldTile() { LocalPlace = localPlace, WorldLocation = Vector3Int.RoundToInt(groundTile.CellToWorld(localPlace)), TileBase = tileMap.GetTile(localPlace), TilemapMember = tileMap, Name = localPlace.x + "," + localPlace.y, WorldObject = tileMap == instance.objectTilemap ? GetObjectInCell(Vector3Int.RoundToInt(groundTile.CellToWorld(localPlace))) : null, DefaultWorldObjectData = (tileMap == instance.objectTilemap && GetObjectInCell(Vector3Int.RoundToInt(groundTile.CellToWorld(localPlace))) != null) ? GetObjectInCell(Vector3Int.RoundToInt(groundTile.CellToWorld(localPlace))).Data : null, WaterLevel = 0 }; if (tileDict.TryGetValue(tile.WorldLocation, out WorldTile tryTile)) { tryTile = tile; } else { tileDict.Add(tile.WorldLocation, tile); } } }
private void Recenter() { Tilemap tilemap = GetComponent <Tilemap>(); tilemap.CompressBounds(); transform.localPosition = -tilemap.localBounds.center; }
public void RecalculateGridBounds() { tilemap.CompressBounds(); tilemap.ResizeBounds(); gridWidth = tilemap.size.x; gridHeight = tilemap.size.y; }
static internal void CompressBounds(MenuCommand item) { Tilemap tilemap = (Tilemap)item.context; Undo.RegisterCompleteObjectUndo(tilemap, "Compress Tilemap Bounds"); tilemap.CompressBounds(); }
/* * Graph section */ public void InitializeGraph() { _mapGraph = new LifeGraph(); MainTilemap.CompressBounds(); //analyze tilemap and build map graph foreach (Vector3Int pos in MainTilemap.cellBounds.allPositionsWithin) { MapTile tile = MainTilemap.GetTile <Tile>(pos) as MapTile; if (tile != null) { LifeNode centralTileNode = _mapGraph.GetNode(pos) as LifeNode; if (centralTileNode == null) { centralTileNode = new LifeNode(); centralTileNode.Coords = pos; if (tile.IsBlocked == false) { centralTileNode.Status = LifeNode.NodeStatus.Empty; } else { centralTileNode.Status = LifeNode.NodeStatus.Blocked; } centralTileNode.NewStatus = centralTileNode.Status; _mapGraph.AddNode(centralTileNode); } } } }
public static BoundsInt GetMaxBoundsOfGrid(Grid grid) { var currentBounds = new BoundsInt(); for (var i = 0; i < grid.transform.childCount; i++) { Tilemap child = grid.transform.GetChild(i).GetComponent <Tilemap>(); child.CompressBounds(); currentBounds.xMax = (child.cellBounds.xMax > currentBounds.xMax) ? child.cellBounds.xMax : currentBounds.xMax; currentBounds.yMax = (child.cellBounds.yMax > currentBounds.yMax) ? child.cellBounds.yMax : currentBounds.yMax; currentBounds.xMin = (child.cellBounds.xMin < currentBounds.xMin) ? child.cellBounds.xMin : currentBounds.xMin; currentBounds.yMin = (child.cellBounds.yMin < currentBounds.yMin) ? child.cellBounds.yMin : currentBounds.yMin; } currentBounds.zMin = 0; currentBounds.zMax = 1; return(currentBounds); }
public void InitTilesFromView() { // Cache all logic-related data _tilemap.CompressBounds(); _halfCellSize = _tilemap.cellSize; _halfCellSize.Scale(new Vector3(0.5f, 0.5f, 1.0f)); }
private void UpdateGridProperties() { // Compress timemap bounds tilemap.CompressBounds(); // Only populate in the editor if (!Application.IsPlaying(gameObject)) { if (gridProperties != null) { Vector3Int startCell = tilemap.cellBounds.min; Vector3Int endCell = tilemap.cellBounds.max; for (int x = startCell.x; x < endCell.x; x++) { for (int y = startCell.y; y < endCell.y; y++) { TileBase tile = tilemap.GetTile(new Vector3Int(x, y, 0)); if (tile != null) { gridProperties.gridPropertyList.Add(new GridProperty(new GridCoordinate(x, y), gridBoolProperty, true)); } } } } } }
// Start is called before the first frame update void Start() { if (PlayerController.instance != null) { target = PlayerController.instance.transform; } else { target = GameObject.FindWithTag("Player").transform; } halfHeight = Camera.main.orthographicSize; //gets the camera half size.. halfWidth = halfHeight * Camera.main.aspect; //compresses the tilemap size to where only tiles are actually painted theMap.CompressBounds(); //clip the bounds of the camera to the edges of the map. bottomLeftLimit = theMap.localBounds.min + new Vector3(halfWidth, halfHeight, 0f); topRightLimit = theMap.localBounds.max + new Vector3(-halfWidth, -halfHeight, 0f); PlayerController.instance.setBounds(theMap.localBounds.min, theMap.localBounds.max); }
/* * public void setBool() * { * playerSpawned = true; * } */ void Update() { bool gameActive = true; bool playerSpawned = false; if (gameActive == true) { if (playerSpawned == false)/*(Input.GetKeyDown(KeyCode.Keypad1))*/ { Debug.Log("Gstartet"); _gameData = GameObject.FindWithTag("GameData").GetComponent <GameData>(); Debug.Log(_gameData.GetWidth()); IsoGroundMap.CompressBounds(); for (int x = 0; x < _gameData.GetWidth(); x++) { for (int y = 0; y < _gameData.GetHeight(); y++) { var feld = _gameData.GetFeld(x, y); Debug.Log(_gameData.GetFeld(x, y)); if (feld.Terrain == FeldTerrain.Wiese) { Player.layer = 6; Instantiate(Player, IsoGroundMap.GetCellCenterWorld(new Vector3Int(x, y, 0)), Quaternion.identity); Debug.Log("Player was spawned at X: " + (IsoGroundMap.GetCellCenterWorld(new Vector3Int(x, y, 0)).x) + " Y: " + (IsoGroundMap.GetCellCenterWorld(new Vector3Int(x, y, 0)).y) + "Q: " + (Quaternion.identity) + "!"); //playerActive = true; return; } } } } } playerSpawned = true; }
private void InitializeGraph() { tilemap.CompressBounds(); //When you draw a tilemap, its size can only grows, by using "CompressBounds" you allow it to shrink to its "real" size BoundsInt bounds = tilemap.cellBounds; //Creates a dictionary with a node for each tile in "tilemap" wich has for key the coordinates of the tile for (int x = bounds.xMin; x < bounds.xMax; x += 1) { for (int y = bounds.yMin; y < bounds.yMax; y += 1) { if (tilemap.HasTile(new Vector3Int(x, y, 0))) { mazeDic[new Vector2Int(x, y)] = new Node(new Vector2Int(x, y)); } } } //Puts all the neighbor nodes of each node in its "neighbors" list foreach (Vector2Int coord1 in mazeDic.Keys) { foreach (Vector2Int coord2 in mazeDic.Keys) { if (coord1 != coord2 && (((coord1.x - 1 == coord2.x || coord1.x + 1 == coord2.x) && coord1.y == coord2.y) || ((coord1.y - 1 == coord2.y || coord1.y + 1 == coord2.y) && coord1.x == coord2.x))) { mazeDic[coord1].neighbors.Add(mazeDic[coord2]); } } } }
public void CreateGrid(Tilemap floor, Tilemap walls) { this.floor = floor; floor.CompressBounds(); var bounds = floor.cellBounds; grid = new Node[bounds.size.x, bounds.size.y]; for (int x = bounds.xMin; x < bounds.xMax; x++) { for (int y = bounds.yMin; y < bounds.yMax; y++) { var cellPos = new Vector3Int(x, y, 0); var worldPos = floor.CellToWorld(cellPos) + new Vector3(0.5f, 0.5f, 0); var result = Physics2D.OverlapBox(worldPos, Vector2.one * 2, 0, wallMask); var walkable = walls.GetTile(cellPos) == null; var xGrid = x - bounds.xMin; var yGrid = y - bounds.yMin; grid[xGrid, yGrid] = new Node(walkable, worldPos, xGrid, yGrid, result != null ? 5 : 0); } } lowerLeft = grid[0, 0].WorldPosition; upperRight = grid[GridSizeX - 1, GridSizeY - 1].WorldPosition; worldGridBounds = new Bounds(lowerLeft + (upperRight - lowerLeft) * 0.5f, upperRight - lowerLeft); }
// Start is called before the first frame update public int Awake() { tileMap = GetComponentInChildren <Tilemap>(); tileMap.CompressBounds(); width = tileMap.size.x; return(0); }
void CreateGrid() { tileMap.CompressBounds(); BoundsInt tilemapBounds = tileMap.cellBounds; TileBase[] allTiles = tileMap.GetTilesBlock(tilemapBounds); grid = new Node[tilemapBounds.size.x, tilemapBounds.size.y]; for (int x = 0; x < tilemapBounds.size.x; x++) { for (int y = 0; y < tilemapBounds.size.y; y++) { TileBase tile = allTiles[x + y * tilemapBounds.size.x]; bool walkable = (tile.name.Contains("Floor")); TileType type; switch (tile.name) { case "Floor": type = TileType.FLOOR; break; case "Wall": type = TileType.WALL; break; default: type = TileType.FLOOR; break; } grid[x, y] = new Node(walkable, tileMap.GetCellCenterWorld(new Vector3Int(x, y, 0)), x, y, type); } } }
private void Awake() { parentGrid = GetComponentInParent <Grid>(); tilemap = GetComponent <Tilemap>(); tilemap.CompressBounds(); GameObject cell = Resources.Load("ramka", typeof(GameObject)) as GameObject; int count = 0; bounds = tilemap.cellBounds; allTiles = tilemap.GetTilesBlock(bounds); cellGrid = new Cell[bounds.size.x * bounds.size.y]; for (int x = 0; x < bounds.size.x; x++) { for (int y = 0; y < bounds.size.y; y++) { TileBase tile = allTiles[x + y * bounds.size.x]; count++; if (tile != null) { GameObject currentCell = Instantiate(cell, tilemap.CellToWorld(new Vector3Int(x + bounds.xMin, y + bounds.yMin, 0)) + new Vector3(tilemap.tileAnchor.x, tilemap.tileAnchor.y, 0), Quaternion.identity, cellParentTransform); cellGrid[x + y * bounds.size.x] = currentCell.GetComponent <Cell>(); } else { cellGrid[x + y * bounds.size.x] = null; } } } }