Files
2026-02-16 08:56:15 -05:00

26 KiB

extends CanvasLayer

const WORLD_RUNTIME_FLAG := "application/config/world_runtime_enabled" const WORLD_DEBUG_PAYWALL_FLAG := "application/config/world_debug_show_paywalls" const MOVE_SEND_INTERVAL_MS := 100 const LOCAL_MOVE_SPEED := 160.0 const VISUAL_RECONCILE_RATE := 4.0 const VISUAL_SNAP_DISTANCE := 256.0

@onready var return_to_hub_btn = $Control/Panel/VBoxContainer/ReturnToHubBtn @onready var status_label = $Control/Panel/VBoxContainer/StatusLabel @onready var mode_label = $Control/Panel/VBoxContainer/ModeLabel @onready var connect_btn = $Control/Panel/VBoxContainer/ConnectBtn @onready var world_bg = $ColorRect @onready var menu_control = $Control @onready var menu_panel = $Control/Panel

var runtime = null var world_root: Node2D = null var visual_renderer: VisualTileMapRenderer = null var paywall_overlay: Node2D = null var tile_fallback_overlay: Node2D = null var object_container: Node2D = null var npc_container: Node2D = null var players_container: Node2D = null var player_marker: Node2D = null var world_camera: Camera2D = null var npc_scene: PackedScene = null var player_scene: PackedScene = null var other_player_scene: PackedScene = null var self_player_node: Node2D = null var other_player_nodes: Dictionary = {} # id -> Node2D var _show_paywall_debug: bool = false var _last_move_send_ms: int = 0 var _object_texture_cache: Dictionary = {} var _last_move_vec: Vector2 = Vector2.ZERO var _last_world_input_log_ms: int = 0 var _was_visible: bool = true var _last_sent_move_vec: Vector2 = Vector2.ZERO var _last_sent_facing: String = "" var _render_self_position: Vector2 = Vector2.ZERO var _has_render_self_position: bool = false

func _ready(): if return_to_hub_btn: return_to_hub_btn.pressed.connect(_on_return_to_hub_pressed) if connect_btn: connect_btn.pressed.connect(_on_connect_pressed) if GameState: GameState.state_changed.connect(_on_game_state_changed)

_init_world_nodes()
_setup_runtime()
_was_visible = visible

func _input(event: InputEvent): if runtime == null: return if runtime.mode != runtime.MODE_ACTIVE_WORLD: return if event.is_action_pressed("escape_menu"): if menu_panel: menu_panel.visible = not menu_panel.visible if world_bg: world_bg.visible = menu_panel.visible get_viewport().set_input_as_handled()

func _on_return_to_hub_pressed(): if GameState and GameState.has_method("return_to_hub_from_world"): GameState.return_to_hub_from_world()

func _process(delta: float): var is_now_visible = visible if _was_visible != is_now_visible: _was_visible = is_now_visible if not is_now_visible: # When this screen is hidden (state switched away), clear all world runtime/UI state. _reset_world_session()

if runtime == null:
	return
if runtime.mode != runtime.MODE_ACTIVE_WORLD:
	return
_handle_world_input(delta)
_update_render_self_position(delta)
_sync_player_marker()

func _setup_runtime(): var enabled = ProjectSettings.get_setting(WORLD_RUNTIME_FLAG, true) if not enabled: if status_label: status_label.text = "World runtime disabled by feature flag." if mode_label: mode_label.text = "Mode: disabled" if connect_btn: connect_btn.disabled = true return

var runtime_script = load("res://scripts/world/world_runtime_client.gd")
runtime = runtime_script.new()
add_child(runtime)
runtime.mode_changed.connect(_on_mode_changed)
runtime.chunk_refresh_required.connect(_on_chunk_refresh_required)
runtime.chunk_updated.connect(_on_chunk_updated)
runtime.chunk_unloaded.connect(_on_chunk_unloaded)
runtime.set_mode(runtime.MODE_CONNECTING)
if GameState:
	GameState.world_spawn_received.connect(_on_world_spawn_received)
	GameState.world_state_received.connect(_on_world_state_received)
	GameState.world_despawn_received.connect(_on_world_despawn_received)
