Tomkun But wait. There's a simple way still using _tile_data_runtime_update() with just the original map. Maintain a list of invisible cell coordinates. Return true from _use_tile_data_runtime_update() if received coord is in that list. In _tile_data_runtime_update() simply set tile_data.modulate.a to 0.
Tomkun Example:
extends TileMapLayer
var invisibles: Array[Vector2i]
func _ready():
for i in 5:
invisibles.push_back(Vector2i(i,i))
func _use_tile_data_runtime_update(coords):
return coords in invisibles
func _tile_data_runtime_update(coords, tile_data):
tile_data.modulate.a = 0With this you can even animate fading in of the tiles as they become visible.
Tomkun The engine calls them. You just provide the code and the return value. Same as _process() which engine calls each frame. "Virtual" here only means that the function body is optional to implement by the user.
Whenever the engine is about to draw a cell, it will call your _use_tile_data_runtime_update and if it gets true as the return value, it will call your _tile_data_runtime_update() passing it a reference to that cell's tile data. You can alter that data and that's what it will be used for drawing the cell.
It's done like this so that updating is kept efficient i.e. it's only done for cells that really need it.
Okay, I think I get it.
So tile_data.modulate.a = 0 will make the cell invisible and I assume tile_data.modulate.a = 1 or 255 will make it visible again?
xyz
Oh, I see, so if the tile is removed from the list, then it will become visible automatically?
No, that's not working... The tiles are being removed from the list but aren't becoming visible again.
Forget it, I was being dumb again.
Great news!
Thanks to you, it's working (kind of)! I still need to iron out some kinks in my raycasting I think, but tiles are appearing now!
xyz
Which part?
I got the raycasting working, but I'm still not happy with the algorithm I'm using to decide which tiles to reveal.
The code that reveals the tiles is basically exactly what you wrote:
extends TileMapLayer
var invisibletiles: Array[Vector2i]
@onready var hero = $"../../Hero"
func reveal_tile(collisionpoint: Vector2):
var coords = self.local_to_map(collisionpoint)
var herocoords = self.local_to_map(hero.position)
var x_start = min(herocoords.x, coords.x)
var x_end = max(herocoords.x, coords.x)
var y_start = min(herocoords.y, coords.y)
var y_end = max(herocoords.y, coords.y)
for x in range(x_start,x_end + 1):
for y in range(y_start,y_end + 1):
if Vector2i(x,y) in invisibletiles:
invisibletiles.erase(Vector2i(x,y))
notify_runtime_tile_data_update()
func _ready():
pass
func _use_tile_data_runtime_update(coords):
if coords in invisibletiles: return true
else: return false
func _tile_data_runtime_update(coords, tile_data):
if coords in invisibletiles:
tile_data.modulate.a = 0Tomkun Where do you populate the invisibletiles array? At the start it needs to contain the coords of all cells in the map, because you start with all of them being invisible.
Umm you also don't need to do that check in _tile_data_runtime_update(). That's already handled in _use_tile_data_runtime_update(). Everything that passes that check needs its alpha set to 0.
xyz
Oh yeah, that's a leftover from when I didn't realise I didn't have to reset the modulation back to 1.
I populate the array from the same script I use to generate the dungeon. It's very simple:
func HideCells():
for cell in hiddenfloorlayer.get_used_cells():
hiddenfloorlayer.invisibletiles.push_back(cell)Tomkun Put some prints in the reveal_tile to see if anything actually gets erased. Always put some prints when the code is not behaving as expected.
I'd suggest starting with a simpler version where only the tile the player is on gets revealed. That way you can be sure that tilemap update is actually working. Then proceed to implement a more complex algorithm for deciding which tiles to reveal.
xyz
I can get the tiles to reveal themselves reliably. That's not the issue any longer. What I want to improve is the algorithm I'm using to choose which tiles to reveal. At the moment it's revealing all tiles in a straight line, but I'd prefer a cone, or even a complete 360, but from what I can understand, raycasting wouldn't be an efficient way to do that.
Tomkun Well that's another problem altogether.
Use a cone (or a circle) collider on the player to get all cells in range and then test each for visibility via a raycast. Worry about efficiency when you profile it. I doubt it will be an issue especially since you don't need to do it every frame. For cone you need to check only when player changed the movement direction or entered another tile. For a circle it's even less, you need to check only when player enters another tile.
Is there a signal or something to use to make it fire when a new tile is entered, or does the _use_tile_data_runtime_update(coords) function take care of that?
Oh, never mind, just realised I can do it with physics layers.
Tomkun You can use some collision but it's simpler to just check player's position. You always know at which cell the player is (via local_to_map()). Just maintain that value, get it every frame. If there's a difference compared to what is stored from the previous frame, the change happened.
I'm having so much trouble with it though. Sometimes it doesn't detect walls, sometimes it does but local_to_map() converts to the wrong cell. It's being a royal pain to figure out.
I think what is happening is the if the raycast collides with a tile to the left or top, using local_to_map() rounds up so it gets detected as either one cell too low or to the right.