Files
dungeon-divers/scripts/dungeon/visual_tilemap_renderer.gd
T
2025-12-28 14:38:59 -05:00

272 lines
7.9 KiB
GDScript

extends Node2D
class_name VisualTileMapRenderer
## Renders dungeon tiles using visual tile data from server
## Supports multiple tilemap sheets, layers, rotation, and flipping
const TILE_SCALE := 2.0 # Scale tiles to match world coordinates
# CDN base URL for tile sheets
var cdn_base_url := "https://assets.aeternalisgames.com/downloads"
# Cached textures by sheet ID
var _sheet_textures: Dictionary = {} # sheet_id -> ImageTexture
var _sheet_info: Dictionary = {} # sheet_id -> sheet data
# Layer nodes
var _layer_nodes: Dictionary = {} # layer -> Node2D
# Tile sprites (for cleanup)
var _tile_sprites: Array[Sprite2D] = []
signal tiles_loaded
signal tiles_failed(error: String)
func _ready():
# Create layer container nodes
for layer in range(4): # 0=ground, 1=floor_decor, 2=walls, 3=ceiling
var layer_node = Node2D.new()
layer_node.name = "Layer%d" % layer
layer_node.z_index = layer * 10
add_child(layer_node)
_layer_nodes[layer] = layer_node
## Load and render visual tiles from dungeon data
func render_visual_tiles(visual_data: Dictionary) -> void:
clear_tiles()
if not visual_data.has("sheets") or not visual_data.has("tiles"):
push_warning("[VisualTileMap] No visual tile data provided")
return
var sheets = visual_data.get("sheets", [])
var tiles = visual_data.get("tiles", [])
print("[VisualTileMap] Loading %d sheets, %d tiles" % [sheets.size(), tiles.size()])
# Load sheet info - convert IDs to int (JSON sends floats)
for sheet in sheets:
var sheet_id = int(sheet.get("id", 0))
_sheet_info[sheet_id] = {
"path": sheet.get("path", ""),
"tile_w": int(sheet.get("tileW", 16)),
"tile_h": int(sheet.get("tileH", 16)),
"sheet_w": int(sheet.get("sheetW", 256)),
"sheet_h": int(sheet.get("sheetH", 256)),
"cols": int(sheet.get("cols", 16))
}
# Load textures then render
await _load_sheet_textures()
_render_tiles(tiles)
tiles_loaded.emit()
## Load all sheet textures from CDN or cache
func _load_sheet_textures() -> void:
for sheet_id in _sheet_info.keys():
if _sheet_textures.has(sheet_id):
continue # Already loaded
var info = _sheet_info[sheet_id]
var path = info.get("path", "")
if path.is_empty():
continue
# Check UpdateManager cache first
var texture = await _load_texture(path)
if texture:
_sheet_textures[sheet_id] = texture
print("[VisualTileMap] Loaded sheet %d: %s" % [sheet_id, path])
else:
push_warning("[VisualTileMap] Failed to load sheet: %s" % path)
## Load texture from UpdateManager cache or CDN
func _load_texture(cdn_path: String) -> ImageTexture:
# Try UpdateManager's load_texture first (handles caching)
if UpdateManager:
var tex = await UpdateManager.load_texture(cdn_path)
if tex:
# Convert to ImageTexture if needed
if tex is ImageTexture:
return tex
elif tex is Texture2D:
var img = tex.get_image()
if img:
return ImageTexture.create_from_image(img)
# Fallback: download directly from CDN
var url = "%s/%s" % [cdn_base_url, cdn_path]
print("[VisualTileMap] Downloading from CDN: %s" % url)
var http = HTTPRequest.new()
add_child(http)
var err = http.request(url)
if err != OK:
http.queue_free()
push_warning("[VisualTileMap] HTTP request failed for: %s" % url)
return null
var result = await http.request_completed
http.queue_free()
var response_code = result[1]
var body = result[3]
if response_code != 200:
push_warning("[VisualTileMap] HTTP %d for: %s" % [response_code, url])
return null
var image = Image.new()
# Detect format from path
if cdn_path.ends_with(".png"):
err = image.load_png_from_buffer(body)
elif cdn_path.ends_with(".jpg") or cdn_path.ends_with(".jpeg"):
err = image.load_jpg_from_buffer(body)
elif cdn_path.ends_with(".webp"):
err = image.load_webp_from_buffer(body)
else:
err = image.load_png_from_buffer(body) # Default to PNG
if err != OK:
push_warning("[VisualTileMap] Failed to load image: %s" % cdn_path)
return null
return ImageTexture.create_from_image(image)
## Render all tiles
func _render_tiles(tiles: Array) -> void:
var rendered := 0
var skipped := 0
var first_logged := false
for tile_data in tiles:
if not first_logged:
print("[VisualTileMap] First tile: %s" % tile_data)
print("[VisualTileMap] Sheet textures keys: %s" % _sheet_textures.keys())
print("[VisualTileMap] Sheet info keys: %s" % _sheet_info.keys())
first_logged = true
if _render_tile(tile_data):
rendered += 1
else:
skipped += 1
print("[VisualTileMap] Rendered %d tile sprites, skipped %d" % [rendered, skipped])
## Render a single tile
func _render_tile(tile_data: Dictionary) -> bool:
var x = int(tile_data.get("x", 0))
var y = int(tile_data.get("y", 0))
var tile_def_id = int(tile_data.get("tid", 0))
var layer = int(tile_data.get("l", 0))
var rotation = int(tile_data.get("r", 0))
var flip_x = tile_data.get("fx", false)
var flip_y = tile_data.get("fy", false)
# Get sheet_id and frame - convert from float to int (JSON numbers are floats)
var sheet_id = int(tile_data.get("sid", 0))
var frame_idx = int(tile_data.get("frame", 0))
# If no sheet_id, try first available
if sheet_id == 0:
if _sheet_info.size() > 0:
sheet_id = int(_sheet_info.keys()[0])
if not _sheet_textures.has(sheet_id):
return false # Sheet not loaded
var texture = _sheet_textures[sheet_id]
var info = _sheet_info[sheet_id]
var tile_w = int(info.get("tile_w", 16))
var tile_h = int(info.get("tile_h", 16))
var cols = int(info.get("cols", 16))
if cols <= 0:
return false
# Calculate source rect for this tile
var col = frame_idx % cols
var row = frame_idx / cols
var src_rect = Rect2(col * tile_w, row * tile_h, tile_w, tile_h)
# Create sprite
var sprite = Sprite2D.new()
sprite.texture = texture
sprite.region_enabled = true
sprite.region_rect = src_rect
sprite.centered = false
# Position (scaled to world coords)
sprite.position = Vector2(x * tile_w * TILE_SCALE, y * tile_h * TILE_SCALE)
sprite.scale = Vector2(TILE_SCALE, TILE_SCALE)
# Apply transforms
if flip_x:
sprite.flip_h = true
if flip_y:
sprite.flip_v = true
if rotation != 0:
sprite.rotation_degrees = rotation * 90.0 # 0, 90, 180, 270
# Adjust position for rotation pivot
if rotation == 1:
sprite.position.x += tile_w * TILE_SCALE
elif rotation == 2:
sprite.position.x += tile_w * TILE_SCALE
sprite.position.y += tile_h * TILE_SCALE
elif rotation == 3:
sprite.position.y += tile_h * TILE_SCALE
# Pixel perfect rendering
sprite.texture_filter = CanvasItem.TEXTURE_FILTER_NEAREST
# Add to appropriate layer
var layer_node = _layer_nodes.get(layer, _layer_nodes[0])
layer_node.add_child(sprite)
_tile_sprites.append(sprite)
return true
## Clear all rendered tiles
func clear_tiles() -> void:
for sprite in _tile_sprites:
if is_instance_valid(sprite):
sprite.queue_free()
_tile_sprites.clear()
## Preload sheet textures (call during loading screen)
func preload_sheets(sheets: Array) -> void:
for sheet in sheets:
var sheet_id = sheet.get("id", 0)
_sheet_info[sheet_id] = {
"path": sheet.get("path", ""),
"tile_w": sheet.get("tileW", 16),
"tile_h": sheet.get("tileH", 16),
"sheet_w": sheet.get("sheetW", 256),
"sheet_h": sheet.get("sheetH", 256),
"cols": sheet.get("cols", 16)
}
await _load_sheet_textures()
## Alternative: Render using a single TileMapLayer (more efficient for large dungeons)
## Call this instead of render_visual_tiles if you want to use Godot's built-in TileMap
func render_to_tilemap(visual_data: Dictionary, tilemap: TileMapLayer) -> void:
if not tilemap:
push_error("[VisualTileMap] No TileMapLayer provided")
return
tilemap.clear()
var tiles = visual_data.get("tiles", [])
if tiles.is_empty():
return
# This requires setting up a TileSet with the tilemap sheets as sources
# For now, we use the sprite-based approach which is more flexible
push_warning("[VisualTileMap] TileMapLayer rendering not yet implemented - use render_visual_tiles()")