if status_label:
	status_label.text = "World runtime ready. Connect to request spawn."

func _on_connect_pressed(): if runtime == null: return if runtime.mode == runtime.MODE_AWAITING_SPAWN or runtime.mode == runtime.MODE_ACTIVE_WORLD: return runtime.set_mode(runtime.MODE_AWAITING_SPAWN) if status_label: status_label.text = "Awaiting world spawn from server..." if GameState and GameState.has_method("request_world_spawn"): GameState.request_world_spawn()

func _on_mode_changed(mode: String): if mode_label: mode_label.text = "Mode: %s" % mode if connect_btn: connect_btn.disabled = (mode == runtime.MODE_AWAITING_SPAWN or mode == runtime.MODE_ACTIVE_WORLD) connect_btn.text = "Connected" if mode == runtime.MODE_ACTIVE_WORLD else "Connect World" if menu_panel: menu_panel.visible = mode != runtime.MODE_ACTIVE_WORLD if world_bg: world_bg.visible = mode != runtime.MODE_ACTIVE_WORLD

func _on_chunk_refresh_required(chunk_key: String): if status_label: status_label.text = "Chunk refresh required: %s" % chunk_key

func _on_world_spawn_received(data: Dictionary): if runtime == null: return runtime.apply_spawn(data) _render_self_position = Vector2( float(runtime.self_player.get("x", 0.0)), float(runtime.self_player.get("y", 0.0)) ) _has_render_self_position = true _rebuild_world_visuals() _rebuild_world_entities() _ensure_self_player_node() _update_player_entities() _sync_player_marker() # Spawn means world is active; force-hide menu in case stale UI toggles survived. if menu_panel: menu_panel.visible = false if world_bg: world_bg.visible = false if status_label: if runtime.chunk_cache.is_empty(): status_label.text = "World spawn received (no chunks in payload)." else: status_label.text = "World spawn received."

func _on_world_state_received(data: Dictionary): if runtime == null: return runtime.apply_world_state(data) _update_player_entities() _sync_player_marker() #_rebuild_world_entities()

func _on_world_despawn_received(data: Dictionary): if runtime == null: return runtime.set_mode(runtime.MODE_RECOVERING) if status_label: status_label.text = "World despawned: %s" % str(data.get("reason", "unknown")) if connect_btn: connect_btn.disabled = false connect_btn.text = "Connect World" _clear_player_entities()

func _on_game_state_changed(state: String): if state == "WORLD": # Always start world scene from a clean baseline before new connect/spawn. _reset_world_session() _prepare_world_entry_ui() return # Any non-world state should fully reset world session/UI to prevent stale re-entry. _reset_world_session()

func _on_chunk_updated(_chunk_key: String): _rebuild_world_visuals() _rebuild_world_entities()

func _on_chunk_unloaded(_chunk_key: String): _rebuild_world_visuals() _rebuild_world_entities()

func _init_world_nodes(): _show_paywall_debug = bool(ProjectSettings.get_setting(WORLD_DEBUG_PAYWALL_FLAG, false))

world_root = Node2D.new()
world_root.name = "WorldRoot"
add_child(world_root)
# Keep world above background but below menu/control.
var target_index = 1 if world_bg != null else 0
move_child(world_root, target_index)

visual_renderer = VisualTileMapRenderer.new()
visual_renderer.name = "WorldVisualRenderer"
world_root.add_child(visual_renderer)

paywall_overlay = Node2D.new()
paywall_overlay.name = "PaywallOverlay"
paywall_overlay.z_index = 5
world_root.add_child(paywall_overlay)

tile_fallback_overlay = Node2D.new()
tile_fallback_overlay.name = "TileFallbackOverlay"
tile_fallback_overlay.z_index = 2
world_root.add_child(tile_fallback_overlay)

object_container = Node2D.new()
object_container.name = "WorldObjects"
object_container.z_index = 20
world_root.add_child(object_container)

npc_container = Node2D.new()
npc_container.name = "WorldNpcs"
npc_container.z_index = 30
world_root.add_child(npc_container)

