public void Initialize()
{
///TODO: This should grab the ground and doodad layers separately....
for (int i = 0; i < transform.childCount; i++)
{
TileMapLayer tml = transform.GetChild(i).GetComponent <TileMapLayer> ();
if (tml != null)
{
tml.Initialize();
}
}
// Debug.Log ("tilemap props: " + tm.CellSize.ToString());
// Debug.Log ("tilemap h: " + tm.GridHeight);
// Debug.Log ("tilemap w: " + tm.GridWidth);
// Debug.Log ("tilemap maxX: " + tm.MaxGridX);
// Debug.Log ("tilemap minX: " + tm.MinGridX);
// Debug.Log ("tilemap maxY: " + tm.MaxGridY);
// Debug.Log ("tilemap minY: " + tm.MinGridY);
// Debug.Log ("tilemap w: " + tm.GridWidth);
// Debug.LogError ("shits here!");
MapManager.instance.MapInitialized(this);
//Debug.Log("==? " + (newT == MapManager.instance.TileAt(-5, -7)));
// Debug.Log ("t null? " + (t == null));
// Debug.Log ("to: " + t.prefabData.offset);
// Debug.Log ("map bounds: " + bnds.size);
// Debug.Log ("map bounds center: " + bnds.center);
//tm.Erase (new Vector2 (0f, 0f));
}
private Vector2Int MouseGridPosition(TileMapLayer buildingLayer)
{
Vector3 mousePos = GetcameraComp().ScreenToWorldPoint(Input.mousePosition);
mousePos.z = 0;
return(gridManager.WorldToGridPosition(mousePos, buildingLayer));
}
public void CancelEvent(Vector2Int gridPosition, TileMapLayer tilemapLayer)
{
if (eventInstance != null)
{
eventInstance.Cancel();
}
}
public Hero(Player player, TileMapLayer tileMapLayer, Input.Mouse mouse) : base(tileMapLayer)
{
_type = UID.Get <Hero>();
_player = player;
_mouse = mouse;
SetSize(24, 32);
SetPivot(12, 16);
// Create Collide Point of Hero
AddPoint((int)HSpots.UL, new Vector2(-10, -20));
AddPoint((int)HSpots.UR, new Vector2(+10, -20));
AddPoint((int)HSpots.DL, new Vector2(-10, +20));
AddPoint((int)HSpots.DR, new Vector2(+10, +20));
AddPoint((int)HSpots.LU, new Vector2(-16, -8));
AddPoint((int)HSpots.LD, new Vector2(-16, +6));
AddPoint((int)HSpots.RU, new Vector2(+16, -8));
AddPoint((int)HSpots.RD, new Vector2(+16, +6));
// Collide Point for Grip
AddPoint((int)HSpots.EL, new Vector2(-16, -16));
AddPoint((int)HSpots.ER, new Vector2(+16, -16));
_sprite = Game1._spriteDragon.Clone();
_sprite.Start("stand", 1, 0);
}
public void GatherInteraction(Vector2Int gridPosition, TileMapLayer tilemapLayer)
{
if (GetIsGatherable)
{
EffectController effectController = new EffectController(PlayerStats._instance.GetStat(StatType.EXP), 0);
expEffect.duration = currentStage.GetExpReward / expEffect.amount;
effectController.Begin(expEffect);
Debug.Log("Tried gathering");
if (currentStage.GetDestroyOnGather || currentStageIndex == 0)
{
Remove(gridPosition, tilemapLayer);
}
else
{
currentStageIndex--;
if (!reachedMaxStage)
{
InitEvent(gridPosition, tilemapLayer);
}
SetIsBeingGatheredState(false, gridPosition);
}
Inventory inventory = Inventory.GetInstance;
foreach (Drop drop in currentStage.GetDrops)
{
if (Random.value <= drop.GetChance)
{
inventory.AddToInventory(0, new ItemSlot(drop.GetItem, Random.Range(drop.GetMinAmount, drop.GetMaxAmount + 1)));
}
}
}
}
public Enemy0(TileMapLayer tileMapLayer) : base(tileMapLayer)
{
_type = UID.Get <Enemy0>();
SetSize(24, 32);
SetPivot(12, 16);
// Create Collide Point of Hero
AddPoint((int)HSpots.UL, new Vector2(-10, -20));
AddPoint((int)HSpots.UR, new Vector2(+10, -20));
AddPoint((int)HSpots.DL, new Vector2(-10, +20));
AddPoint((int)HSpots.DR, new Vector2(+10, +20));
AddPoint((int)HSpots.LU, new Vector2(-16, -8));
AddPoint((int)HSpots.LD, new Vector2(-16, +6));
AddPoint((int)HSpots.RU, new Vector2(+16, -8));
AddPoint((int)HSpots.RD, new Vector2(+16, +6));
// Collide Point for Grip
AddPoint((int)HSpots.EL, new Vector2(-16, -16));
AddPoint((int)HSpots.ER, new Vector2(+16, -16));
_colorA = new Color(Misc.Rng.Next(100, 250), Misc.Rng.Next(50, 250), Misc.Rng.Next(50, 250));
_colorB = new Color(Misc.Rng.Next(100, 250), Misc.Rng.Next(50, 250), Misc.Rng.Next(50, 250));
}
public void GatherInteraction(Vector2Int gridPosition, TileMapLayer buildingLayer)
{
Tilemap tilemap = GridManager._instance.GetTilemap(buildingLayer);
tilemap.RemoveTileFlags((Vector3Int)gridPosition, TileFlags.LockColor);
tilemap.SetColor((Vector3Int)gridPosition, new Color(0.9f, 0.9f, 1f, 0.7f));
}
public Vector3 GridToWorldPosition(Vector2Int gridPosition, TileMapLayer buildingLayer, bool getCenter)
{
Vector3 position = GetTilemap(buildingLayer).CellToWorld((Vector3Int)gridPosition);
position += Vector3.up * ((buildingLayer == TileMapLayer.Buildings ? BUILDING_LAYER_POSITION_OFFSET : 0f) + (getCenter ? TOP_FACE_HEIGHT / 2 : 0f));
return(position);
}
private void InitEvent(Vector2Int gridPosition, TileMapLayer tilemapLayer)
{
if (eventInstance != null)
{
CancelEvent(gridPosition, tilemapLayer);
}
eventInstance = new TileGrowEvent(Time.time + Random.Range(tile.GetMinGrowTime, tile.GetMaxGrowTime), tileSlot, gridPosition, tilemapLayer);
}
public MapObject(TileMapLayer tileMapLayer)
{
_tileMapLayer = tileMapLayer;
_map2D = tileMapLayer._map2D;
_tileW = _map2D._tileW;
_tileH = _map2D._tileH;
}
public void Grow(Vector2Int gridPosition, TileMapLayer tileMapLayer)
{
currentStageIndex++;
GridManager._instance.SetTile(tileSlot, gridPosition, tileMapLayer, false);
if (!reachedMaxStage)
{
InitEvent(gridPosition, tileMapLayer);
}
}
public MapActor(TileMapLayer tileMapLayer) : base(tileMapLayer)
{
_cPoints = new ContactPoint[Enum.GetNames(typeof(HSpots)).Length];
for (int i = 0; i < _cPoints.Length; ++i)
{
_cPoints[i] = new ContactPoint();
}
}
// Update is called once per frame
private void Update()
{
viewChanged = false;
movement = new Vector2(
Input.GetKey(KeyCode.D) ? 1 : 0 - (Input.GetKey(KeyCode.A) ? 1 : 0),
Input.GetKey(KeyCode.W) ? 1 : 0 - (Input.GetKey(KeyCode.S) ? 1 : 0)
);
movement *= moveSpeed * Time.deltaTime;
if (movement != Vector2.zero)
{
transform.position += (Vector3)movement;
viewChanged = true;
}
scrollMovement = Time.deltaTime * scrollSpeed * -Input.GetAxis("Mouse ScrollWheel");
if (scrollMovement != 0)
{
viewChanged = true;
}
if (Input.GetKey(KeyCode.Mouse0))
{
TileMapLayer layer = (Input.GetKey(KeyCode.LeftShift)) ? TileMapLayer.Buildings : TileMapLayer.Floor;
Vector2Int gridPosition = MouseGridPosition(TileMapLayer.Floor);
gridManager.SetTile(new TileSlot(clickTile), gridPosition, layer);
}
else if (Input.GetKey(KeyCode.Mouse1))
{
TileMapLayer layer = (Input.GetKey(KeyCode.LeftShift)) ? TileMapLayer.Buildings : TileMapLayer.Floor;
Vector2Int gridPosition = MouseGridPosition(layer);
gridManager.SetTile(null, gridPosition, layer);
}
else if (Input.GetKeyDown(KeyCode.LeftControl))
{
TileMapLayer layer = (Input.GetKey(KeyCode.LeftShift)) ? TileMapLayer.Buildings : TileMapLayer.Floor;
Debug.Log(gridManager.GetTileFromGrid(MouseGridPosition(layer), layer));
}
else if (Input.GetKeyDown(KeyCode.Mouse2))
{
Vector3 mousePos = GetcameraComp().ScreenToWorldPoint(Input.mousePosition);
mousePos.z = 0;
TileMapLayer layer = (Input.GetKey(KeyCode.LeftShift)) ? TileMapLayer.Buildings : TileMapLayer.Floor;
TileHit hit = gridManager.GetHitFromWorldPosition(mousePos, layer);
if (hit.tile != null &&
hit.tile.IsGatherable)
{
Debug.Log("Color change");
hit.tile.GatherInteraction(hit.gridPosition, layer);
}
}
if (viewChanged)
{
cameraController.UpdateView();
}
}
private void Remove(Vector2Int gridPosition, TileMapLayer tilemapLayer)
{
CancelEvent(gridPosition, tilemapLayer);
GridManager._instance.SetTile(null, gridPosition, tilemapLayer, true);
if (particlesObject != null)
{
Object.Destroy(particlesObject);
particlesObject = null;
}
}
public void RenderTexturedBackground(IDrawDevice device, ref TileMapLayer layer, int cacheIndex, float x, float y)
{
if (!cachedTexturedBackground.IsAvailable || cachedTexturedBackgroundAnimated)
{
RecreateTexturedBackground(ref layer);
}
// Fit the input material rect to the output size according to rendering step config
Vector3 renderPos = new Vector3(device.ViewerPos.X - device.TargetSize.X / 2, device.ViewerPos.Y - device.TargetSize.Y / 2, layer.Depth);
// Fit the target rect to actual pixel coordinates to avoid unnecessary filtering offsets
renderPos.X = MathF.Round(renderPos.X);
renderPos.Y = MathF.Round(renderPos.Y);
if (MathF.RoundToInt(device.TargetSize.X) != (MathF.RoundToInt(device.TargetSize.X) / 2) * 2)
{
renderPos.X += 0.5f;
}
if (MathF.RoundToInt(device.TargetSize.Y) != (MathF.RoundToInt(device.TargetSize.Y) / 2) * 2)
{
// AMD Bugfix?
renderPos.Y -= 0.004f;
}
// Reserve the required space for vertex data in our locally cached buffer
int neededVertices = 4;
if (cachedVertices == null || cachedVertices.Length < neededVertices)
{
cachedVertices = new VertexC1P3T2[neededVertices];
}
// Render it as world-space fullscreen quad
cachedVertices[0].Pos = new Vector3(renderPos.X, renderPos.Y, renderPos.Z);
cachedVertices[1].Pos = new Vector3(renderPos.X + device.TargetSize.X, renderPos.Y, renderPos.Z);
cachedVertices[2].Pos = new Vector3(renderPos.X + device.TargetSize.X, renderPos.Y + device.TargetSize.Y, renderPos.Z);
cachedVertices[3].Pos = new Vector3(renderPos.X, renderPos.Y + device.TargetSize.Y, renderPos.Z);
cachedVertices[0].TexCoord = new Vector2(0f, 0f);
cachedVertices[1].TexCoord = new Vector2(1f, 0f);
cachedVertices[2].TexCoord = new Vector2(1f, 1f);
cachedVertices[3].TexCoord = new Vector2(0f, 1f);
cachedVertices[0].Color = cachedVertices[1].Color = cachedVertices[2].Color = cachedVertices[3].Color = ColorRgba.White;
// Setup custom pixel shader
BatchInfo material = device.RentMaterial();
material.Technique = texturedBackgroundShader;
material.MainTexture = cachedTexturedBackground;
material.SetValue("horizonColor", layer.BackgroundColor);
material.SetValue("shift", new Vector2(x, y));
material.SetValue("parallaxStarsEnabled", layer.ParallaxStarsEnabled ? 1f : 0f);
device.AddVertices(material, VertexMode.Quads, cachedVertices, 0, 4);
}
public void Init(Vector2Int gridPosition, TileMapLayer tilemapLayer, bool generation = false)
{
if (generation)
{
currentStageIndex = StagesCount - 1;
}
if (eventInstance == null && tile.GetStages.Length > 1 && !reachedMaxStage)
{
InitEvent(gridPosition, tilemapLayer);
}
}
public TileSlot GetTileFromGrid(Vector2Int gridPosition, TileMapLayer buildingLayer)
{
if (TryGetChunk(GridToChunkCoordinates(gridPosition), out Chunk chunk))
{
TileSlot tile = chunk.GetTile(gridPosition, buildingLayer);
return(tile);
}
else
{
return(null);
}
}
internal void SetTile(TileSlot tile, Vector2Int gridPosition, TileMapLayer buildingLayer, bool countsAsEdit = true, bool generation = false)
{
switch (buildingLayer)
{
case TileMapLayer.Floor:
SetTileByRef(tile, gridPosition, buildingLayer, countsAsEdit, ref floorArr, ref _instance.floor, generation);
break;
case TileMapLayer.Buildings:
SetTileByRef(tile, gridPosition, buildingLayer, countsAsEdit, ref buildingsArr, ref _instance.buildings, generation);
break;
}
}
public void SetTile(TileSlot tile, Vector2Int gridPosition, TileMapLayer buildingLayer, bool playerAction = true, Color?color = null)
{
Vector2Int chunkPos = GridToChunkCoordinates(gridPosition);
SetTileColor(gridPosition, buildingLayer, (color != null) ? (Color)color : Color.white);
if (TryGetChunk(chunkPos, out Chunk chunk))
{
chunk.SetTile(tile, gridPosition, buildingLayer, playerAction, false);
}
else if (tile != null)
{
CreateChunk(chunkPos).SetTile(tile, gridPosition, buildingLayer, playerAction, false);
}
}
public TileSlot GetTile(Vector2Int gridPosition, TileMapLayer buildingLayer)
{
switch (buildingLayer)
{
case TileMapLayer.Floor:
return(floorArr?[gridPosition.x - chunkStartPos.x, gridPosition.y - chunkStartPos.y]);
case TileMapLayer.Buildings:
return(buildingsArr?[gridPosition.x - chunkStartPos.x, gridPosition.y - chunkStartPos.y]);
default:
throw new System.NotImplementedException();
}
}
public Tilemap GetTilemap(TileMapLayer buildingLayer)
{
switch (buildingLayer)
{
case TileMapLayer.Floor:
return(floor);
case TileMapLayer.Buildings:
return(buildings);
default:
return(null);
}
}
private void SetTileByRef(TileSlot tile, Vector2Int gridPosition, TileMapLayer tilemapLayer, bool countsAsEdit, ref TileSlot[,] tileArr, ref Tilemap tilemap, bool generation = false)
{
Vector2Int chunkPosition = GridToChunkPosition(gridPosition);
bool tileExists = tileArr != null && tileArr[chunkPosition.x, chunkPosition.y] != null;
if (tile != null || tileExists)
{
if (tileArr == null)
{
tileArr = new TileSlot[CHUNK_SIZE, CHUNK_SIZE];
}
if (tileExists && tile == null)
{
tileArr[chunkPosition.x, chunkPosition.y].CancelEvent(gridPosition, tilemapLayer);
tilemap.SetTile((Vector3Int)gridPosition, null);
tileArr[chunkPosition.x, chunkPosition.y] = null;
tileCount--;
wasEdited |= countsAsEdit;
if (tileCount == 0)
{
tileArr = null;
}
}
else if (!tileExists)
{
tileCount++;
wasEdited |= countsAsEdit;
tile.Init(gridPosition, tilemapLayer, generation);
tilemap.SetTile((Vector3Int)gridPosition, tile.GetMainTileBase);
tileArr[chunkPosition.x, chunkPosition.y] = tile;
}
else
{
if (tile != tileArr[chunkPosition.x, chunkPosition.y])
{
tileArr[chunkPosition.x, chunkPosition.y].CancelEvent(gridPosition, tilemapLayer);
tileArr[chunkPosition.x, chunkPosition.y] = tile;
tile.Init(gridPosition, tilemapLayer, generation);
}
tilemap.SetTile((Vector3Int)gridPosition, tile.GetMainTileBase);
wasEdited |= countsAsEdit;
}
}
}
public Level(ContentManager content)
{
SetSize(Game1._screenW, Game1._screenH);
_tmxMap = new TmxMap("Content/test_slope2D.tmx");
_tileSet = content.Load <Texture2D>("Image/" + "TileSet_Slope2D");
//_tileMap2DX = new TileMap2D().Setup(new Rectangle(0, 0, Game1._screenW, Game1._screenH), _tmxMap.Width, _tmxMap.Height, _tmxMap.TileWidth, _tmxMap.TileHeight, 0, 0);
//_layerX = _tileMap2DX.CreateLayer(null);
_tileMap2D = new TileMap2D().Setup(new Rectangle(0, 0, Game1._screenW, Game1._screenH), _tmxMap.Width, _tmxMap.Height, _tmxMap.TileWidth, _tmxMap.TileHeight);
_arenaSizeW = _tmxMap.Width * _tmxMap.TileWidth;
_arenaSizeH = _tmxMap.Height * _tmxMap.TileHeight;
_layer0 = TileMap2D.CreateLayer(_tmxMap, _tmxMap.Layers["Tile Layer 1"], _tileSet);
System.Console.WriteLine("Layer0._map2D = " + _layer0._map2D);
//System.Console.WriteLine("------> "+_tmxMap.Tilesets[0].Tiles[2].ObjectGroups[0].Objects[0].Points);
// debug
//GenerateMap();
_camera = new Camera();
_camera.SetView(new RectangleF(0, 0, Game1._screenW, Game1._screenH));
_camera.SetZone(new RectangleF(0, 0, Game1._screenW / 20, Game1._screenH / 40));
//_camera.SetLimit(new RectangleF(0, 0, _arenaSizeW, _arenaSizeH));
_camera.SetLimit(new RectangleF(0, 0, _arenaSizeW, _arenaSizeH));
_camera.SetPosition(new Vector2(_arenaSizeW / 2 + _layer0._map2D._tileW / 2, _arenaSizeH / 2 + _layer0._map2D._tileH * 2));
//for (int i = 0; i < 400; ++i)
//{
// new Enemy0(_layer0).SetPosition(Misc.Rng.Next(80, (int)_arenaSizeW - 80), 80).AppendTo(this);
//}
_hero = (Hero) new Hero(Game1.Player1, _layer0, _mouseLevel).Init().AppendTo(this).SetPosition(80, 80);
//_hero2 = (Hero)new Hero(Game1.Player2, _layer0._map2D).Init().AppendTo(this);
}
protected override void OnCollectStateOverlayDrawcalls(Canvas canvas)
{
base.OnCollectStateOverlayDrawcalls(canvas);
if (CamViewTargetSize.X > LevelRenderSetup.TargetSize.X ||
CamViewTargetSize.Y > LevelRenderSetup.TargetSize.Y)
{
float x1 = (CamViewTargetSize.X - LevelRenderSetup.TargetSize.X) / 2;
float y1 = (CamViewTargetSize.Y - LevelRenderSetup.TargetSize.Y) / 2;
float x2 = x1 + LevelRenderSetup.TargetSize.X;
float y2 = y1 + LevelRenderSetup.TargetSize.Y;
canvas.State.SetMaterial(DrawTechnique.Alpha);
canvas.State.ColorTint = new ColorRgba(0.4f, 1f, 0.4f);
canvas.DrawDashLine(x1, y1, x2, y1, DashPattern.Dash);
canvas.DrawDashLine(x1, y1, x1, y2, DashPattern.Dash);
canvas.DrawDashLine(x2, y1, x2, y2, DashPattern.Dash);
canvas.DrawDashLine(x1, y2, x2, y2, DashPattern.Dash);
}
VertexC1P3T2[] vertices = null;
{
int vertexCount = FontRasterizer.Native9.EmitTextVertices("Pre-alpha version", ref vertices, 10, 10, ColorRgba.White);
canvas.DrawDevice.AddVertices(FontRasterizer.Native9.Material, VertexMode.Quads, vertices, 0, vertexCount);
}
{
int vertexCount = FontRasterizer.Native9.EmitTextVertices("Tile: " + activeTilePos.X + "; " + activeTilePos.Y, ref vertices, 10, 28, ColorRgba.White);
canvas.DrawDevice.AddVertices(FontRasterizer.Native9.Material, VertexMode.Quads, vertices, 0, vertexCount);
}
if (activeTilePos.X >= 0 && activeTilePos.Y >= 0)
{
ref TileMapLayer layer = ref tilemap.Layers.Data[tilemap.SpriteLayerIndex];
int index = activeTilePos.X + activeTilePos.Y * layer.LayoutWidth;
if (index < layer.Layout.Length)
{
ref LayerTile tile = ref layer.Layout[index];
int vertexCount = FontRasterizer.Native9.EmitTextVertices("ID: " + tile.TileID + "; Anim: " + tile.IsAnimated + "; FlipX: " + tile.IsFlippedX + "; FlipY: " + tile.IsFlippedY + "; OneWay:" + tile.IsOneWay + "; " + tile.MaterialOffset + "; " + tile.Material, ref vertices, 10, 56, ColorRgba.White);
canvas.DrawDevice.AddVertices(FontRasterizer.Native9.Material, VertexMode.Quads, vertices, 0, vertexCount);
}
public void SetDummyTile(TileSlot tile, Vector2Int gridPosition, TileMapLayer buildingLayer, Color?color = null)
{
Tilemap tilemap = GetTilemap(buildingLayer);
if (GetTileFromGrid(gridPosition, buildingLayer) == null)
{
if (tile == null)
{
tilemap.SetTile((Vector3Int)gridPosition, null);
}
else
{
GetTilemap(buildingLayer).SetTile((Vector3Int)gridPosition, tile.GetMainTileBase);
if (color != null)
{
SetTileColor(gridPosition, buildingLayer, (Color)color);
}
}
}
}
/// <summary>
/// Gets the tile on a certain position.
/// Input grid position for an exact position on the grid
/// and world position if you want to also check for tiles sides.
/// </summary>
/// <returns></returns>
public TileHit GetHitFromWorldPosition(Vector2 worldPosition, TileMapLayer buildingLayer)
{
Vector2Int gridPosition = WorldToGridPosition(worldPosition, buildingLayer);
TileHit hit;
if (TryGetChunk(GridToChunkCoordinates(gridPosition), out Chunk chunk))
{
hit = new TileHit(chunk.GetTile(gridPosition, buildingLayer), gridPosition);
if (hit.tile != null)
{
return(hit);
}
else
{
Vector2 tileWorldPosition = GridToWorldPosition(gridPosition, buildingLayer, false);
Vector2 localPosition = worldPosition - tileWorldPosition;
if (localPosition.y < 0.2f && Mathf.Abs(localPosition.x) < 0.1f)
{
return(hit);
}
Vector2Int checkPosition = gridPosition + (localPosition.x < 0 ? Vector2Int.up : Vector2Int.right);
hit = new TileHit(GetTileFromGrid(checkPosition, buildingLayer), checkPosition);
if (hit.tile != null)
{
return(hit);
}
else if (Vector2.Distance(localPosition, new Vector2(0, 0.45f)) <= 0.24f)
{
checkPosition = gridPosition + Vector2Int.one;
hit = new TileHit(GetTileFromGrid(checkPosition, buildingLayer), checkPosition);
if (hit.tile != null)
{
return(hit);
}
}
}
}
return(new TileHit(null, gridPosition));
}
public TileHit Scan(Vector2Int gridStartPosition, DirectionEnum _direction, int _radius, TileMapLayer _buildingLayer, IChecker _checker)
{
startPosition = gridStartPosition;
radius = _radius;
buildingLayer = _buildingLayer;
checker = _checker;
direction = _direction;
TileSlot currentTile = gridManager.GetTileFromGrid(startPosition, buildingLayer);
if (currentTile != null && checker.CheckTile(currentTile))
{
return(new TileHit(currentTile, startPosition));
}
for (int i = 1; i <= radius; i++)
{
TileHit tileHit = GetClosestTileInSquare(i);
if (tileHit != null)
{
return(tileHit);
}
}
return(null);
}
public virtual void CancelEvent(Vector2Int gridPosition, TileMapLayer tilemapLayer) => tileState.CancelEvent(gridPosition, tilemapLayer);
public void Init(Vector2Int gridPosition, TileMapLayer tilemapLayer, bool generation = false) => tileState.Init(gridPosition, tilemapLayer, generation);
public virtual void SpecialInteraction(Vector2Int gridPosition, TileMapLayer buildingLayer) => tileState.SpecialInteraction(gridPosition, buildingLayer);
