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)