Resources, saving & export

print(OS.get_user_data_dir())                  # absolute
print(ProjectSettings.globalize_path("user://saves"))
OS.shell_open(ProjectSettings.globalize_path("user://"))
var p := "user://saves".path_join("slot_1.json")

const PLAYER := preload("res://actors/player.tscn")
 
func _ready() -> void:
    var tex: Texture2D = load("res://art/icon.png")  # cached
    var fresh := ResourceLoader.load("user://save.tres",
        "", ResourceLoader.CACHE_MODE_IGNORE)
    if ResourceLoader.exists("res://levels/level_9.tscn"):
        pass

const LEVEL := "res://levels/level_2.tscn"
 
func start() -> void:
    ResourceLoader.load_threaded_request(LEVEL)
 
func _process(_d: float) -> void:
    var progress := []
    var status := ResourceLoader.load_threaded_get_status(
        LEVEL, progress)
    match status:
        ResourceLoader.THREAD_LOAD_IN_PROGRESS:
            $Bar.value = progress[0] * 100.0   # 0..1
        ResourceLoader.THREAD_LOAD_LOADED:
            var scene: PackedScene = \
                ResourceLoader.load_threaded_get(LEVEL)
            get_tree().change_scene_to_packed(scene)
            set_process(false)
        ResourceLoader.THREAD_LOAD_FAILED, \
        ResourceLoader.THREAD_LOAD_INVALID_RESOURCE:
            push_error("could not load " + LEVEL)
            set_process(false)

class_name SaveData
extends Resource
 
@export var level := "res://levels/level_1.tscn"
@export var position := Vector2.ZERO
@export var inventory: Dictionary[StringName, int] = {}
@export var flags: PackedStringArray = []

const PATH := "user://save.tres"   # .tres text, .res binary
 
func save_game(data: SaveData) -> void:
    var err := ResourceSaver.save(data, PATH)
    if err != OK:
        push_error(error_string(err))
 
func load_game() -> SaveData:
    if not ResourceLoader.exists(PATH):
        return SaveData.new()
    return ResourceLoader.load(PATH, "",
        ResourceLoader.CACHE_MODE_IGNORE) as SaveData

const SETTINGS := "user://settings.cfg"
var cfg := ConfigFile.new()
 
func load_settings() -> void:
    var err := cfg.load(SETTINGS)    # ERR_FILE_NOT_FOUND ok
    var vol: float = cfg.get_value("audio", "music", 0.8)
    var full: bool = cfg.get_value("video", "fullscreen",
        false)
    apply(vol, full)
 
func save_settings(vol: float, full: bool) -> void:
    cfg.set_value("audio", "music", vol)
    cfg.set_value("video", "fullscreen", full)
    cfg.save(SETTINGS)

[audio]
 
music=0.8
 
[video]
 
fullscreen=false

# Text
var f := FileAccess.open("user://log.txt", FileAccess.WRITE)
if f == null:
    push_error(error_string(FileAccess.get_open_error()))
    return
f.store_line("started")
f.store_string("no newline")
f.close()                     # or let it go out of scope
 
var text := FileAccess.get_file_as_string("user://log.txt")
var r := FileAccess.open("user://log.txt", FileAccess.READ)
while not r.eof_reached():
    print(r.get_line())
 
# Binary Variants (Godot's own serialization)
const BIN := "user://state.bin"
var w := FileAccess.open(BIN, FileAccess.WRITE)
w.store_var({"hp": 3, "pos": Vector2(4, 5)})
w.close()
var rd := FileAccess.open(BIN, FileAccess.READ)
var state: Dictionary = rd.get_var()   # objects refused

var data := {"name": "Ada", "level": 3, "tags": ["a", "b"]}
var text := JSON.stringify(data, "\t")      # pretty
 
var parsed = JSON.parse_string(text)        # null on error
if parsed is Dictionary:
    var level := int(parsed["level"])       # numbers: float
 
