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

820 lines
26 KiB
Markdown

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)