352 lines
10 KiB
GDScript
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)
|