players_container = Node2D.new()
players_container.name = "WorldPlayers"
players_container.z_index = 35
world_root.add_child(players_container)

player_marker = Node2D.new()
player_marker.name = "SelfPlayer"
player_marker.z_index = 40
world_root.add_child(player_marker)
_create_player_marker_visual()

world_camera = Camera2D.new()
world_camera.name = "WorldCamera"
world_camera.enabled = true
world_camera.zoom = Vector2(1.3, 1.3)
world_root.add_child(world_camera)

if ResourceLoader.exists("res://scenes/dungeon/mob.tscn"):
	npc_scene = load("res://scenes/dungeon/mob.tscn")
if ResourceLoader.exists("res://scenes/dungeon/player.tscn"):
	player_scene = load("res://scenes/dungeon/player.tscn")
if ResourceLoader.exists("res://scenes/dungeon/other_player.tscn"):
	other_player_scene = load("res://scenes/dungeon/other_player.tscn")

func _create_player_marker_visual(): for child in player_marker.get_children(): child.queue_free() var sprite = Sprite2D.new() if SpriteGenerator: sprite.texture = SpriteGenerator.get_circle() sprite.modulate = Color(0.35, 0.9, 1.0, 1.0) sprite.scale = Vector2(0.8, 0.8) else: var poly = Polygon2D.new() poly.polygon = PackedVector2Array([ Vector2(-12, -12), Vector2(12, -12), Vector2(12, 12), Vector2(-12, 12) ]) poly.color = Color(0.35, 0.9, 1.0, 1.0) player_marker.add_child(poly) return player_marker.add_child(sprite)

func _sync_player_marker(): if runtime == null: return if not _has_render_self_position: _render_self_position = Vector2( float(runtime.self_player.get("x", 0.0)), float(runtime.self_player.get("y", 0.0)) ) _has_render_self_position = true var x = _render_self_position.x var y = _render_self_position.y if world_root: var viewport_center = get_viewport().get_visible_rect().size * 0.5 world_root.position = viewport_center - Vector2(x, y) if world_camera: world_camera.position = Vector2(x, y) if self_player_node and is_instance_valid(self_player_node): if player_marker: player_marker.visible = false self_player_node.position = Vector2(x, y) if self_player_node.has_method("set_player_name"): self_player_node.set_player_name(str(runtime.self_player.get("name", "You"))) if self_player_node.has_method("update_health"): var hp = int(runtime.self_player.get("health", 100)) var max_hp = int(runtime.self_player.get("maxHealth", runtime.self_player.get("max_health", 100))) self_player_node.update_health(hp, max_hp) if self_player_node.has_method("set_movement"): self_player_node.set_movement(_last_move_vec) return if player_marker: player_marker.visible = true player_marker.position = Vector2(x, y)

func _update_render_self_position(delta: float): if runtime == null: return var auth_pos = Vector2( float(runtime.self_player.get("x", 0.0)), float(runtime.self_player.get("y", 0.0)) ) if not _has_render_self_position: _render_self_position = auth_pos _has_render_self_position = true return

# Dungeon-like local render prediction while keeping server authoritative position as truth.
var predicted = _render_self_position + (_last_move_vec * LOCAL_MOVE_SPEED * delta)
var error = auth_pos - predicted
if error.length() > VISUAL_SNAP_DISTANCE:
	_render_self_position = auth_pos
	return
var alpha = min(1.0, delta * VISUAL_RECONCILE_RATE)
_render_self_position = predicted + (error * alpha)

func _handle_world_input(delta: float): var move_x = Input.get_axis("move_left", "move_right") var move_y = Input.get_axis("move_up", "move_down") var movement = Vector2(move_x, move_y) if movement.length() > 1.0: movement = movement.normalized()

var is_vip = bool(runtime.self_player.get("isVip", false))
var current_pos = Vector2(
	float(runtime.self_player.get("x", 0.0)),
	float(runtime.self_player.get("y", 0.0))
)
var target_pos = current_pos + movement * LOCAL_MOVE_SPEED * delta