var json := JSON.new()                      # with errors
if json.parse(text) != OK:
    push_error("line %d: %s" % [
        json.get_error_line(), json.get_error_message()])
else:
    var d = json.data

DirAccess.make_dir_recursive_absolute("user://saves/slots")
print(DirAccess.dir_exists_absolute("user://saves"))
 
for file in DirAccess.get_files_at("user://saves"):
    if file.ends_with(".json"):
        print(file)
for dir in DirAccess.get_directories_at("user://"):
    print(dir)
 
DirAccess.rename_absolute("user://a.json", "user://b.json")
DirAccess.remove_absolute("user://b.json")   # file or
                                             # empty dir
var d := DirAccess.open("user://saves")
if d:
    print(d.get_space_left())

config_version=5
 
[application]
 
config/name="Slime Quest"
run/main_scene="res://main.tscn"
config/features=PackedStringArray("4.7", "GL Compatibility")
 
[display]
 
window/size/viewport_width=1280
window/size/viewport_height=720
window/stretch/mode="canvas_items"

var title: String = ProjectSettings.get_setting(
    "application/config/name")
if OS.has_feature("web"):
    $QuitButton.hide()          # no quitting a browser tab
if OS.has_feature("mobile"):
    $TouchControls.show()
if OS.is_debug_build():
    $DebugOverlay.show()

# Load a PCK exported separately (DLC, mods, patches)
func mount_dlc(path: String) -> bool:
    return ProjectSettings.load_resource_pack(path)
# then load("res://dlc/new_level.tscn") works

# CI: import assets (fresh checkouts have no .godot/)
godot --headless --path . --import
 
# Export with the preset's name as shown in the dialog
godot --headless --path . \
  --export-release "Web" build/web/index.html
godot --headless --path . \
  --export-debug "Windows Desktop" build/win/game.exe
godot --headless --path . \
  --export-pack "Linux" build/linux/game.pck
godot --headless --path . \
  --export-patch "Linux" build/patch_1.pck   # changed only
 
# Run a script (tests, tools) and exit
godot --headless --path . -s res://tools/build_atlas.gd
godot --headless --path . --check-only -s res://main.gd
 
# Run the game with debug helpers
godot --path . --debug-collisions --debug-navigation
godot --path . --rendering-method gl_compatibility
godot --path . --write-movie out.avi --fixed-fps 60

Required response headers for a threaded (Thread Support) build:
  Cross-Origin-Opener-Policy: same-origin
  Cross-Origin-Embedder-Policy: require-corp
MIME types:
  .wasm  application/wasm   (enables streaming compilation)
  .pck   application/octet-stream
Compression: pre-compress .wasm and .pck with brotli/gzip and
send Content-Encoding (gzip alone brings .wasm to about a quarter)

print_debug("state ", state)          # adds file:line
print_rich("[color=orange]warn[/color]")
print_verbose("only with --verbose")
var fps := Performance.get_monitor(Performance.TIME_FPS)
var mem := Performance.get_monitor(
    Performance.MEMORY_STATIC)
Performance.add_custom_monitor(
    "game/enemies", _count_enemies)   # Monitors tab
 
func _count_enemies() -> int:
    return get_tree().get_nodes_in_group("enemies").size()

# Godot 4+ cache: imported assets, editor state, credentials
.godot/
# Android Gradle build template (reinstallable)
/android/
# Local builds
build/

extends Node
 
const DIR := "user://saves"
const VERSION := 2
 
func save_slot(slot: int, data: Dictionary) -> Error:
    DirAccess.make_dir_recursive_absolute(DIR)
    var path := DIR.path_join("slot_%d.json" % slot)
    var tmp := path + ".tmp"
    data["version"] = VERSION
    var f := FileAccess.open(tmp, FileAccess.WRITE)
    if f == null:
        return FileAccess.get_open_error()
    f.store_string(JSON.stringify(data, "\t"))
    f.close()
    return DirAccess.rename_absolute(tmp, path)
 
