Godot 4 screen shake and hit-stop in one script

saltmire — Wed, 08 Jul 2026 22:28:12 +0000

"Game feel" is mostly a handful of cheap effects stacked on top of otherwise
normal gameplay. Two of the highest-impact ones are screen shake and
hit-stop. Here is how to do both in Godot 4 with code you can reuse.

Screen shake on a Camera2D

The trick is to offset the camera by a random amount each frame and decay that
amount over time. Attach this to your Camera2D:

extends Camera2D

var _trauma := 0.0        # 0..1, how much shake is queued
var _decay := 4.0         # how fast it fades per second
var _max_offset := 12.0   # pixels at full trauma

func shake(amount: float) -> void:
    _trauma = min(_trauma + amount, 1.0)

func _process(delta: float) -> void:
    if _trauma <= 0.0:
        offset = Vector2.ZERO
        return
    _trauma = max(_trauma - _decay * delta, 0.0)
    var t := _trauma * _trauma           # square it: small hits stay subtle
    offset = Vector2(
        randf_range(-1, 1) * _max_offset * t,
        randf_range(-1, 1) * _max_offset * t
    )

Call camera.shake(0.4) on a hit. Squaring the trauma (t = _trauma * _trauma)
is what makes it feel good — light hits barely nudge, big hits kick hard.

Hit-stop (freeze frames)

Hit-stop briefly freezes the game on impact so a hit reads as heavy. In Godot 4
you scale Engine.time_scale down, wait, then restore it. Use an unscaled timer
so the freeze itself is not slowed:

func hit_stop(duration := 0.08, scale := 0.05) -> void:
    Engine.time_scale = scale
    # ignore_time_scale so the wait runs in real time
    await get_tree().create_timer(duration, true, false, true).timeout
    Engine.time_scale = 1.0

await hit_stop() on a big hit. Keep it short — 60–120 ms is plenty. Longer than
that and the game feels laggy instead of punchy.

Stacking them

A satisfying hit usually fires several of these at once: shake + hit-stop + a
white flash on the sprite + damage numbers + a little particle burst. Each is a
few lines, but wiring all of them, tuned, for every hit type — light hit, heavy
hit, crit, death — is where the boilerplate piles up.

func on_enemy_hit(enemy, damage):
    camera.shake(0.3)
    await hit_stop()
    flash(enemy.sprite)
    spawn_damage_number(enemy.global_position, damage)
    # ...and a particle burst, and sound, per hit type

Skip the wiring

The individual effects are free to build. If you would rather call one function —
Impact.hit(enemy, "heavy") — and get shake, curved hit-stop, flash, damage
numbers and shader FX in tuned combos, that is what Saltmire Impact is. The
building-block pieces (Juice, FX, Trail, Spark) are free and open source; Impact
is the orchestrator that ties them together.

If you'd rather drop this in than build it, Saltmire Impact does it as a ready-made tool: https://saltmire.itch.io/saltmire-impact

Originally published at https://saltmire.github.io/godot-4-screen-shake-hit-stop.html

How to save and load your game in Godot 4 (the honest way)

saltmire — Wed, 08 Jul 2026 22:28:11 +0000

Every game needs to save state, and Godot 4 gives you everything you need in the
standard library. Here is a real, working system you can paste into a project
today — followed by the parts that quietly break in production.

The minimal version

Godot's FileAccess writes bytes; JSON turns a Dictionary into a string and
back. Put the two together and you have save/load:

const SAVE_PATH := "user://savegame.json"

func save_game(data: Dictionary) -> void:
    var f := FileAccess.open(SAVE_PATH, FileAccess.WRITE)
    f.store_string(JSON.stringify(data))
    f.close()

func load_game() -> Dictionary:
    if not FileAccess.file_exists(SAVE_PATH):
        return {}
    var f := FileAccess.open(SAVE_PATH, FileAccess.READ)
    var text := f.get_as_text()
    f.close()
    var parsed = JSON.parse_string(text)
    return parsed if typeof(parsed) == TYPE_DICTIONARY else {}

Call save_game({"hp": 80, "level": 3}) and later var d = load_game(). That is
genuinely all you need for a jam game.

Why `user://` and not `res://`

res:// is your project — it is read-only in an exported game. Always save to
user://, which maps to a real per-user folder on desktop and to IndexedDB on the
web export. Same API either way, so your code does not change per platform.

Multiple save slots

Do not hardcode one path. Key the filename by a slot name so you can build a
load-game menu:

func slot_path(slot: String) -> String:
    return "user://saves/%s.json" % slot

func save_to(slot: String, data: Dictionary) -> void:
    DirAccess.make_dir_recursive_absolute("user://saves")
    var f := FileAccess.open(slot_path(slot), FileAccess.WRITE)
    f.store_string(JSON.stringify(data))
    f.close()

To list existing slots for a menu, walk the directory with DirAccess.

The four things that bite later

The snippet above works — until real players use it. These are the problems that
turn a two-line save system into a two-week refactor:

Corruption. A crash or power-off mid-write leaves a half-written file. JSON.parse_string returns null and the player loses everything. The fix is to write to a temp file, then rename over the real one, and keep a rotating backup to restore from.
Save editing. A plain JSON file in user:// is trivial to open and edit — players will change their gold to 9999. If that matters, you need to encrypt the file (FileAccess.open_encrypted_with_pass).
Schema changes. You ship an update that renames coins to gold. Every existing save still has coins. Without a migration step, old saves crash or silently lose data.
Save size. A big world save is megabytes of JSON. gzip typically cuts that by ~90%, but only helps if you wire compression in from the start.

None of these are hard individually. The problem is that they all show up after
launch, one at a time, in bug reports.

If you just want it handled

You can build all four yourself — or drop in a tool that already has them, with a
headless self-test that proves each one with a real number. That is exactly what
Saltmire Save Lite (free) and Saltmire Save (the full version) are for: the same
one-line Save.write / Save.read API, with encryption, backups, migration and
compression when you need them.

If you'd rather drop this in than build it, Saltmire Save Lite does it as a ready-made tool: https://saltmire.itch.io/saltmire-save-lite

Originally published at https://saltmire.github.io/godot-4-save-load.html

DEV Community: saltmire