Files
dungeon-divers/scripts/dungeon/visual_tilemap_renderer.gd
2026-01-11 15:15:24 -05:00

352 lines
10 KiB
GDScript

extends Node2D
class_name VisualTileMapRenderer
## Renders dungeon tiles using visual tile data from server
## Supports multiple tilemap sheets, layers, rotation, and flipping
## Now supports differential updates from admin editing
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 indexed by position for updates
var _tile_sprites: Array[Sprite2D] = []
var _tile_sprite_map: Dictionary = {} # "x,y,layer" -> Sprite2D
signal tiles_loaded
signal tiles_updated(count: int)
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()
## Update tiles from differential update (admin editing)
func update_tiles(tile_updates: Array) -> void:
if tile_updates.is_empty():
return
print("[VisualTileMap] Received %d tile updates" % tile_updates.size())
var updated_count := 0
for tile_data in tile_updates:
var x = int(tile_data.get("x", 0))
var y = int(tile_data.get("y", 0))
var layer = int(tile_data.get("l", 0))
var key = "%d,%d,%d" % [x, y, layer]
# Check if this is a removal (no sheet/frame data)
var sheet_id = int(tile_data.get("sid", 0))
var frame_idx = int(tile_data.get("frame", 0))
if sheet_id == 0:
# Remove tile at this position
if _tile_sprite_map.has(key):
var sprite = _tile_sprite_map[key]
if is_instance_valid(sprite):
sprite.queue_free()
_tile_sprite_map.erase(key)
updated_count += 1
else:
# Update or create tile
var existing_sprite = _tile_sprite_map.get(key)
if existing_sprite and is_instance_valid(existing_sprite):
# Update existing sprite
_update_sprite(existing_sprite, tile_data)
else:
# Create new sprite
if _render_tile(tile_data):
updated_count += 1
print("[VisualTileMap] Updated %d tiles" % updated_count)
tiles_updated.emit(updated_count)
## Add a new sheet dynamically (for admin-added sheets)
func add_sheet(sheet_data: Dictionary) -> void:
var sheet_id = int(sheet_data.get("id", 0))
if sheet_id == 0:
return
_sheet_info[sheet_id] = {
"path": sheet_data.get("path", ""),
"tile_w": int(sheet_data.get("tileW", 16)),
"tile_h": int(sheet_data.get("tileH", 16)),
"sheet_w": int(sheet_data.get("sheetW", 256)),
"sheet_h": int(sheet_data.get("sheetH", 256)),
"cols": int(sheet_data.get("cols", 16))
}
# Load texture for new sheet
var path = sheet_data.get("path", "")
if not path.is_empty() and not _sheet_textures.has(sheet_id):
var texture = await _load_texture(path)
if texture:
_sheet_textures[sheet_id] = texture
## 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
for tile_data in tiles:
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 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)
# Track in map for updates
var key = "%d,%d,%d" % [x, y, layer]
_tile_sprite_map[key] = sprite
return true
## Update an existing sprite with new tile data
func _update_sprite(sprite: Sprite2D, tile_data: Dictionary) -> void:
var sheet_id = int(tile_data.get("sid", 0))
var frame_idx = int(tile_data.get("frame", 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)
if not _sheet_textures.has(sheet_id):
return
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
var col = frame_idx % cols
var row = frame_idx / cols
sprite.texture = texture
sprite.region_rect = Rect2(col * tile_w, row * tile_h, tile_w, tile_h)
sprite.flip_h = flip_x
sprite.flip_v = flip_y
sprite.rotation_degrees = rotation * 90.0
## Clear all rendered tiles
func clear_tiles() -> void:
for sprite in _tile_sprites:
if is_instance_valid(sprite):
sprite.queue_free()
_tile_sprites.clear()
_tile_sprite_map.clear()
## Preload sheet textures (call during loading screen)
func preload_sheets(sheets: Array) -> void:
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))
}
await _load_sheet_textures()
## Get tile at position (for debugging/inspection)
func get_tile_at(x: int, y: int, layer: int = 0) -> Sprite2D:
var key = "%d,%d,%d" % [x, y, layer]
return _tile_sprite_map.get(key)