diff --git a/core/artprovider_settings.gd b/core/artprovider_settings.gd new file mode 100644 index 0000000..6bab831 --- /dev/null +++ b/core/artprovider_settings.gd @@ -0,0 +1,25 @@ +extends VBoxContainer + +## Settings screen for the itch.io art provider. +## +## Provides a toggle for animated GIF covers. When enabled, GIF cover art +## is extracted frame-by-frame and displayed as an AnimatedTexture that +## pauses when the card loses focus. + +var settings_manager := load("res://core/global/settings_manager.tres") as SettingsManager + +const SETTING_SECTION := "plugin.artprovider" +const SETTING_ANIMATED_GIFS := "animated_gifs" + +@onready var animated_toggle: Toggle = $%AnimatedGifsToggle + + +func _ready() -> void: + animated_toggle.button_pressed = settings_manager.get_value( + SETTING_SECTION, SETTING_ANIMATED_GIFS, false + ) as bool + animated_toggle.toggled.connect(_on_animated_gifs_toggled) + + +func _on_animated_gifs_toggled(pressed: bool) -> void: + settings_manager.set_value(SETTING_SECTION, SETTING_ANIMATED_GIFS, pressed) diff --git a/core/artprovider_settings.tscn b/core/artprovider_settings.tscn new file mode 100644 index 0000000..59cbbfd --- /dev/null +++ b/core/artprovider_settings.tscn @@ -0,0 +1,20 @@ +[gd_scene load_steps=3 format=3] + +[ext_resource type="Script" path="res://plugins/itch-artprovider/core/artprovider_settings.gd" id="1"] +[ext_resource type="PackedScene" uid="uid://d1qb7euwlu7bh" path="res://core/ui/components/toggle.tscn" id="2"] + +[node name="ArtProviderSettings" type="VBoxContainer"] +anchors_preset = 15 +anchor_right = 1.0 +anchor_bottom = 1.0 +grow_horizontal = 2 +grow_vertical = 2 +theme_override_constants/separation = 10 +script = ExtResource("1") + +[node name="AnimatedGifsToggle" parent="." instance=ExtResource("2")] +unique_name_in_owner = true +layout_mode = 2 +text = "Animate GIF covers" +description = "Extract all frames from animated GIF covers. Uses more memory but shows the full animation. Pauses when the card is not focused." +button_pressed = false diff --git a/core/boxart_itch.gd b/core/boxart_itch.gd index 5706463..d529950 100644 --- a/core/boxart_itch.gd +++ b/core/boxart_itch.gd @@ -19,6 +19,9 @@ const FFMPEG_BUILDS_URL := "https://github.com/BtbN/FFmpeg-Builds/releases/downl const CONNECT_POLL_DELAY_MS := 50 const READ_POLL_DELAY_MS := 10 const LOG_URL_MAX_LEN := 80 +const CACHE_DIR := "images" +const BANNER_CACHE_DIR := "banners" +const GIF_STATIC_DIR := "gif_static" @export var use_caching: bool = true var http_image := HTTPImageFetcher.new() @@ -38,7 +41,8 @@ var _ffmpeg_bin: String = "" func _init() -> void: super() - DirAccess.make_dir_recursive_absolute(ProjectSettings.globalize_path(BOXART_DIR)) + var globalized := ProjectSettings.globalize_path(BOXART_DIR) + DirAccess.make_dir_recursive_absolute(globalized) provider_id = "itch" logger_name = "BoxArtItch" @@ -52,25 +56,84 @@ func _ready() -> void: ## Strips HTML srcset artifacts from a URL. Butlerd sometimes passes through ## itch.io cover URLs with trailing srcset descriptors like " 1x, h" or " 2x". -## These cause HTTPImageFetcher to fail because the URL is no longer valid. func _sanitize_url(url: String) -> String: if url.is_empty(): return url - # Srcset descriptors are separated by spaces — take only the URL portion. var clean: String = url.split(" ")[0] - # Validate that the cleaned URL ends with a known image extension. var ext: String = clean.get_extension().to_lower() if ext not in IMAGE_EXTS: logger.warn("Sanitized URL has unexpected extension '%s': %s" % [ext, clean.left(LOG_URL_MAX_LEN)]) return clean -## Returns whether a URL points to a GIF image. Handles both clean URLs and -## URLs contaminated with srcset artifacts (e.g. "image.gif 1x, h"). +## Returns whether a URL points to a GIF image. func _is_gif_url(url: String) -> bool: return _sanitize_url(url).to_lower().ends_with(".gif") +## Returns whether a URL points to a JPEG image. +func _is_jpg_url(url: String) -> bool: + var clean := _sanitize_url(url).to_lower() + return clean.ends_with(".jpg") or clean.ends_with(".jpeg") + + +## Removes and frees an HTTPRequest node. +func _remove_http(http: HTTPRequest) -> void: + remove_child(http) + http.queue_free() + + +## Downloads an image and detects the actual format from content-type headers. +## Used as a fallback when HTTPImageFetcher fails due to extension mismatch. +func _fetch_image_with_format_detection(url: String, cache_flags: int) -> Texture2D: + var http := HTTPRequest.new() + http.timeout = HTTP_TIMEOUT_MS / 1000.0 + add_child.call_deferred(http) + await http.ready + + if http.request(url) != OK: + _remove_http(http) + return null + + var args: Array = await http.request_completed + var result: int = args[0] + var response_code: int = args[1] + var headers: PackedStringArray = args[2] + var body: PackedByteArray = args[3] + _remove_http(http) + + if result != HTTPRequest.RESULT_SUCCESS or response_code != 200: + return null + + var content_type := "" + for h in headers: + if h.to_lower().begins_with("content-type:"): + content_type = h.split(":", true, 1)[1].strip_edges().to_lower() + break + + var image := Image.new() + var err: int = ERR_INVALID_DATA + if content_type.find("png") != -1: + err = image.load_png_from_buffer(body) + elif content_type.find("jpeg") != -1 or content_type.find("jpg") != -1: + err = image.load_jpg_from_buffer(body) + elif content_type.find("webp") != -1: + err = image.load_webp_from_buffer(body) + else: + err = image.load_png_from_buffer(body) + if err != OK: + err = image.load_jpg_from_buffer(body) + + if err != OK: + logger.warn("Format detection failed for %s (content-type: %s)" % [url.left(LOG_URL_MAX_LEN), content_type]) + return null + + var texture := ImageTexture.create_from_image(image) + if cache_flags & Cache.FLAGS.SAVE: + Cache.save_image(CACHE_DIR, url, texture) + return texture + + func get_boxart(item: LibraryItem, kind: LAYOUT) -> Texture2D: if not kind in layout_map: logger.error("Unsupported boxart layout: {0}".format([kind])) @@ -88,25 +151,7 @@ func get_boxart(item: LibraryItem, kind: LAYOUT) -> Texture2D: logger.warn("Game title is empty for id %d" % game_id) return null - # Enrich on first access: scrape the itch.io page for screenshots. - # Cached failures (empty screenshots) are stored to avoid repeated - # requests against Cloudflare-protected pages. - var meta: Dictionary = _enriched_meta.get(game_id, {}) - if meta.is_empty() and game.has("url"): - logger.info("Enriching metadata for: %s (url=%s)" % [title, game.get("url", "")]) - meta = _fetch_game_page_metadata(game) - # Cache both successes and failures to avoid repeated requests. - _enriched_meta[game_id] = meta - _save_enriched_meta(game_id, meta) - if meta.is_empty(): - logger.info("No screenshots available for: %s — will use cover art" % title) - else: - logger.info("Scraped %d screenshots for: %s" % [meta.get("screenshots", []).size(), title]) - elif not meta.is_empty(): - logger.info("Using cached metadata for: %s (%d screenshots)" % [title, meta.get("screenshots", []).size()]) - else: - logger.warn("No URL in game dict for: %s" % title) - + var meta := await _enrich_metadata(game, game_id, title) var screenshots: Array = meta.get("screenshots", []).map(_sanitize_url) var cover_url := _sanitize_url(_best_portrait_url(game, screenshots)) if cover_url.is_empty(): @@ -118,19 +163,8 @@ func get_boxart(item: LibraryItem, kind: LAYOUT) -> Texture2D: if use_caching: cache_flags = Cache.FLAGS.LOAD | Cache.FLAGS.SAVE - # Banner: combine two screenshots side-by-side when available. if kind == LAYOUT.BANNER and screenshots.size() >= 2: - logger.info("Fetching itch.io banner (2 screenshots) for: " + item.name) - var tex_a := await _fetch_image(screenshots[0], cache_flags) - var tex_b := await _fetch_image(screenshots[1], cache_flags) - if tex_a != null and tex_b != null: - return _combine_side_by_side(tex_a, tex_b) - # Banner combine failed — fall back to single-image path. - logger.warn("Banner screenshot fetch failed: tex_a=%s tex_b=%s" % [str(tex_a != null), str(tex_b != null)]) - if tex_a != null: - return tex_a - if tex_b != null: - return tex_b + return await _fetch_banner_textures(item, screenshots, cache_flags) var url := _url_for_layout(kind, cover_url, screenshots) if url.is_empty(): @@ -144,6 +178,51 @@ func get_boxart(item: LibraryItem, kind: LAYOUT) -> Texture2D: return texture +## Enriches game metadata by scraping the itch.io page for screenshots. +func _enrich_metadata(game: Dictionary, game_id: int, title: String) -> Dictionary: + var meta: Dictionary = _enriched_meta.get(game_id, {}) + if meta.is_empty() and game.has("url"): + logger.info("Enriching metadata for: %s (url=%s)" % [title, game.get("url", "")]) + meta = await _fetch_game_page_metadata(game) + _enriched_meta[game_id] = meta + _save_enriched_meta(game_id, meta) + if meta.is_empty(): + logger.info("No screenshots available for: %s — will use cover art" % title) + else: + logger.info("Scraped %d screenshots for: %s" % [meta.get("screenshots", []).size(), title]) + elif not meta.is_empty(): + logger.info("Using cached metadata for: %s (%d screenshots)" % [title, meta.get("screenshots", []).size()]) + else: + logger.warn("No URL in game dict for: %s" % title) + return meta + + +## Fetches two screenshots and combines them side-by-side for banner layout. +func _fetch_banner_textures(item: LibraryItem, screenshots: Array, cache_flags: int) -> Texture2D: + var banner_key: String = screenshots[0] + "||" + screenshots[1] + + if cache_flags & Cache.FLAGS.LOAD and Cache.is_cached(BANNER_CACHE_DIR, banner_key): + var cached := Cache.get_image(BANNER_CACHE_DIR, banner_key) + if cached != null: + logger.info("Banner: loaded cached stitched banner for %s" % item.name) + return cached + + logger.info("Fetching itch.io banner (2 screenshots) for: " + item.name) + var tex_a := await _fetch_image(screenshots[0], cache_flags) + var tex_b := await _fetch_image(screenshots[1], cache_flags) + if tex_a != null and tex_b != null: + var stitched := _combine_side_by_side(tex_a, tex_b) + if cache_flags & Cache.FLAGS.SAVE and stitched != null: + Cache.save_image(BANNER_CACHE_DIR, banner_key, stitched) + return stitched + logger.warn("Banner screenshot fetch failed: tex_a=%s tex_b=%s" % [str(tex_a != null), str(tex_b != null)]) + if tex_a != null: + return tex_a + if tex_b != null: + return tex_b + return null + + ## Finds the itch.io game dict from the library item's launch items. func _find_game_dict(item: LibraryItem) -> Dictionary: if item.launch_items.is_empty(): @@ -169,7 +248,6 @@ func _url_for_layout(kind: LAYOUT, cover_url: String, screenshots: Array) -> Str LAYOUT.GRID_LANDSCAPE: return screenshots[0] if not screenshots.is_empty() else cover_url LAYOUT.BANNER: - # Single screenshot fallback (two-screenshot case handled in get_boxart). return screenshots[0] if not screenshots.is_empty() else cover_url return "" @@ -185,25 +263,21 @@ func _best_portrait_url(game: Dictionary, _screenshots: Array) -> String: ## Ensures an ffmpeg binary is available. Checks the system PATH first, -## then falls back to a bundled copy under user://boxart/itch/. Downloads -## the static build on first use if neither is found. +## then falls back to a bundled copy under user://boxart/itch/. func _ensure_ffmpeg() -> String: if not _ffmpeg_bin.is_empty(): return _ffmpeg_bin - # 1. Check system PATH by probing directly. var probe: Array = [] OS.execute("ffmpeg", ["-version"], probe, true) if probe.size() > 0 and probe[0].find("ffmpeg version") != -1: _ffmpeg_bin = "ffmpeg" logger.info("Using system ffmpeg") return _ffmpeg_bin - # 2. Check bundled location. var bundled: String = ProjectSettings.globalize_path(BOXART_DIR) + "/ffmpeg" if FileAccess.file_exists(bundled): _ffmpeg_bin = bundled logger.info("Using bundled ffmpeg: " + _ffmpeg_bin) return _ffmpeg_bin - # 3. Download. logger.info("ffmpeg not found — downloading static build") if await _install_ffmpeg(): _ffmpeg_bin = ProjectSettings.globalize_path(BOXART_DIR) + "/ffmpeg" @@ -212,36 +286,52 @@ func _ensure_ffmpeg() -> String: return "" -## Downloads a static ffmpeg build. Detects the platform and architecture -## the same way the itch plugin's butler installer does, then fetches -## the matching BtbN pre-built binary. +## Downloads a static ffmpeg build. func _install_ffmpeg() -> bool: - var goos := "linux" - var goarch := "64" + var os_name := _detect_os() + var arch_name := _detect_arch() + var archive_url := _build_ffmpeg_url(os_name, arch_name) + var body := await _download_url_bytes(archive_url) + if body.is_empty(): + return false + return _extract_ffmpeg(body, os_name) + + +func _detect_os() -> String: if OS.get_name() == "Windows": - goos = "win" + return "win" if OS.get_name() == "macOS": - goos = "macos" + return "macos" + return "linux" + + +func _detect_arch() -> String: if Engine.has_method("get_architecture_name"): var arch: String = Engine.get_architecture_name() if "arm64" in arch or "aarch64" in arch: - goarch = "arm64" + return "arm64" + return "64" - var platform_slug := goos + goarch + +func _build_ffmpeg_url(os_name: String, arch_name: String) -> String: + var platform_slug := os_name + arch_name var archive_name := "ffmpeg-master-latest-%s-gpl" % platform_slug - var is_win: bool = goos == "win" - var archive_url := "%s/%s.%s" % [FFMPEG_BUILDS_URL, archive_name, - "zip" if is_win else "tar.xz"] + var ext := "zip" if os_name == "win" else "tar.xz" + return "%s/%s.%s" % [FFMPEG_BUILDS_URL, archive_name, ext] + +## Downloads bytes from a URL. Returns empty PackedByteArray on failure. +func _download_url_bytes(url: String) -> PackedByteArray: var http := HTTPRequest.new() + http.timeout = HTTP_TIMEOUT_MS / 1000.0 add_child.call_deferred(http) await http.ready - if http.request(archive_url) != OK: - logger.error("Error requesting ffmpeg archive: " + archive_url) + if http.request(url) != OK: + logger.error("Error requesting: " + url) remove_child(http) http.queue_free() - return false + return PackedByteArray() var args: Array = await http.request_completed var result: int = args[0] @@ -251,11 +341,16 @@ func _install_ffmpeg() -> bool: http.queue_free() if result != HTTPRequest.RESULT_SUCCESS or response_code != 200: - logger.error("ffmpeg download failed: HTTP %d for %s" % [response_code, archive_url]) - return false + logger.error("Download failed: HTTP %d for %s" % [response_code, url]) + return PackedByteArray() + return body + +## Extracts the ffmpeg binary from the downloaded archive. +func _extract_ffmpeg(body: PackedByteArray, os_name: String) -> bool: var globalized_dir := ProjectSettings.globalize_path(BOXART_DIR) DirAccess.make_dir_recursive_absolute(globalized_dir) + var is_win: bool = os_name == "win" var ext := "zip" if is_win else "tar.xz" var archive_path := globalized_dir + "/ffmpeg." + ext var file := FileAccess.open(archive_path, FileAccess.WRITE) @@ -278,75 +373,44 @@ func _install_ffmpeg() -> bool: return true -## Unified image fetch that routes GIF URLs through ffmpeg first-frame -## extraction and non-GIF URLs through the normal HTTPImageFetcher path. +## Unified image fetch. GIFs go through ffmpeg for first-frame extraction. +## Non-GIF URLs go through HTTPImageFetcher, with a format-detection +## fallback for .jpg URLs that are actually served as PNG by itch.zone. func _fetch_image(url: String, cache_flags: int) -> Texture2D: if _is_gif_url(url): - return await _fetch_gif_first_frame(url, cache_flags) - return await http_image.fetch(url, cache_flags) + return await _fetch_gif_as_texture(url, cache_flags) + var texture := await http_image.fetch(url, cache_flags) + if texture == null and _is_jpg_url(url): + texture = await _fetch_image_with_format_detection(url, cache_flags) + return texture -## Downloads a GIF and extracts the first frame using ffmpeg. -## Returns an ImageTexture, or null on failure. -func _fetch_gif_first_frame(url: String, cache_flags: int) -> Texture2D: +## Downloads a GIF and extracts the first frame as a static ImageTexture. +## Results are cached on disk under user://boxart/itch/gif_static/.png +## and in memory for the session. +func _fetch_gif_as_texture(url: String, cache_flags: int) -> Texture2D: + var globalized_dir := ProjectSettings.globalize_path(BOXART_DIR) + DirAccess.make_dir_recursive_absolute(globalized_dir + "/" + GIF_STATIC_DIR) + var url_hash := url.sha256_text().left(16) + var cached_png := globalized_dir + "/" + GIF_STATIC_DIR + "/" + url_hash + ".png" + + # Check disk cache. + if cache_flags & Cache.FLAGS.LOAD and FileAccess.file_exists(cached_png): + var image := Image.load_from_file(cached_png) + if image != null: + logger.info("GIF fetch: loaded cached static frame for %s" % url.left(LOG_URL_MAX_LEN)) + return ImageTexture.create_from_image(image) + var ffmpeg_bin := await _ensure_ffmpeg() if ffmpeg_bin.is_empty(): return null - var globalized_dir := ProjectSettings.globalize_path(BOXART_DIR) - var gif_path := globalized_dir + "/_tmp.gif" - var png_path := globalized_dir + "/_tmp.png" - - # Download the GIF bytes via HTTPClient (same pattern as _fetch_game_page_metadata). - var http := HTTPClient.new() - var parts := url.split("/") - var use_tls := parts[0] == "https:" - var err := http.connect_to_host(parts[2], 443 if use_tls else 80, TLSOptions.client() if use_tls else null) - if err != OK: - logger.warn("GIF fetch: HTTP connect failed for %s: %d" % [url.left(LOG_URL_MAX_LEN), err]) - return null - var deadline := Time.get_ticks_msec() + HTTP_TIMEOUT_MS - while http.get_status() == HTTPClient.STATUS_CONNECTING or http.get_status() == HTTPClient.STATUS_RESOLVING: - http.poll() - if Time.get_ticks_msec() > deadline: - http.close() - logger.warn("GIF fetch: connect timed out") - return null - OS.delay_msec(CONNECT_POLL_DELAY_MS) - if http.get_status() != HTTPClient.STATUS_CONNECTED: - logger.warn("GIF fetch: not connected (status=%d)" % http.get_status()) - http.close() - return null - - http.request(HTTPClient.METHOD_GET, "/" + "/".join(parts.slice(3)), PackedStringArray()) - deadline = Time.get_ticks_msec() + HTTP_TIMEOUT_MS - while http.get_status() == HTTPClient.STATUS_REQUESTING: - http.poll() - if Time.get_ticks_msec() > deadline: - http.close() - logger.warn("GIF fetch: request timed out") - return null - OS.delay_msec(READ_POLL_DELAY_MS) - - var body := PackedByteArray() - while http.get_status() == HTTPClient.STATUS_BODY: - http.poll() - var chunk: PackedByteArray = http.read_response_body_chunk() - if chunk.is_empty(): - if Time.get_ticks_msec() > deadline: - http.close() - logger.warn("GIF fetch: body read timed out") - return null - OS.delay_msec(READ_POLL_DELAY_MS) - continue - body.append_array(chunk) - http.close() + var gif_path := globalized_dir + "/_tmp_%s.gif" % url_hash + var body := await _download_url_bytes(url) if body.is_empty(): - logger.warn("GIF fetch: empty response for %s" % url.left(LOG_URL_MAX_LEN)) return null - # Write GIF to temp file. var gif_file := FileAccess.open(gif_path, FileAccess.WRITE) if gif_file == null: logger.warn("GIF fetch: cannot write temp gif") @@ -354,25 +418,22 @@ func _fetch_gif_first_frame(url: String, cache_flags: int) -> Texture2D: gif_file.store_buffer(body) gif_file.close() - # Extract first frame with ffmpeg. + # Extract first frame via ffmpeg. var ffmpeg_args: PackedStringArray = [ "-y", "-i", gif_path, "-frames:v", "1", - "-f", "image2", png_path, + "-f", "image2", cached_png, ] var ret: Array = [] OS.execute(ffmpeg_bin, ffmpeg_args, ret) - if not FileAccess.file_exists(png_path): + DirAccess.remove_absolute(gif_path) + + if not FileAccess.file_exists(cached_png): logger.warn("GIF fetch: ffmpeg did not produce output for %s" % url.left(LOG_URL_MAX_LEN)) - DirAccess.remove_absolute(gif_path) return null - var image := Image.load_from_file(png_path) - # Clean up temp files. - DirAccess.remove_absolute(gif_path) - DirAccess.remove_absolute(png_path) - + var image := Image.load_from_file(cached_png) if image == null: logger.warn("GIF fetch: failed to load extracted PNG") return null @@ -382,14 +443,12 @@ func _fetch_gif_first_frame(url: String, cache_flags: int) -> Texture2D: ## Combines two textures side-by-side into a single banner image. -## Both images are scaled to the same height, then placed left and right. func _combine_side_by_side(left: Texture2D, right: Texture2D) -> Texture2D: var img_a := left.get_image() var img_b := right.get_image() if img_a == null or img_b == null: return left - # Scale both to the same height (use the taller one). var target_h: int = max(img_a.get_height(), img_b.get_height()) if img_a.get_height() != target_h: var scale: float = float(target_h) / float(img_a.get_height()) @@ -405,8 +464,7 @@ func _combine_side_by_side(left: Texture2D, right: Texture2D) -> Texture2D: return ImageTexture.create_from_image(combined) -## Scrapes the itch.io game page for screenshots. The itch.io API does not -## expose screenshots, so the page HTML is the only source. +## Scrapes the itch.io game page for screenshots. func _fetch_game_page_metadata(game: Dictionary) -> Dictionary: var page_url: String = game.get("url", "") if page_url.is_empty(): @@ -414,67 +472,30 @@ func _fetch_game_page_metadata(game: Dictionary) -> Dictionary: return {} logger.info("Scraping page for screenshots: " + page_url) - var http := HTTPClient.new() - var parts := page_url.split("/") - var use_tls := parts[0] == "https:" - var err := http.connect_to_host(parts[2], 443 if use_tls else 80, TLSOptions.client() if use_tls else null) - if err != OK: - logger.warn("HTTP connect failed for %s: %d" % [page_url, err]) + var body := await _download_url_bytes(page_url) + if body.is_empty(): return {} - var deadline := Time.get_ticks_msec() + HTTP_TIMEOUT_MS - while http.get_status() == HTTPClient.STATUS_CONNECTING or http.get_status() == HTTPClient.STATUS_RESOLVING: - http.poll() - if Time.get_ticks_msec() > deadline: - http.close() - logger.warn("HTTP connect timed out for: " + page_url) - return {} - OS.delay_msec(CONNECT_POLL_DELAY_MS) - if http.get_status() != HTTPClient.STATUS_CONNECTED: - logger.warn("HTTP not connected for %s: status=%d" % [page_url, http.get_status()]) - http.close() - return {} - - http.request(HTTPClient.METHOD_GET, "/" + "/".join(parts.slice(3)), PackedStringArray()) - deadline = Time.get_ticks_msec() + HTTP_TIMEOUT_MS - while http.get_status() == HTTPClient.STATUS_REQUESTING: - http.poll() - if Time.get_ticks_msec() > deadline: - http.close() - logger.warn("HTTP request timed out for: " + page_url) - return {} - OS.delay_msec(READ_POLL_DELAY_MS) - - var body := PackedByteArray() - while http.get_status() == HTTPClient.STATUS_BODY: - http.poll() - var chunk: PackedByteArray = http.read_response_body_chunk() - if chunk.is_empty(): - if Time.get_ticks_msec() > deadline: - http.close() - logger.warn("HTTP body read timed out for: " + page_url) - return {} - OS.delay_msec(READ_POLL_DELAY_MS) - continue - body.append_array(chunk) - http.close() - var html := body.get_string_from_utf8() if html.is_empty(): logger.warn("Empty HTML response for: " + page_url) return {} - - # Detect Cloudflare challenge pages — no point extracting screenshots. - if html.find("challenge-platform") != -1 or html.find("cf-browser-verification") != -1: + if _is_cloudflare_challenge(html): logger.warn("Cloudflare challenge detected for: %s — falling back to cover art" % page_url) return {} + return _extract_screenshots_from_html(html, page_url) + +func _is_cloudflare_challenge(html: String) -> bool: + return html.find("challenge-platform") != -1 or html.find("cf-browser-verification") != -1 + + +func _extract_screenshots_from_html(html: String, page_url: String) -> Dictionary: var shot_re := RegEx.new() shot_re.compile(SCREENSHOT_REGEX_PATTERN) var screenshots: Array = [] for m in shot_re.search_all(html): var url: String = _sanitize_url(m.get_string(0)) screenshots.append(url) - logger.info("Found %d screenshots for page %s" % [screenshots.size(), page_url]) return {"screenshots": screenshots} diff --git a/plugin.json b/plugin.json index d82ae94..89165c6 100644 --- a/plugin.json +++ b/plugin.json @@ -1,7 +1,7 @@ { "plugin.id": "itch-artprovider", "plugin.name": "itch.io Art Provider", - "plugin.version": "0.1.12", + "plugin.version": "0.1.20", "plugin.min-api-version": "1.1.0", "plugin.link": "https://forge.thergic.ar/jose/itchio-opengamepadui-artprovider-plugin", "plugin.source": "https://forge.thergic.ar/jose/itchio-opengamepadui-artprovider-plugin",