public void SetupTilemapGeneration() { // Create tilemap if it does not exist tilemap = GetComponent <Tilemap>(); if (tilemap == null) { tilemap = transform.gameObject.AddComponent <Tilemap>(); transform.gameObject.AddComponent <TilemapRenderer>(); } // Set tilemap bounds object to the value of sideSize x sideSize x 0 tilemapBounds = new BoundsInt(Vector3Int.zero, new Vector3Int(sideSize, sideSize, 0)); // Initialize and fill the rules dictionary rules.Add(TransformRule.WALL_FROM_BOUNDS, new TransformToTileFromBounds(TileType.WALL)); rules.Add(TransformRule.WALL_FROM_ADJACENTS, new TransformToWallFromAdjacents()); rules.Add(TransformRule.WALL_FOR_ROOM, new TransformToWallForRoom()); rules.Add(TransformRule.ROOM_FROM_ADJACENTS, new TransformToRoomFromAdjacents()); rules.Add(TransformRule.FLOOR_FROM_BOUNDS, new TransformToTileFromBounds(TileType.CORRIDOR)); defaultTile = TilemapHelper.GetDefaultTile(); // Create DataParser object fileParser = new DataParser(); }
public static List <BoundsInt> FindRooms(Tilemap Tilemap) { List <BoundsInt> roomAreas = new List <BoundsInt>(); // Evaluate the area for rooms int corridorsXMin = Tilemap.cellBounds.xMin + 2; int corridorsYMin = Tilemap.cellBounds.yMin + 2; int sizeX = Tilemap.cellBounds.xMax - corridorsXMin - 2; int sizeY = Tilemap.cellBounds.yMax - corridorsYMin - 2; var roomAreaBounds = new BoundsInt(corridorsXMin, corridorsYMin, Tilemap.cellBounds.zMin, sizeX, sizeY, 0); int nextPositionToCheck = 0; Vector3Int position = new Vector3Int(0, 0, 0); for (int x = roomAreaBounds.xMin; x < roomAreaBounds.xMax; x++) { position.x = x; for (int y = roomAreaBounds.yMin; y < roomAreaBounds.yMax; y++) { position.y = y; var tile = Tilemap.GetTile(position); if (TilemapHelper.IsTileOfType(tile.name, TileType.WALL)) { if (IsRoom(Tilemap, position, roomAreaBounds, out BoundsInt roomBounds, out nextPositionToCheck)) { roomAreas.Add(roomBounds); } } } } return(roomAreas); }
public void FindRooms() { var position = Vector3Int.zero; var bounds = tilemap.cellBounds; searchedTiles = new Hashtable(); for (int y = bounds.yMin; y < bounds.yMax; y++) { position.y = y; for (int x = bounds.xMin; x < bounds.xMax; x++) { position.x = x; if (!searchedTiles.ContainsKey(position)) { var currentTileType = TilemapHelper.GetTileTypeFromPosition(position, tilemap); if (currentTileType == TileType.ROOM) { var room = FindRoomArea(position); if (room.tiles.Any()) { rooms.Add(room); } } } } } Debug.Log($"Number of room areas for this tilemap: {rooms.Count}"); }
public void AddRoomsToMap(List <RoomsList> rooms) { // Get tilebase tiles for the room and the corridor TileBase roomTile = TilemapHelper.GetTileByType(TileType.ROOM); TileBase corridorTile = TilemapHelper.GetTileByType(TileType.CORRIDOR); BoundsInt corridorBounds; int roomY = 2; foreach (var roomList in rooms) { int roomX = 2; foreach (var room in roomList.Rooms) { var roomBounds = new BoundsInt(roomX, roomY, 0, room.Width, room.Height, 1); FillAreaWithTile(roomBounds, roomTile); corridorBounds = new BoundsInt(roomX + room.Width, roomY, 0, 1, roomList.MaxHeight, 1); FillAreaWithTile(corridorBounds, corridorTile); roomX += room.Width + 1; } roomY += roomList.MaxHeight; corridorBounds = new BoundsInt(2, roomY, 0, roomList.MaxWidth, 1, 0); roomY++; FillAreaWithTile(corridorBounds, corridorTile); } }
public RoomArea FindRoomArea(Vector3Int startPosition) { Queue <Vector3Int> tilesToCheck = new Queue <Vector3Int>(); tilesToCheck.Enqueue(startPosition); RoomArea room = new RoomArea(); while (tilesToCheck.Any()) { var position = tilesToCheck.Dequeue(); if (!searchedTiles.ContainsKey(position)) { searchedTiles.Add(position, position); var tileType = TilemapHelper.GetTileTypeFromPosition(position, tilemap); if (tileType == TileType.ROOM) { // Add current tile to room room.tiles.Add(new TileObject(position, tileType)); tilesToCheck = AddNeighborsInQueue(tilesToCheck, position); } } } return(room); }
/// <summary> /// This will set <see cref="Doors"/> and it will modify tilemap and set doors into correct places /// </summary> /// <param name="doorLocations"></param> public void SetDoors(DoorLocation doorLocations) { Doors = doorLocations; var floorTile = TilemapHelper.GetTile(TilemapHelper.TileType.TilemapGround); var wallTile = TilemapHelper.GetTile(TilemapHelper.TileType.TilemapWall); // TODO: There might be more efficient method to do this // Clear doors Tilemap.SetTile(new Vector3Int(9, 9, 0), wallTile); Tilemap.SetTile(new Vector3Int(17, 5, 0), wallTile); Tilemap.SetTile(new Vector3Int(9, 0, 0), wallTile); Tilemap.SetTile(new Vector3Int(0, 5, 0), wallTile); // If room has top door if (Doors.HasFlag(Room.DoorLocation.Top)) { Tilemap.SetTile(new Vector3Int(9, 9, 0), floorTile); } // If room has right door if (Doors.HasFlag(Room.DoorLocation.Right)) { Tilemap.SetTile(new Vector3Int(17, 5, 0), floorTile); } // If room has bottom door if (Doors.HasFlag(Room.DoorLocation.Bottom)) { Tilemap.SetTile(new Vector3Int(9, 0, 0), floorTile); } // If room has left door if (Doors.HasFlag(Room.DoorLocation.Left)) { Tilemap.SetTile(new Vector3Int(0, 5, 0), floorTile); } }
void UsePowder() { var targetPosInt = (this.transform.position - this.transform.localPosition) + TilemapHelper.TilePosInFrontOfObj(this.gameObject, movement.lastDirection); Bounds bounds = new Bounds(targetPosInt, Vector2.one * 0.5f); var hits = Physics2D.OverlapAreaAll(bounds.min, bounds.max); foreach (var hit in hits) { if (hit.GetComponentInChildren <ChemPowder>() != null) { return; } } var obj = Instantiate( powderPrefab, Vector2.zero, Quaternion.identity, this.transform.parent); obj.transform.position = targetPosInt; inventory.Change(ItemsEnum.POWDER, -1); putPowder.Invoke(); }
IEnumerator Idle() { var duration = Random.Range(0.5f, 0.7f); yield return(new WaitForSeconds(duration)); var dir = HushPuppy.GenerateValidPosition( () => new Vector3( Random.Range(-distance, distance), Random.Range(-distance, distance)), (vec) => { var hit = Physics2D.BoxCast( this.transform.position, Vector2.one, 0f, vec.normalized, vec.magnitude, 1 << LayerMask.NameToLayer("Walls") | (1 << LayerMask.NameToLayer("Stairs")) | TilemapHelper.GetLayerMaskCreatureCollision(this.currFloorLevel) ); var outOfBounds = !TilemapHelper.InsideSameRoom( this.transform.position, this.transform.position + vec, RoomManager.Get().dimensions ); return(!hit && !outOfBounds); }); this.target = this.transform.position + dir; }
private void SetTile(NVector pos, TileBase tile = null) { //set it? if (tileMap == null) { return; } TilemapHelper.SetTile(tileMap[pos.level].GetComponent <Tilemap>(), pos.x, pos.y, tile); }
public void Remove() { //clear tiles foreach (PPoint p in Points) { TilemapHelper.SetTile(tileMap, p.x, p.y, null); } RemoveAfter(); }
public void WriteTilemap(Tilemap tilemap) { var bounds = tilemap.cellBounds; // Create filename for this csv file var path = BaseOutputPath + BaseFilename + string.Format("{0:yyyy_MM_ddTHH_mm_ss}", DateTime.Now) + $"_{bounds.xMax}x{bounds.yMax}" + BaseFilenameSuffix; string line; // Write tilemap content into file StreamWriter streamWriter = File.CreateText(path); // Write tilemap dimensions line = string.Format("{0}, {1}", bounds.xMax - bounds.xMin, bounds.yMax - bounds.yMin); streamWriter.WriteLine(line); streamWriter.Flush(); // Write column names line = string.Format("{0},{1},{2}", "Tile X", "Tile Y", "Tile Type"); streamWriter.WriteLine(line); streamWriter.Flush(); int typeId; TileBase tile; Vector3Int position = Vector3Int.zero; for (int x = bounds.xMin; x < bounds.xMax; x++) { for (int y = bounds.yMin; y < bounds.yMax; y++) { position.x = x; position.y = y; tile = tilemap.GetTile(position); if (tile != null) { typeId = (int)TilemapHelper.GetTileTypeFromSpriteName(tile.name); line = string.Format("{0},{1},{2}", x, y, typeId); } else { line = string.Format("{0},{1},{2}", x, y, NullTile); } streamWriter.WriteLine(line); streamWriter.Flush(); } } streamWriter.Close(); streamWriter.Dispose(); }
public override void Apply(TilemapStructure tilemap) { _random = new System.Random(tilemap.Grid.Seed); // Re-create the heightmap from our tilemap var heightmap = Noise.GenerateNoiseMap(tilemap.Width, tilemap.Height, tilemap.Grid.Seed, GroundHeightmap.NoiseScale, GroundHeightmap.Octaves, GroundHeightmap.Persistance, GroundHeightmap.Lacunarity, GroundHeightmap.Offset); if (GroundHeightmap.ApplyIslandGradient) { var islandGradient = Noise.GenerateIslandGradientMap(tilemap.Width, tilemap.Height); for (int x = 0, y; x < tilemap.Width; x++) { for (y = 0; y < tilemap.Height; y++) { // Subtract the islandGradient value from the noiseMap value float subtractedValue = heightmap[y * tilemap.Width + x] - islandGradient[y * tilemap.Width + x]; // Apply it into the map, but make sure we clamp it between 0f and 1f heightmap[y * tilemap.Width + x] = Mathf.Clamp01(subtractedValue); } } } // Get all start positions var validStartPositions = TilemapHelper.GetTilesByType(tilemap, StartingTileTypes.Select(a => (int)a)); var amountOfRivers = _random.Next(MinRiverQuota, MaxRiverQuota + 1); var rivers = new List <DownstreamRiver>(); for (int i = 0; i < amountOfRivers; i++) { // Get valid startPoint with respect to distance between existing rivers var startPoint = GetValidStartPosition(validStartPositions, rivers); if (!startPoint.HasValue) { break; } // Build river from start based on heightmap var river = new DownstreamRiver(startPoint.Value); if (river.Build(tilemap, heightmap)) { rivers.Add(river); } } // Set river tiles into tilemap int riverTileId = (int)GroundTileType.River; foreach (var riverPosition in rivers.SelectMany(a => a.RiverPositions)) { tilemap.SetTile(riverPosition.x, riverPosition.y, riverTileId); } }
public static bool InPlayerRoom(GameObject obj) { var player = GameObject.FindGameObjectWithTag("Player"); if (player == null) { return(false); } return(TilemapHelper.InsideSameRoom( obj.transform.position, player.transform.position, RoomManager.Get().dimensions)); }
/// <summary> /// Update the tilemap according to specific rules (e.g. firespread) /// </summary> public void UpdateTiles() { var tiles = TilemapHelper.GetTileDictionary(tilemap); if (!levelIsComplete && !isGameOver) { Debug.Log("Starting next round"); StartCoroutine(SpreadFire(tiles, dynamicFireSpread)); ResetActionPoints(); isGameOver = IsGameOver(TilemapHelper.GetTileDictionary(tilemap)); } }
IEnumerator RespawnTimer() { yield return(new WaitForSeconds(respawnInterval)); yield return(new WaitWhile(() => TilemapHelper.InPlayerRoom(this.gameObject))); yield return(new WaitForSeconds(0.5f)); Vector3 position = FindVacantPosition(); var obj = Instantiate(whitePowderPrefab, position, Quaternion.identity, this.transform.parent); RegisterPowder(obj.GetComponent <WhitePowder>()); }
private void CreateRandomTileProps() { // remove objects that have changed tile type for (int i = grassPropsList.Count - 1; i >= 0; i--) { if (!((AbstractGameTile)tilemap.GetTile(grassPropsList[i].Item1) is GrassTile)) { Destroy(grassPropsList[i].Item2); grassPropsList.RemoveAll(item => item.Item1 == grassPropsList[i].Item1); } } var tileDic = TilemapHelper.GetTileDictionary(tilemap); foreach (var tileType in tileDic.Keys) { var tilesWithType = tileDic[tileType]; if (tileType == typeof(GrassTile)) { foreach (var tile in tilesWithType) { if (grassPropsList.Count == 0 || !grassPropsList.Any(i => i.Item1 == tile)) { var randomProp = UnityEngine.Random.Range(1, 4); // random prop 1-4 (4 is excluded) var newProp = Instantiate(Resources.Load("Forest/ForestProps" + randomProp), GrassProps.transform) as GameObject; var cellPos = tilemap.CellToWorld(tile); newProp.transform.position = new Vector3(cellPos.x, newProp.transform.position.y, cellPos.z); newProp.transform.eulerAngles = new Vector3(newProp.transform.rotation.x, UnityEngine.Random.Range(0f, 360f), newProp.transform.rotation.z); grassPropsList.Add(new Tuple <Vector3Int, GameObject>(tile, newProp)); } } } else if (tileType == typeof(BurntTile)) { foreach (var tile in tilesWithType) { if (burnedPropsList.Count == 0 || !burnedPropsList.Any(i => i.Item1 == tile)) { var randomProp = UnityEngine.Random.Range(1, 3); // random prop 1-3 (3 is excluded) var newProp = Instantiate(Resources.Load("Burned/BurnedProps" + randomProp), BurnedProps.transform) as GameObject; var cellPos = tilemap.CellToWorld(tile); newProp.transform.position = new Vector3(cellPos.x, newProp.transform.position.y, cellPos.z); newProp.transform.eulerAngles = new Vector3(newProp.transform.rotation.x, UnityEngine.Random.Range(0f, 360f), newProp.transform.rotation.z); burnedPropsList.Add(new Tuple <Vector3Int, GameObject>(tile, newProp)); } } } } }
void ClearPath() { var walls = TilemapHelper.GetWallsTilemap(); var posInt = HushPuppy.GetVecAsTileVec(this.transform.position); var tile = walls.GetTile(posInt); if (tile != null) { var sprite = ((Tile)tile).sprite; fakeWall.sprite = sprite; walls.SetTile(posInt, null); } }
void Start() { foreach (var powder in GameObject.FindObjectsOfType <WhitePowder>()) { if (TilemapHelper.InsideSameRoom(this.transform.position, powder.transform.position, RoomManager.Get().dimensions)) { RegisterPowder(powder); } } if (spawnPoints.Count == 0) { Debug.LogError("This shouldn't be happening."); Debug.Break(); } }
public void CreateTilemapFromLeafs(Tilemap tilemap) { if (Children.Count == 0) { TileBase tile = TilemapHelper.GetTileByType(Type); TilemapHelper.FillAreaWithTile(this.LeafBounds, tile, tilemap); } else { foreach (var child in Children) { child.CreateTilemapFromLeafs(tilemap); } } }
void LeaveSlime() { Vector3Int currentInt = GetCurrentPosInt(); Vector3Int belowInt = currentInt + Vector3Int.down; if (tilesToSlime.Contains(belowInt)) { tilesToSlime.Remove(belowInt); if (TilemapHelper.IsWall(belowInt)) { Instantiate( slorgSlimePrefab, belowInt + new Vector3(0.5f, 0.5f, 0), Quaternion.identity, this.transform.parent); } } }
IEnumerator Loop() { while (true) { var food = sensors.observations.Find((f) => f.CompareTag("MoleRatFood")); if (state != State.DIGGING && food != null && TilemapHelper.InPlayerRoom(this.gameObject)) { targetObj = food; target = food.transform.position; state = State.MOVING; // yield return ShowExclamation(); } switch (state) { case State.IDLE: yield return(Idle()); state = State.MOVING; break; case State.MOVING: yield return(Move(food != null)); if (food != null && Vector3.Distance(this.transform.position, food.transform.position) < 0.1f) { state = State.DIGGING; } else { state = State.IDLE; } break; case State.DIGGING: yield return(Dig()); state = State.IDLE; break; } } }
/// <summary> /// Apply a specific transformation rule to a specific tile /// </summary> /// <param name="rule">The TRANFROM_RULE to be applied to this tile</param> /// <param name="position">The position of the tile on the tilemap</param> /// <param name="neighbors">the tile's neighborhood, the 3x3 area around the tile as a 1D array</param> /// <returns></returns> public TileBase ApplyRule(TransformRule rule, Vector3Int position, TileBase[] neighbors, BoundsInt bounds) { if (rule == TransformRule.WALL_FROM_BOUNDS) { var newTileType = rules[TransformRule.WALL_FROM_BOUNDS].Apply(position, bounds); if (newTileType != null) { return(TilemapHelper.GetTileByType(newTileType)); } } if (rule == TransformRule.WALL_FROM_ADJACENTS) { var newTileType = rules[TransformRule.WALL_FROM_ADJACENTS].Apply(neighbors); if (newTileType != null) { return(TilemapHelper.GetTileByType(newTileType)); } } if (rule == TransformRule.WALL_FOR_ROOM) { var newTileType = rules[TransformRule.WALL_FOR_ROOM].Apply(neighbors); if (newTileType != null) { return(TilemapHelper.GetTileByType(newTileType)); } } if (rule == TransformRule.ROOM_FROM_ADJACENTS) { var newTileType = rules[TransformRule.ROOM_FROM_ADJACENTS].Apply(neighbors); if (newTileType != null) { return(TilemapHelper.GetTileByType(newTileType)); } } if (rule == TransformRule.FLOOR_FROM_BOUNDS) { var newTileType = rules[TransformRule.FLOOR_FROM_BOUNDS].Apply(position, bounds); if (newTileType != null) { return(TilemapHelper.GetTileByType(newTileType)); } } return(null); }
void HandleRoomChange() { var roomCenter = TilemapHelper.GetRoomCenter( this.cameraFocus.transform.position, roomManager.dimensions); if (lastRoomCenter != roomCenter) { var roomDistance = RoomManager.RoomDistance(lastRoomCenter, roomCenter, roomManager.dimensions); float dur = roomDistance == 1 ? transitionDuration : 0f; this.transform.DOMove(roomCenter + offset, dur); letterboxTilemap.transform.DOMove(roomCenter, dur); lastRoomCenter = roomCenter; roomManager.RegisterChange(roomCenter); } }
public TileType?Apply(TileBase[] neighbors) { if (neighbors.Length < 9) { return(null); } // Get middle tile var tile = neighbors[(int)TilePositions.MIDDLE]; var tileType = TilemapHelper.GetTileTypeFromSpriteName(tile.name); // Check if the tile is already a wall if (tileType == TileType.WALL) { return(null); } // Check if the tile is not floor if (tileType != TileType.ROOM) { return(null); } var neighborTypes = new TileType[8]; int index = 0; int count = 0; foreach (var neighbor in neighbors) { if (count != (int)TilePositions.MIDDLE) { neighborTypes[index] = TilemapHelper.GetTileTypeFromSpriteName(neighbor.name); index++; } count++; } if (TilemapHelper.IsNextToType(neighborTypes, TileType.CORRIDOR)) { return(TileType.WALL); } return(null); }
public TileType?Apply(TileBase[] neighbors) { if (neighbors.Length < 9) { return(null); } // Get middle tile var tile = neighbors[(int)TilePositions.MIDDLE]; // Check if the tile is already a wall if (TilemapHelper.GetTileTypeFromSpriteName(tile.name) == TileType.WALL) { return(null); } // Get horizontal and vertical adjacent tiles var adjacents = new TileBase[4] { neighbors[(int)TilePositions.MIDDLE_LEFT], neighbors[(int)TilePositions.MIDDLE_RIGHT], neighbors[(int)TilePositions.TOP_MIDDLE], neighbors[(int)TilePositions.DOWN_MIDDLE] }; int count = 0; foreach (var adjacentTile in adjacents) { if (adjacentTile != null) { count += TilemapHelper.GetTileTypeFromSpriteName(adjacentTile.name) == TileType.WALL ? 1 : 0; } } if (count >= 2) { return(TileType.WALL); } return(null); }
// Update is called once per frame public void Update() { var fireTiles = TilemapHelper.GetTileCoordinates(Tilemap).Where(t => Tilemap.GetTile(t) is FireTile).ToList(); if (fireTiles.Contains(TilePosition)) { audioController.PlayUnitDeathSound(); Destroy(gameObject); // Choose next unit var nextUnit = levelController.playerUnits.Where(unit => unit != null && unit.ActionPoints > 0).ToList(); if (nextUnit.Count > 0) { levelController.currentlySelectedUnit = levelController.playerUnits.IndexOf(nextUnit.First()); } else { levelController.currentlySelectedUnit = -1; } } }
public override void Apply(TilemapStructure tilemap) { _random = new System.Random(tilemap.Grid.Seed); var rivers = new List <DrunkenRiver>(); var validStartPositions = TilemapHelper.GetTilesByType(tilemap, StartingTileTypes.Select(a => (int)a)); var amountOfRivers = _random.Next(MinRiverQuota, MaxRiverQuota + 1); for (int i = 0; i < amountOfRivers; i++) { // Get valid startPoint with respect to distance between existing rivers var startPoint = GetValidStartPosition(validStartPositions, rivers); if (!startPoint.HasValue) { break; } // Find valid endPos (closest deep water tile to startPos) var endPos = TilemapHelper.FindClosestTileByType(tilemap, startPoint.Value, (int)GroundTileType.DeepWater); if (!endPos.HasValue) { break; } // Build river from start to end position var river = new DrunkenRiver(_random, RiverDriftChance, startPoint.Value, endPos.Value); if (river.Build()) { rivers.Add(river); } } // Set river tiles into tilemap int riverTileId = (int)GroundTileType.River; foreach (var riverPosition in rivers.SelectMany(a => a.RiverPositions)) { tilemap.SetTile(riverPosition.x, riverPosition.y, riverTileId); } }
void ClimbWall() { Vector3Int currentInt = GetCurrentPosInt(); Vector3Int aboveInt = currentInt + Vector3Int.up; Vector3Int belowInt = currentInt + Vector3Int.down; if (TilemapHelper.IsWall(currentInt) || TilemapHelper.IsWall(aboveInt) || TilemapHelper.IsWall(belowInt)) { this.rb.velocity = Vector2.up * speed; if (!tilesToSlime.Contains(currentInt)) { tilesToSlime.Add(currentInt); } } else { this.rb.velocity = Vector2.zero; } }
public void DisplayReachableTilesForCurrentUnit() { DestroyReachableTilesDisplayHelp(); if (currentlySelectedUnit != -1) { var currentUnit = playerUnits[currentlySelectedUnit]; var reachableTiles = TilemapHelper.FindReachableTiles(currentUnit.TilePosition, currentUnit.ActionPoints, tilemap); foreach (var fringe in reachableTiles) { foreach (var tile in fringe) { if (tile.Item2 <= currentUnit.ActionPoints) { var newHelper = Instantiate(Resources.Load("RangeHexagon"), RangeDisplayHelper.transform) as GameObject; var cellPos = tilemap.CellToWorld(tile.Item1); newHelper.transform.position = new Vector3(cellPos.x, newHelper.transform.position.y, cellPos.z); } } } } }
public void CreatePaths() { var rooms = evaluator.rooms; RoomArea currentRoom; RoomArea nextRoom; TileBase roomTile = TilemapHelper.GetTileByType(TileType.ROOM); for (int i = 0; i < rooms.Count; i++) { currentRoom = rooms[i]; if (i + 1 < rooms.Count) { nextRoom = rooms[i + 1]; var path = CalculatePathBetweenRooms(currentRoom, nextRoom); foreach (var position in path) { tilemap.SetTile(position, roomTile); } } } }