743 lines
23 KiB
GDScript
743 lines
23 KiB
GDScript
extends Node
|
|
|
|
## Update Manager
|
|
## Downloads and caches files from CDN, enabling hot-updates without client redeploy
|
|
## Files are stored at: {CDN_BASE_URL}/{cdnPath}
|
|
##
|
|
## For web builds: textures are kept in memory only (no disk cache)
|
|
## For desktop builds: textures are cached to disk
|
|
|
|
signal update_check_started
|
|
signal update_progress(downloaded: int, total: int, current_file: String)
|
|
signal update_completed(updated_count: int)
|
|
signal update_failed(error: String)
|
|
signal file_downloaded(file_path: String)
|
|
|
|
const LOCAL_CACHE_DIR = "user://cdn_cache/"
|
|
const MANIFEST_CACHE_FILE = "user://cdn_manifest.json"
|
|
const CLIENT_VERSION = "1.0.0"
|
|
|
|
var cdn_base_url: String = "https://assets.aeternalisgames.com/downloads/"
|
|
var _manifest: Dictionary = {} # filePath -> {fileHash, fileSize, version, assetType, cdnPath}
|
|
var _local_hashes: Dictionary = {} # filePath -> hash
|
|
var _download_queue: Array = []
|
|
var _is_updating: bool = false
|
|
var _files_downloaded: int = 0
|
|
var _files_total: int = 0
|
|
var _active_request: HTTPRequest = null
|
|
var _queued_files: Dictionary = {} # filePath -> true
|
|
var _pending_requests: Dictionary = {} # filePath -> priority (requested before manifest)
|
|
var _build_queue: Array = []
|
|
var _build_queue_active: bool = false
|
|
|
|
# Runtime loaded resources cache
|
|
var _loaded_scenes: Dictionary = {} # filePath -> PackedScene
|
|
var _loaded_textures: Dictionary = {} # filePath -> Texture2D
|
|
var _loaded_scripts: Dictionary = {} # filePath -> GDScript
|
|
|
|
# Web builds: store raw bytes in memory since disk access is unreliable
|
|
var _texture_bytes: Dictionary = {} # filePath -> PackedByteArray
|
|
var _is_web: bool = false
|
|
|
|
func _ready():
|
|
print("[UpdateManager] _ready called!")
|
|
print("[UpdateManager] OS.get_name(): %s" % OS.get_name())
|
|
print("[UpdateManager] OS.has_feature('web'): %s" % OS.has_feature("web"))
|
|
|
|
# Detect web platform
|
|
_is_web = OS.has_feature("web")
|
|
|
|
if _is_web:
|
|
print("[UpdateManager] Running on WEB - using memory-only cache")
|
|
_load_local_manifest_web()
|
|
else:
|
|
print("[UpdateManager] Running on DESKTOP - using disk cache")
|
|
# Ensure cache directory exists (desktop only)
|
|
DirAccess.make_dir_recursive_absolute(LOCAL_CACHE_DIR)
|
|
_load_local_manifest()
|
|
|
|
print("[UpdateManager] _ready complete!")
|
|
|
|
## Request manifest from server and check for updates
|
|
func check_for_updates():
|
|
print("[UpdateManager] check_for_updates() called")
|
|
|
|
if _is_updating:
|
|
push_warning("[UpdateManager] Already checking for updates")
|
|
return
|
|
|
|
update_check_started.emit()
|
|
|
|
if Network and Network.is_socket_connected():
|
|
print("[UpdateManager] Sending ASSET_MANIFEST_REQUEST")
|
|
Network.send_message(OpCodes.ASSET_MANIFEST_REQUEST, {})
|
|
else:
|
|
push_error("[UpdateManager] Network not connected, cannot check for updates")
|
|
update_failed.emit("Network not connected")
|
|
|
|
## Called by GameState when manifest response is received
|
|
func on_manifest_received(data: Dictionary):
|
|
print("[UpdateManager] on_manifest_received() called")
|
|
cdn_base_url = data.get("cdnBaseUrl", cdn_base_url)
|
|
print("[UpdateManager] CDN base URL: %s" % cdn_base_url)
|
|
var assets = data.get("assets", [])
|
|
print("[UpdateManager] Received %d assets in manifest" % assets.size())
|
|
|
|
_manifest.clear()
|
|
for asset in assets:
|
|
var file_path = asset.get("filePath", "")
|
|
if file_path.is_empty():
|
|
continue
|
|
|
|
var min_version = asset.get("minClientVersion", "")
|
|
if not min_version.is_empty() and _compare_versions(CLIENT_VERSION, min_version) < 0:
|
|
push_warning("[UpdateManager] Asset %s requires client version %s, we have %s" % [file_path, min_version, CLIENT_VERSION])
|
|
continue
|
|
|
|
_manifest[file_path] = {
|
|
"fileHash": asset.get("fileHash", ""),
|
|
"fileSize": asset.get("fileSize", 0),
|
|
"version": asset.get("version", 1),
|
|
"assetType": asset.get("assetType", 2),
|
|
"isRequired": asset.get("isRequired", false),
|
|
"cdnPath": asset.get("cdnPath", file_path)
|
|
}
|
|
|
|
print("[UpdateManager] Received manifest with %d files" % _manifest.size())
|
|
_check_for_updates()
|
|
_flush_pending_requests()
|
|
|
|
func _check_for_updates():
|
|
_download_queue.clear()
|
|
_queued_files.clear()
|
|
|
|
for file_path in _manifest:
|
|
var remote = _manifest[file_path]
|
|
var local_hash = _local_hashes.get(file_path, "")
|
|
|
|
if local_hash != remote.fileHash:
|
|
var entry = {
|
|
"filePath": file_path,
|
|
"cdnPath": remote.cdnPath,
|
|
"fileHash": remote.fileHash,
|
|
"fileSize": remote.fileSize,
|
|
"isRequired": remote.isRequired
|
|
}
|
|
_download_queue.append(entry)
|
|
_queued_files[file_path] = true
|
|
|
|
if _download_queue.is_empty():
|
|
print("[UpdateManager] All files up to date!")
|
|
update_completed.emit(0)
|
|
return
|
|
|
|
# Sort: required files first, then textures before scenes (so scenes can reference them)
|
|
_download_queue.sort_custom(func(a, b):
|
|
if a.isRequired != b.isRequired:
|
|
return a.isRequired
|
|
# Textures before scenes
|
|
var a_is_texture = a.filePath.ends_with(".png") or a.filePath.ends_with(".jpg")
|
|
var b_is_texture = b.filePath.ends_with(".png") or b.filePath.ends_with(".jpg")
|
|
return a_is_texture and not b_is_texture
|
|
)
|
|
|
|
_files_total = _download_queue.size()
|
|
_files_downloaded = 0
|
|
_is_updating = true
|
|
|
|
print("[UpdateManager] Need to download %d files" % _files_total)
|
|
_download_next()
|
|
|
|
func _download_next():
|
|
if _download_queue.is_empty():
|
|
_is_updating = false
|
|
_queued_files.clear()
|
|
if _is_web:
|
|
_save_local_manifest_web()
|
|
_save_local_manifest()
|
|
print("[UpdateManager] Update complete! Downloaded %d files" % _files_downloaded)
|
|
update_completed.emit(_files_downloaded)
|
|
return
|
|
|
|
var item = _download_queue.pop_front()
|
|
_queued_files.erase(item.filePath)
|
|
var url = cdn_base_url + item.cdnPath + "?h=" + item.fileHash
|
|
|
|
update_progress.emit(_files_downloaded, _files_total, item.filePath)
|
|
|
|
_active_request = HTTPRequest.new()
|
|
add_child(_active_request)
|
|
_active_request.request_completed.connect(_on_download_completed.bind(item))
|
|
|
|
print("[UpdateManager] Downloading: %s" % item.filePath)
|
|
var err = _active_request.request(url)
|
|
if err != OK:
|
|
push_error("[UpdateManager] Failed to start download for %s: %d" % [item.filePath, err])
|
|
_active_request.queue_free()
|
|
_active_request = null
|
|
_download_next()
|
|
|
|
func _on_download_completed(result: int, response_code: int, _headers: PackedStringArray, body: PackedByteArray, item: Dictionary):
|
|
if _active_request:
|
|
_active_request.queue_free()
|
|
_active_request = null
|
|
|
|
if result != HTTPRequest.RESULT_SUCCESS or response_code != 200:
|
|
push_error("[UpdateManager] Download failed for %s: result=%d, code=%d" % [item.filePath, result, response_code])
|
|
if item.isRequired:
|
|
update_failed.emit("Failed to download required file: " + item.filePath)
|
|
_is_updating = false
|
|
return
|
|
else:
|
|
# Skip optional file and continue
|
|
_download_next()
|
|
return
|
|
|
|
# Verify hash
|
|
var actual_hash = _compute_md5(body)
|
|
if actual_hash != item.fileHash:
|
|
push_error("[UpdateManager] Hash mismatch for %s: expected %s, got %s" % [item.filePath, item.fileHash, actual_hash])
|
|
_download_next()
|
|
return
|
|
|
|
# Store in memory cache (works for both web and desktop)
|
|
_texture_bytes[item.filePath] = body
|
|
_local_hashes[item.filePath] = item.fileHash
|
|
print("[UpdateManager] Stored in _texture_bytes: %s (%d bytes)" % [item.filePath, body.size()])
|
|
|
|
# For desktop, also save to disk for persistence
|
|
if not _is_web:
|
|
var cache_path = _get_cache_path(item.filePath)
|
|
var dir_path = cache_path.get_base_dir()
|
|
DirAccess.make_dir_recursive_absolute(dir_path)
|
|
|
|
var file = FileAccess.open(cache_path, FileAccess.WRITE)
|
|
if file:
|
|
file.store_buffer(body)
|
|
file.close()
|
|
else:
|
|
push_warning("[UpdateManager] Failed to save file to disk: %s" % cache_path)
|
|
|
|
_files_downloaded += 1
|
|
print("[UpdateManager] Emitting file_downloaded signal for: %s" % item.filePath)
|
|
file_downloaded.emit(item.filePath)
|
|
print("[UpdateManager] Downloaded: %s (%d bytes)" % [item.filePath, body.size()])
|
|
|
|
_download_next()
|
|
|
|
## Request a single file on-demand (web: useful if texture wasn't ready)
|
|
func request_file(file_path: String, priority: bool = false):
|
|
if file_path.is_empty():
|
|
return
|
|
if _manifest.is_empty():
|
|
print("[UpdateManager] request_file(%s) - manifest not loaded yet" % file_path)
|
|
_pending_requests[file_path] = priority
|
|
return
|
|
if not _is_web and _local_hashes.has(file_path):
|
|
return
|
|
if _queued_files.has(file_path):
|
|
return
|
|
if not _manifest.has(file_path):
|
|
print("[UpdateManager] request_file(%s) - not in manifest" % file_path)
|
|
return
|
|
|
|
var remote = _manifest[file_path]
|
|
var entry = {
|
|
"filePath": file_path,
|
|
"cdnPath": remote.cdnPath,
|
|
"fileHash": remote.fileHash,
|
|
"fileSize": remote.fileSize,
|
|
"isRequired": remote.isRequired
|
|
}
|
|
|
|
if priority:
|
|
_download_queue.push_front(entry)
|
|
else:
|
|
_download_queue.append(entry)
|
|
_queued_files[file_path] = true
|
|
if not _is_updating:
|
|
_files_total = _download_queue.size()
|
|
_files_downloaded = 0
|
|
_is_updating = true
|
|
_download_next()
|
|
|
|
func _flush_pending_requests():
|
|
if _manifest.is_empty() or _pending_requests.is_empty():
|
|
return
|
|
var pending = _pending_requests.duplicate()
|
|
var pending_paths = pending.keys()
|
|
_pending_requests.clear()
|
|
for file_path in pending_paths:
|
|
var priority = pending.get(file_path, false)
|
|
request_file(file_path, priority)
|
|
|
|
## Queue heavy build work (e.g., sprite frame construction) to one per frame.
|
|
func queue_build(cb: Callable):
|
|
if cb == null:
|
|
return
|
|
_build_queue.append(cb)
|
|
if not _build_queue_active:
|
|
_build_queue_active = true
|
|
call_deferred("_process_build_queue")
|
|
|
|
func _process_build_queue():
|
|
if _build_queue.is_empty():
|
|
_build_queue_active = false
|
|
return
|
|
var cb = _build_queue.pop_front()
|
|
cb.call()
|
|
# Run the next build on the next frame to avoid stalling the main thread.
|
|
call_deferred("_process_build_queue")
|
|
|
|
## Get the cache path for a file (preserves directory structure)
|
|
func _get_cache_path(file_path: String) -> String:
|
|
return LOCAL_CACHE_DIR + file_path
|
|
|
|
## Load a scene from cache (for mobs, effects, etc.)
|
|
## Textures are loaded separately and injected after scene instantiation
|
|
func load_scene(file_path: String) -> PackedScene:
|
|
# Check memory cache
|
|
if _loaded_scenes.has(file_path):
|
|
return _loaded_scenes[file_path]
|
|
|
|
# Check disk cache
|
|
var cache_path = _get_cache_path(file_path)
|
|
if not FileAccess.file_exists(cache_path):
|
|
push_warning("[UpdateManager] Scene not in cache: %s" % file_path)
|
|
return null
|
|
|
|
# Load the .tscn file
|
|
var file = FileAccess.open(cache_path, FileAccess.READ)
|
|
if not file:
|
|
return null
|
|
|
|
var content = file.get_as_text()
|
|
file.close()
|
|
|
|
# Extract texture paths that the scene needs (for pre-loading)
|
|
var texture_paths = _extract_texture_paths(content)
|
|
|
|
# Pre-load all textures into memory cache
|
|
for tex_path in texture_paths:
|
|
_preload_texture_for_scene(tex_path)
|
|
|
|
# Rewrite the scene to use embedded textures or remove ext_resources
|
|
content = _rewrite_scene_for_runtime(content)
|
|
|
|
# Parse and load the scene
|
|
var scene = _parse_tscn(content, file_path)
|
|
if scene:
|
|
_loaded_scenes[file_path] = scene
|
|
|
|
return scene
|
|
|
|
## Instantiate a scene and inject textures
|
|
## Call this instead of scene.instantiate() to get textures working
|
|
func instantiate_scene(file_path: String) -> Node:
|
|
var scene = load_scene(file_path)
|
|
if not scene:
|
|
return null
|
|
|
|
var instance = scene.instantiate()
|
|
|
|
# Inject textures into the instance
|
|
_inject_textures(instance, file_path)
|
|
|
|
return instance
|
|
|
|
## Extract texture paths from a .tscn file
|
|
func _extract_texture_paths(content: String) -> Array:
|
|
var paths = []
|
|
var regex = RegEx.new()
|
|
regex.compile('\\[ext_resource[^\\]]*path="res://([^"]+)"[^\\]]*type="Texture2D"')
|
|
|
|
for match in regex.search_all(content):
|
|
var path = match.get_string(1)
|
|
if not path in paths:
|
|
paths.append(path)
|
|
|
|
return paths
|
|
|
|
## Pre-load a texture that a scene needs
|
|
func _preload_texture_for_scene(res_path: String):
|
|
# res_path is like "assets/sprites/skeleton_idle_front.png"
|
|
var filename = res_path.get_file()
|
|
|
|
# Try to find this texture in our cache
|
|
var cache_path = _find_texture_in_cache(filename)
|
|
if cache_path.is_empty():
|
|
# Try with the full path structure
|
|
cache_path = _get_cache_path(res_path)
|
|
if not FileAccess.file_exists(cache_path):
|
|
push_warning("[UpdateManager] Texture not found for scene: %s" % res_path)
|
|
return
|
|
|
|
# Load it into memory cache if not already there
|
|
if not _loaded_textures.has(res_path):
|
|
var texture = _load_texture_from_path(cache_path)
|
|
if texture:
|
|
_loaded_textures[res_path] = texture
|
|
# Also cache by filename for easier lookup
|
|
_loaded_textures[filename] = texture
|
|
print("[UpdateManager] Pre-loaded texture: %s" % res_path)
|
|
|
|
## Load a texture from a file path (handles user:// paths properly)
|
|
func _load_texture_from_path(path: String) -> Texture2D:
|
|
if not FileAccess.file_exists(path):
|
|
return null
|
|
|
|
var image = Image.new()
|
|
var err = image.load(path)
|
|
if err != OK:
|
|
push_error("[UpdateManager] Failed to load image: %s (error %d)" % [path, err])
|
|
return null
|
|
|
|
return ImageTexture.create_from_image(image)
|
|
|
|
## Rewrite scene content to remove external texture references
|
|
## We'll inject textures at runtime instead
|
|
func _rewrite_scene_for_runtime(content: String) -> String:
|
|
# Remove ext_resource lines for Texture2D - we'll load them manually
|
|
var lines = content.split("\n")
|
|
var new_lines = []
|
|
var texture_resource_ids = []
|
|
|
|
# First pass: identify texture ext_resources
|
|
var ext_res_regex = RegEx.new()
|
|
ext_res_regex.compile('\\[ext_resource[^\\]]*type="Texture2D"[^\\]]*id="([^"]+)"')
|
|
|
|
for line in lines:
|
|
var match = ext_res_regex.search(line)
|
|
if match:
|
|
texture_resource_ids.append(match.get_string(1))
|
|
# Skip this line (don't add to new_lines)
|
|
continue
|
|
new_lines.append(line)
|
|
|
|
var result = "\n".join(new_lines)
|
|
|
|
# Update load_steps count
|
|
var steps_regex = RegEx.new()
|
|
steps_regex.compile('load_steps=(\\d+)')
|
|
var steps_match = steps_regex.search(result)
|
|
if steps_match:
|
|
var old_steps = int(steps_match.get_string(1))
|
|
var new_steps = old_steps - texture_resource_ids.size()
|
|
result = result.replace("load_steps=%d" % old_steps, "load_steps=%d" % new_steps)
|
|
|
|
return result
|
|
|
|
## Inject pre-loaded textures into a scene instance
|
|
func _inject_textures(instance: Node, scene_path: String):
|
|
# Find all AnimatedSprite2D and Sprite2D nodes
|
|
_inject_textures_recursive(instance)
|
|
|
|
func _inject_textures_recursive(node: Node):
|
|
if node is AnimatedSprite2D:
|
|
_fix_animated_sprite(node)
|
|
elif node is Sprite2D:
|
|
_fix_sprite(node)
|
|
|
|
for child in node.get_children():
|
|
_inject_textures_recursive(child)
|
|
|
|
func _fix_animated_sprite(sprite: AnimatedSprite2D):
|
|
if not sprite.sprite_frames:
|
|
return
|
|
|
|
var frames = sprite.sprite_frames
|
|
|
|
# Iterate through all animations
|
|
for anim_name in frames.get_animation_names():
|
|
var frame_count = frames.get_frame_count(anim_name)
|
|
|
|
for i in range(frame_count):
|
|
var texture = frames.get_frame_texture(anim_name, i)
|
|
|
|
# If texture is an AtlasTexture, we need to fix its atlas
|
|
if texture is AtlasTexture:
|
|
var atlas_tex = texture as AtlasTexture
|
|
if atlas_tex.atlas == null:
|
|
# Try to find and assign the atlas texture
|
|
# The atlas might be referenced by a resource path we can match
|
|
pass # Atlas is already null, nothing to fix here
|
|
elif texture == null:
|
|
# Frame has no texture, might need to inject one
|
|
pass
|
|
|
|
func _fix_sprite(sprite: Sprite2D):
|
|
# If the sprite has no texture, we could try to assign one
|
|
# But we need to know which texture it should have
|
|
pass
|
|
|
|
## Search for a texture file anywhere in the cache
|
|
func _find_texture_in_cache(filename: String) -> String:
|
|
var dir = DirAccess.open(LOCAL_CACHE_DIR)
|
|
if not dir:
|
|
return ""
|
|
|
|
return _find_file_recursive(dir, LOCAL_CACHE_DIR, filename)
|
|
|
|
func _find_file_recursive(dir: DirAccess, current_path: String, filename: String) -> String:
|
|
dir.list_dir_begin()
|
|
var item = dir.get_next()
|
|
while item != "":
|
|
var full_path = current_path + item
|
|
if dir.current_is_dir():
|
|
var subdir = DirAccess.open(full_path)
|
|
if subdir:
|
|
var found = _find_file_recursive(subdir, full_path + "/", filename)
|
|
if not found.is_empty():
|
|
return found
|
|
elif item == filename:
|
|
return full_path
|
|
item = dir.get_next()
|
|
return ""
|
|
|
|
## Load a texture from cache (for items, UI, etc.)
|
|
func load_texture(file_path: String) -> Texture2D:
|
|
# Check already-loaded texture cache
|
|
if _loaded_textures.has(file_path):
|
|
#iprint("[UpdateManager] load_texture(%s) - Found in _loaded_textures cache" % file_path)
|
|
return _loaded_textures[file_path]
|
|
|
|
var buffer: PackedByteArray
|
|
|
|
# Try memory cache first (works for web and desktop)
|
|
if _texture_bytes.has(file_path):
|
|
print("[UpdateManager] load_texture(%s) - Found in _texture_bytes, creating texture..." % file_path)
|
|
buffer = _texture_bytes[file_path]
|
|
elif not _is_web:
|
|
# Desktop: try disk cache
|
|
var cache_path = _get_cache_path(file_path)
|
|
if not FileAccess.file_exists(cache_path):
|
|
print("[UpdateManager] load_texture(%s) - Not in disk cache" % file_path)
|
|
return null
|
|
|
|
var file = FileAccess.open(cache_path, FileAccess.READ)
|
|
if not file:
|
|
print("[UpdateManager] load_texture(%s) - Failed to open cached file" % file_path)
|
|
return null
|
|
|
|
buffer = file.get_buffer(file.get_length())
|
|
file.close()
|
|
|
|
# Store in memory cache for faster subsequent access
|
|
_texture_bytes[file_path] = buffer
|
|
else:
|
|
# Texture not in cache - this is normal for optional textures on web
|
|
# The calling code should handle null gracefully
|
|
print("[UpdateManager] load_texture(%s) - Not in memory cache (web build)" % file_path)
|
|
request_file(file_path)
|
|
return null
|
|
|
|
var image = Image.new()
|
|
var err = image.load_png_from_buffer(buffer)
|
|
if err != OK:
|
|
err = image.load_jpg_from_buffer(buffer)
|
|
if err != OK:
|
|
err = image.load_webp_from_buffer(buffer)
|
|
|
|
if err != OK:
|
|
push_error("[UpdateManager] Failed to load image from buffer: %s (buffer size: %d bytes)" % [file_path, buffer.size()])
|
|
return null
|
|
|
|
print("[UpdateManager] load_texture(%s) - Successfully created texture from buffer" % file_path)
|
|
var texture = ImageTexture.create_from_image(image)
|
|
_loaded_textures[file_path] = texture
|
|
if _is_web:
|
|
# Free raw bytes once the texture exists to reduce memory spikes on web.
|
|
_texture_bytes.erase(file_path)
|
|
return texture
|
|
|
|
## Check if a file is in the cache (memory or disk)
|
|
func has_file(file_path: String) -> bool:
|
|
# Check memory cache first (works for both web and desktop)
|
|
if _texture_bytes.has(file_path):
|
|
return true
|
|
# Loaded textures count as cached for web (bytes may have been freed)
|
|
if _loaded_textures.has(file_path):
|
|
return true
|
|
|
|
# For desktop, also check disk cache
|
|
if not _is_web:
|
|
var cache_path = _get_cache_path(file_path)
|
|
return FileAccess.file_exists(cache_path)
|
|
|
|
return false
|
|
|
|
## Wait until all files are available (web: checks memory/loaded cache)
|
|
func wait_for_files(paths: Array) -> void:
|
|
var remaining: Dictionary = {}
|
|
for p in paths:
|
|
var file_path := str(p)
|
|
if file_path.is_empty():
|
|
continue
|
|
if not has_file(file_path):
|
|
remaining[file_path] = true
|
|
|
|
if remaining.is_empty():
|
|
return
|
|
|
|
while remaining.size() > 0:
|
|
var downloaded_path: String = await file_downloaded
|
|
if remaining.has(downloaded_path):
|
|
remaining.erase(downloaded_path)
|
|
# Clear any that may have been loaded via other paths
|
|
for key in remaining.keys():
|
|
if has_file(key):
|
|
remaining.erase(key)
|
|
|
|
## Prefetch a set of files (web: ensures bytes are downloaded before use)
|
|
func prefetch_files(paths: Array, priority: bool = true, wait: bool = true) -> void:
|
|
if paths.is_empty():
|
|
return
|
|
|
|
var missing: Array = []
|
|
for p in paths:
|
|
var file_path := str(p)
|
|
if file_path.is_empty():
|
|
continue
|
|
if has_file(file_path):
|
|
continue
|
|
missing.append(file_path)
|
|
|
|
if missing.is_empty():
|
|
return
|
|
|
|
for file_path in missing:
|
|
request_file(file_path, priority)
|
|
|
|
# If requested, wait only for these files
|
|
if wait:
|
|
await wait_for_files(missing)
|
|
|
|
## Get the local cache path for a file
|
|
func get_cache_path(file_path: String) -> String:
|
|
return _get_cache_path(file_path)
|
|
|
|
## Clear all cached files
|
|
func clear_cache():
|
|
_loaded_scenes.clear()
|
|
_loaded_textures.clear()
|
|
_loaded_scripts.clear()
|
|
_local_hashes.clear()
|
|
|
|
# Recursively delete cache directory
|
|
_delete_directory_recursive(LOCAL_CACHE_DIR)
|
|
DirAccess.make_dir_recursive_absolute(LOCAL_CACHE_DIR)
|
|
|
|
_save_local_manifest()
|
|
|
|
func _delete_directory_recursive(path: String):
|
|
var dir = DirAccess.open(path)
|
|
if not dir:
|
|
return
|
|
|
|
dir.list_dir_begin()
|
|
var item = dir.get_next()
|
|
while item != "":
|
|
var full_path = path + "/" + item
|
|
if dir.current_is_dir():
|
|
_delete_directory_recursive(full_path)
|
|
DirAccess.remove_absolute(full_path)
|
|
else:
|
|
DirAccess.remove_absolute(full_path)
|
|
item = dir.get_next()
|
|
|
|
# ============ Internal Methods ============
|
|
|
|
func _parse_tscn(content: String, file_path: String) -> PackedScene:
|
|
# Save as a temp .tscn file and load it
|
|
# Godot doesn't have a direct way to parse tscn from string
|
|
var temp_path = "user://temp_scene_%d.tscn" % randi()
|
|
var temp_file = FileAccess.open(temp_path, FileAccess.WRITE)
|
|
if temp_file:
|
|
temp_file.store_string(content)
|
|
temp_file.close()
|
|
|
|
var scene = load(temp_path) as PackedScene
|
|
# Clean up temp file
|
|
DirAccess.remove_absolute(temp_path)
|
|
return scene
|
|
|
|
return null
|
|
|
|
func _compute_md5(data: PackedByteArray) -> String:
|
|
var ctx = HashingContext.new()
|
|
ctx.start(HashingContext.HASH_MD5)
|
|
ctx.update(data)
|
|
var hash_bytes = ctx.finish()
|
|
return hash_bytes.hex_encode()
|
|
|
|
func _compare_versions(v1: String, v2: String) -> int:
|
|
var parts1 = v1.split(".")
|
|
var parts2 = v2.split(".")
|
|
|
|
for i in range(max(parts1.size(), parts2.size())):
|
|
var p1 = int(parts1[i]) if i < parts1.size() else 0
|
|
var p2 = int(parts2[i]) if i < parts2.size() else 0
|
|
if p1 < p2:
|
|
return -1
|
|
elif p1 > p2:
|
|
return 1
|
|
|
|
return 0
|
|
|
|
func _load_local_manifest():
|
|
if not FileAccess.file_exists(MANIFEST_CACHE_FILE):
|
|
return
|
|
|
|
var file = FileAccess.open(MANIFEST_CACHE_FILE, FileAccess.READ)
|
|
if not file:
|
|
return
|
|
|
|
var json_str = file.get_as_text()
|
|
file.close()
|
|
|
|
var json = JSON.new()
|
|
if json.parse(json_str) == OK and json.data is Dictionary:
|
|
_local_hashes = json.data
|
|
print("[UpdateManager] Loaded local manifest with %d files" % _local_hashes.size())
|
|
|
|
func _save_local_manifest():
|
|
var file = FileAccess.open(MANIFEST_CACHE_FILE, FileAccess.WRITE)
|
|
if file:
|
|
file.store_string(JSON.stringify(_local_hashes))
|
|
file.close()
|
|
|
|
const WEB_HASHES_KEY: String = "cdn_manifest_hashes_v1"
|
|
|
|
func _load_local_manifest_web() -> void:
|
|
if not _is_web:
|
|
return
|
|
|
|
# JavaScriptBridge is a class in web exports; keep it simple.
|
|
# eval() returns Variant, so type it explicitly.
|
|
var raw: Variant = JavaScriptBridge.eval("localStorage.getItem('%s')" % WEB_HASHES_KEY, true)
|
|
|
|
if raw == null:
|
|
return
|
|
|
|
var json_str: String = str(raw)
|
|
if json_str.is_empty():
|
|
return
|
|
|
|
var parsed: Variant = JSON.parse_string(json_str)
|
|
if parsed is Dictionary:
|
|
_local_hashes = parsed as Dictionary
|
|
print("[UpdateManager] (WEB) Loaded local hashes: %d" % _local_hashes.size())
|
|
|
|
func _save_local_manifest_web() -> void:
|
|
if not _is_web:
|
|
return
|
|
|
|
var json_str: String = JSON.stringify(_local_hashes)
|
|
|
|
# Safer than trying to nest JSON.stringify() inside an eval string:
|
|
# we escape backslashes and quotes so the JS string literal is valid.
|
|
var escaped: String = json_str.replace("\\", "\\\\").replace("'", "\\'")
|
|
|
|
var js: String = "localStorage.setItem('%s','%s')" % [WEB_HASHES_KEY, escaped]
|
|
JavaScriptBridge.eval(js, false)
|