# Keep world movement server-authoritative to avoid rubber-banding.
# We still evaluate local blocking to avoid sending obviously invalid movement spam.
if movement.length() > 0.0:
	var target_tile_x = int(floor(target_pos.x / float(runtime.TILE_SIZE)))
	var target_tile_y = int(floor(target_pos.y / float(runtime.TILE_SIZE)))
	var blocked = runtime.is_target_tile_blocked(target_tile_x, target_tile_y, is_vip)
	if blocked:
		movement = Vector2.ZERO
_last_move_vec = movement

var now_ms = Time.get_ticks_msec()
var facing = _movement_to_facing(movement)
var is_running = Input.is_key_pressed(KEY_SHIFT)
var time_since_last = now_ms - _last_move_send_ms
var moved_changed = movement != _last_sent_move_vec
var facing_changed = facing != _last_sent_facing
var should_send = moved_changed \
	or (movement.length() > 0.0 and time_since_last >= MOVE_SEND_INTERVAL_MS) \
	or (facing_changed and movement.length() > 0.0)

if not should_send:
	return

var seq = runtime.next_input_seq()
GameState.send_world_input(
	seq,
	movement.x,
	movement.y,
	is_running,
	facing
)
_last_move_send_ms = now_ms
_last_sent_move_vec = movement
_last_sent_facing = facing
if movement.length() > 0.0 and now_ms - _last_world_input_log_ms > 500:
	_last_world_input_log_ms = now_ms
	print("[World] INPUT seq=%d move=(%.2f,%.2f) pos=(%.1f,%.1f) run=%s" % [
		seq,
		movement.x,
		movement.y,
		float(runtime.self_player.get("x", 0.0)),
		float(runtime.self_player.get("y", 0.0)),
		str(is_running)
	])

func _movement_to_facing(movement: Vector2) -> String: if movement.length() < 0.001: return "" if absf(movement.x) >= absf(movement.y): return "right" if movement.x > 0.0 else "left" return "down" if movement.y > 0.0 else "up"

func _rebuild_world_visuals(): if runtime == null or visual_renderer == null: return

if paywall_overlay:
	_clear_children(paywall_overlay)
if tile_fallback_overlay:
	_clear_children(tile_fallback_overlay)

var sheets = runtime.tile_sheets.duplicate(true)
var available_sheet_ids: Dictionary = {}
for s in sheets:
	available_sheet_ids[int(s.get("id", 0))] = true
var visual_tiles: Array = []

for key in runtime.chunk_cache:
	var chunk_data = runtime.chunk_cache[key]
	var zone_x = int(chunk_data.get("zoneX", 0))
	var zone_y = int(chunk_data.get("zoneY", 0))
	var chunk_x = int(chunk_data.get("chunkX", 0))
	var chunk_y = int(chunk_data.get("chunkY", 0))

	for tile in chunk_data.get("tiles", []):
		var local_tile_x = int(tile.get("x", tile.get("tileX", 0)))
		var local_tile_y = int(tile.get("y", tile.get("tileY", 0)))
		var world_tile_x = runtime.world_tile_x(zone_x, chunk_x, local_tile_x)
		var world_tile_y = runtime.world_tile_y(zone_y, chunk_y, local_tile_y)
		var sheet_id = int(tile.get("sid", tile.get("sheetId", 0)))
		var frame_index = int(tile.get("frame", tile.get("frameIndex", 0)))

		visual_tiles.append({
			"x": world_tile_x,
			"y": world_tile_y,
			"l": int(tile.get("l", 0)),
			"sid": sheet_id,
			"frame": frame_index,
			"fx": bool(tile.get("fx", false)),
			"fy": bool(tile.get("fy", false)),
			"r": int(tile.get("r", 0))
		})

		if _show_paywall_debug and bool(tile.get("isInvisiblePaywall", false)):
			_add_paywall_debug_overlay(world_tile_x, world_tile_y)
		if not available_sheet_ids.has(sheet_id) and _fallback_sheet_path(sheet_id).is_empty():
			_add_fallback_tile_overlay(world_tile_x, world_tile_y, sheet_id)

# Render textured tiles when sheet metadata exists.
if sheets.is_empty():
	sheets = _build_fallback_world_sheets(visual_tiles)