func load_slot(slot: int) -> Dictionary:
    var path := DIR.path_join("slot_%d.json" % slot)
    if not FileAccess.file_exists(path):
        return {}
    var d = JSON.parse_string(
        FileAccess.get_file_as_string(path))
    if d is not Dictionary:
        push_warning("corrupt save " + path)
        return {}
    return _migrate(d)
 
func _migrate(d: Dictionary) -> Dictionary:
    if int(d.get("version", 1)) < 2:
        d["gold"] = d.get("coins", 0)   # renamed field
    return d

extends Node
 
const PATH := "user://settings.cfg"
var cfg := ConfigFile.new()
 
func _ready() -> void:
    cfg.load(PATH)                 # missing file is fine
    apply()
 
func setv(section: String, key: String, v: Variant) -> void:
    cfg.set_value(section, key, v)
    cfg.save(PATH)
    apply()
 
func apply() -> void:
    var full: bool = cfg.get_value("video", "fullscreen",
        false)
    DisplayServer.window_set_mode(
        DisplayServer.WINDOW_MODE_FULLSCREEN if full
        else DisplayServer.WINDOW_MODE_WINDOWED)
    var music: float = cfg.get_value("audio", "music", 0.8)
    var i := AudioServer.get_bus_index("Music")
    AudioServer.set_bus_volume_db(i, linear_to_db(music))

extends Control
 
var target := ""
 
func load_level(path: String) -> void:
    target = path
    ResourceLoader.load_threaded_request(path, "", true)
    set_process(true)
 
func _process(_d: float) -> void:
    var p := []
    var s := ResourceLoader.load_threaded_get_status(
        target, p)
    if s == ResourceLoader.THREAD_LOAD_IN_PROGRESS:
        %Bar.value = p[0] * 100.0
    elif s == ResourceLoader.THREAD_LOAD_LOADED:
        set_process(false)
        var scene: PackedScene = \
            ResourceLoader.load_threaded_get(target)
        get_tree().change_scene_to_packed(scene)
    else:
        set_process(false)
        push_error("failed to load " + target)

const root = "./build/web";
const headers = {
  "Cross-Origin-Opener-Policy": "same-origin",
  "Cross-Origin-Embedder-Policy": "require-corp",
};
 
Bun.serve({
  port: 8060,
  async fetch(req) {
    let path = new URL(req.url).pathname;
    if (path === "/") path = "/index.html";
    const file = Bun.file(root + path);
    if (!(await file.exists())) {
      return new Response("Not found", { status: 404 });
    }
    return new Response(file, { headers }); // MIME inferred
  },
});

name: export
on: [push]
jobs:
  web:
    runs-on: ubuntu-latest
    env:
      V: 4.7.2
    steps:
      - uses: actions/checkout@v4
      - name: Install Godot and templates
        run: |
          B=https://github.com/godotengine/godot/releases
          B=$B/download/$V-stable
          curl -sLO $B/Godot_v$V-stable_linux.x86_64.zip
          curl -sLO $B/Godot_v$V-stable_export_templates.tpz
          unzip -q Godot_v$V-stable_linux.x86_64.zip
          mv Godot_v$V-stable_linux.x86_64 godot
          T=~/.local/share/godot/export_templates/$V.stable
          mkdir -p $T
          unzip -q Godot_v$V-stable_export_templates.tpz
          mv templates/* $T/
      - name: Export
        run: |
          mkdir -p build/web
          ./godot --headless --path . --import
          ./godot --headless --path . \
            --export-release "Web" build/web/index.html
      - uses: actions/upload-artifact@v4
        with:
          name: web
          path: build/web

func _unhandled_input(event: InputEvent) -> void:
    if event.is_action_pressed("screenshot"):
        var img := get_viewport().get_texture().get_image()
        var stamp := Time.get_datetime_string_from_system() \
            .replace(":", "-")
        DirAccess.make_dir_recursive_absolute(
            "user://screenshots")
        img.save_png("user://screenshots/%s.png" % stamp)
        # thumbnail: img.resize(320, 180) before saving