if sheets.size() > 0:
	visual_renderer.render_visual_tiles({
		"sheets": sheets,
		"tiles": visual_tiles
	})
else:
	visual_renderer.clear_tiles()

func _build_fallback_world_sheets(visual_tiles: Array) -> Array: # WORLD_SPAWN payload currently sends sheetId/frameIndex but not sheet metadata. # Build a local fallback catalog so VisualTileMapRenderer can render. var used_sheet_ids: Dictionary = {} for t in visual_tiles: used_sheet_ids[int(t.get("sid", 0))] = true

var fallback_defs: Array = []
for sid in used_sheet_ids.keys():
	var sheet_id = int(sid)
	var path = _fallback_sheet_path(sheet_id)
	if path.is_empty():
		continue
	var cols = 16
	var sheet_w = 256
	var sheet_h = 256
	if ResourceLoader.exists(path):
		var tex = load(path)
		if tex and tex is Texture2D:
			var w = tex.get_width()
			var h = tex.get_height()
			if w > 0:
				cols = max(1, int(w / 16))
				sheet_w = w
			if h > 0:
				sheet_h = h
	fallback_defs.append({
		"id": sheet_id,
		"path": path,
		"tileW": 16,
		"tileH": 16,
		"sheetW": sheet_w,
		"sheetH": sheet_h,
		"cols": cols
	})
return fallback_defs

func _fallback_sheet_path(sheet_id: int) -> String: # Known runtime/default mapping. match sheet_id: 3: return "res://assets/sprites/Dungeon_Tileset.png" _: return ""

func _fallback_tile_color(sheet_id: int) -> Color: # Deterministic fallback color per sheet id when no sheet path is known. var hue = float(abs(sheet_id * 53) % 360) / 360.0 return Color.from_hsv(hue, 0.35, 0.8, 0.9)

func _add_paywall_debug_overlay(world_tile_x: int, world_tile_y: int): if paywall_overlay == null: return var tile_size = float(runtime.TILE_SIZE) var poly = Polygon2D.new() poly.color = Color(1.0, 0.2, 0.2, 0.35) poly.polygon = PackedVector2Array([ Vector2(0, 0), Vector2(tile_size, 0), Vector2(tile_size, tile_size), Vector2(0, tile_size) ]) poly.position = Vector2(world_tile_x * tile_size, world_tile_y * tile_size) poly.z_index = 1 paywall_overlay.add_child(poly)

func _add_fallback_tile_overlay(world_tile_x: int, world_tile_y: int, sheet_id: int): if tile_fallback_overlay == null: return var tile_size = float(runtime.TILE_SIZE) var poly = Polygon2D.new() poly.color = _fallback_tile_color(sheet_id) poly.polygon = PackedVector2Array([ Vector2(0, 0), Vector2(tile_size, 0), Vector2(tile_size, tile_size), Vector2(0, tile_size) ]) poly.position = Vector2(world_tile_x * tile_size, world_tile_y * tile_size) tile_fallback_overlay.add_child(poly)

func _clear_children(node: Node): for child in node.get_children(): child.queue_free()

func _ensure_self_player_node(): if players_container == null: return if self_player_node and is_instance_valid(self_player_node): return if player_scene: self_player_node = player_scene.instantiate() self_player_node.name = "SelfPlayerNode" players_container.add_child(self_player_node) if self_player_node.has_method("set_player_name"): self_player_node.set_player_name(str(runtime.self_player.get("name", "You"))) else: self_player_node = null

func _update_player_entities(): if runtime == null: return _ensure_self_player_node()

var seen_ids: Array = []
for pid in runtime.nearby_players.keys():
	seen_ids.append(pid)
	var player_data = runtime.nearby_players[pid]
	var node = other_player_nodes.get(pid, null)
	if node == null or not is_instance_valid(node):
		if other_player_scene:
			node = other_player_scene.instantiate()
			node.name = "OtherPlayer_%s" % str(pid)
			if players_container:
				players_container.add_child(node)
			other_player_nodes[pid] = node
		else:
			continue

	node.position = Vector2(
		float(player_data.get("x", 0.0)),
		float(player_data.get("y", 0.0))
	)
	if node.has_method("update_data"):
		var merged = player_data.duplicate(true)
		if not merged.has("id"):
			merged["id"] = pid
		if not merged.has("name"):
			merged["name"] = merged.get("playerName", "Player")
		node.update_data(merged)

var to_remove: Array = []
for pid in other_player_nodes.keys():
	if pid not in seen_ids:
		to_remove.append(pid)
for pid in to_remove:
	var node = other_player_nodes[pid]
	if node and is_instance_valid(node):
		node.queue_free()
	other_player_nodes.erase(pid)

func _clear_player_entities(): if self_player_node and is_instance_valid(self_player_node): self_player_node.queue_free() self_player_node = null for pid in other_player_nodes.keys(): var node = other_player_nodes[pid] if node and is_instance_valid(node): node.queue_free() other_player_nodes.clear()

func _prepare_world_entry_ui(): if menu_panel: menu_panel.visible = true if world_bg: world_bg.visible = true if connect_btn: connect_btn.disabled = false connect_btn.text = "Connect World" if status_label: status_label.text = "World runtime ready. Connect to request spawn." if runtime: runtime.set_mode(runtime.MODE_CONNECTING)

func _reset_world_session(): _last_move_send_ms = 0 _last_world_input_log_ms = 0 _last_move_vec = Vector2.ZERO _last_sent_move_vec = Vector2.ZERO _last_sent_facing = "" _render_self_position = Vector2.ZERO _has_render_self_position = false _clear_player_entities() if object_container: _clear_children(object_container) if npc_container: _clear_children(npc_container) if paywall_overlay: _clear_children(paywall_overlay) if tile_fallback_overlay: _clear_children(tile_fallback_overlay) if visual_renderer: visual_renderer.clear_tiles() if runtime: runtime.reset_runtime() if world_root: world_root.position = Vector2.ZERO if world_camera: world_camera.position = Vector2.ZERO if player_marker: player_marker.position = Vector2.ZERO player_marker.visible = true if menu_panel: menu_panel.visible = true if world_bg: world_bg.visible = true if connect_btn: connect_btn.disabled = false connect_btn.text = "Connect World" if mode_label: mode_label.text = "Mode: connecting" if status_label: status_label.text = "World runtime ready. Connect to request spawn."

func _rebuild_world_entities(): if runtime == null: return if object_container: _clear_children(object_container) if npc_container: _clear_children(npc_container)

for key in runtime.chunk_cache:
	var chunk_data = runtime.chunk_cache[key]

	for obj in chunk_data.get("objects", []):
		var object_pos = _resolve_entity_position(chunk_data, obj)
		_add_world_object_instance(object_pos, obj)

	for npc in chunk_data.get("npcs", []):
		var npc_pos = _resolve_entity_position(chunk_data, npc)
		_add_world_npc_instance(npc_pos, npc)
	for mob in chunk_data.get("mobs", []):
		var mob_pos = _resolve_entity_position(chunk_data, mob)
		_add_world_npc_instance(mob_pos, mob)

func _resolve_entity_position(chunk_data: Dictionary, entity: Dictionary) -> Vector2: # Runtime can emit either world pixel coords or chunk-local tile coords. if entity.has("worldX") and entity.has("worldY"): return Vector2(float(entity.get("worldX", 0.0)), float(entity.get("worldY", 0.0)))

var x = float(entity.get("x", 0.0))
var y = float(entity.get("y", 0.0))

var chunk_width_tiles = int(runtime.region.get("chunkWidthTiles", 0))
var chunk_height_tiles = int(runtime.region.get("chunkHeightTiles", 0))
if chunk_width_tiles > 0 and chunk_height_tiles > 0 and x >= 0.0 and y >= 0.0 and x < chunk_width_tiles and y < chunk_height_tiles:
	var zone_x = int(chunk_data.get("zoneX", 0))
	var zone_y = int(chunk_data.get("zoneY", 0))
	var chunk_x = int(chunk_data.get("chunkX", 0))
	var chunk_y = int(chunk_data.get("chunkY", 0))
	var tx = runtime.world_tile_x(zone_x, chunk_x, int(x))
	var ty = runtime.world_tile_y(zone_y, chunk_y, int(y))
	return Vector2((tx + 0.5) * runtime.TILE_SIZE, (ty + 0.5) * runtime.TILE_SIZE)

return Vector2(x, y)

func _add_world_object_marker(position: Vector2, label_text: String): if object_container == null: return var node = Node2D.new() node.position = position

var marker = Polygon2D.new()
marker.color = Color(0.95, 0.75, 0.25, 0.9)
marker.polygon = PackedVector2Array([
	Vector2(-8, -8),
	Vector2(8, -8),
	Vector2(8, 8),
	Vector2(-8, 8)
])
node.add_child(marker)

var label = Label.new()
label.text = label_text.left(16)
label.position = Vector2(-28, -26)
node.add_child(label)
object_container.add_child(node)

func _add_world_object_instance(position: Vector2, object_data: Dictionary): if object_container == null: return

var sprite_path = _resolve_object_sprite_path(object_data)
if sprite_path.is_empty():
	_add_world_object_marker(position, str(object_data.get("objectName", "Object")))
	return

var texture = _load_world_texture(sprite_path)
if texture == null:
	_add_world_object_marker(position, str(object_data.get("objectName", "Object")))
	return

var node = Node2D.new()
node.position = position

var sprite = Sprite2D.new()
sprite.texture = texture
sprite.centered = true
sprite.texture_filter = CanvasItem.TEXTURE_FILTER_NEAREST
var scale_value = float(object_data.get("scale", object_data.get("Scale", 1.0)))
if scale_value <= 0.0:
	scale_value = 1.0
sprite.scale = Vector2.ONE * scale_value
var tint = str(object_data.get("tintColor", object_data.get("TintColor", "")))
if not tint.is_empty():
	sprite.modulate = Color.from_string(tint, Color.WHITE)
node.add_child(sprite)

object_container.add_child(node)

func _resolve_object_sprite_path(object_data: Dictionary) -> String: var direct_keys = ["spritePath", "SpritePath", "path", "Path", "sprite", "Sprite"] for key in direct_keys: var value = str(object_data.get(key, "")) if not value.is_empty(): return value

var sprite_config = object_data.get("spriteConfig", object_data.get("SpriteConfig", null))
if sprite_config is Dictionary:
	if sprite_config.has("sheets"):
		var sheets = sprite_config.get("sheets", {})
		for sheet_key in sheets.keys():
			var info = sheets[sheet_key]
			if info is Dictionary:
				var path = str(info.get("path", ""))
				if not path.is_empty():
					return path
	if sprite_config.has("sprites"):
		var sprites = sprite_config.get("sprites", {})
		for anim in sprites.keys():
			var path = str(sprites[anim])
			if not path.is_empty():
				return path

var definition_id = int(object_data.get("objectDefinitionId", object_data.get("definitionId", -1)))
if definition_id >= 0:
	var local_path = "res://textures/objects/%d.png" % definition_id
	if ResourceLoader.exists(local_path):
		return local_path

return ""

func _load_world_texture(path: String) -> Texture2D: if _object_texture_cache.has(path): return _object_texture_cache[path]

var texture: Texture2D = null
if path.begins_with("res://"):
	if ResourceLoader.exists(path):
		texture = load(path)
elif UpdateManager:
	texture = UpdateManager.load_texture(path)

if texture != null:
	_object_texture_cache[path] = texture
return texture

func _add_world_npc_instance(position: Vector2, npc_data: Dictionary): if npc_container == null: return if npc_scene == null: _add_world_object_marker(position, str(npc_data.get("npcName", npc_data.get("name", "NPC")))) return

var npc_node = npc_scene.instantiate()
npc_node.position = position
if npc_node.has_method("update_data"):
	var merged = npc_data.duplicate(true)
	if not merged.has("name") and merged.has("npcName"):
		merged["name"] = merged["npcName"]
	npc_node.update_data(merged)
npc_container.add_child(npc_node)