My samurai's attack felt like swinging at fog. Here's how I fixed it in Godot 4 (I also let AI try)

Chaowen Tan — Tue, 10 Nov 2026 04:59:34 +0000

My samurai's dash slash looked great in the sprite sheet preview. Then I dropped it into Godot, hit play, and he swung straight through the target like it was fog. The frames played. The target stood there. Nothing about it felt like a hit.

Here's the before:

And here's the after, recorded in Godot 4.7:

Same 8 frames. I didn't redraw anything. Everything that changed happens around the animation, in about 60 lines of GDScript.

The five tricks

1. Trigger effects on the impact frame, not on a timer. AnimatedSprite2D fires frame_changed every time the frame advances, so you can hang everything on the exact frame where the blade reaches the target. In my sheet that's frame 4:

func _on_frame_changed() -> void:
    if samurai.frame == 2:  # the lunge starts here
        create_tween().tween_property(samurai, "position:x", samurai.position.x + 250.0, 0.24) \
            .set_trans(Tween.TRANS_QUAD).set_ease(Tween.EASE_OUT)
    if samurai.frame == IMPACT_FRAME:
        hit(target_top.position)

The sheet draws the dash pose in place; the tween supplies the distance. If the slash ends short of the target, this is the number to change.

2. Hit-stop. Freeze the whole game for a tenth of a second on contact. Of the five, this one makes the biggest difference:

func hit(at: Vector2) -> void:
    Engine.time_scale = 0.05
    await get_tree().create_timer(0.1, true, false, true).timeout
    Engine.time_scale = 1.0

The last true is ignore_time_scale. Leave it out and the timer slows down along with everything else, so the "0.1 second" freeze lasts two full seconds.

3. Screen shake. Shake Camera2D.offset, not its position, and let it decay fast. Mine starts at 10 px and is gone in about a third of a second. A shake that outlasts the sound effect stops feeling like a hit and starts feeling like an earthquake.

4. A white flash. modulate = Color(4, 4, 4) pushes the target past its own colors to white, and a tween brings it back over 0.18 s.

5. Sparks and a clean cut. A CPUParticles2D with explosiveness = 1.0 and additive blending. Without additive blending my sparks looked like pale confetti on the stone floor. The target is one PNG drawn as two Sprite2Ds with region_rect, so on impact the top half pops up slightly, then falls and rotates. That little pop is what makes it look cut instead of dropped.

The full script (150 lines, everything built in code)

extends Node2D
# Recording scene for the article: a real SpriteFuse sheet + hit-stop, shake, flash, sparks and a clean slice.
const SHEET := preload("res://samurai-sheet.png")
const CELL := Vector2i(256, 256)
const COLUMNS := 4
const FRAME_COUNT := 8
const IMPACT_FRAME := 4
const FLOOR_Y := 712.0
const TARGET_SCALE := 0.19
const CUT_Y := 430  # slice height inside target.png, in source pixels
const EFFECTS := true  # false records the plain 'before' version

var samurai: AnimatedSprite2D
var target_top: Sprite2D
var target_bottom: Sprite2D
var cam: Camera2D
var shake := 0.0

func _ready() -> void:
    var bg := Sprite2D.new()
    bg.texture = load("res://dojo-bg.png")
    bg.centered = false
    add_child(bg)
    add_petals()

    var tex: Texture2D = load("res://target.png")
    var size := tex.get_size()
    target_bottom = make_half(tex, Rect2(0, CUT_Y, size.x, size.y - CUT_Y))
    target_bottom.offset = Vector2(-size.x / 2, -(size.y - CUT_Y))
    target_bottom.position = Vector2(1060, FLOOR_Y)
    target_top = make_half(tex, Rect2(0, 0, size.x, CUT_Y))
    target_top.offset = Vector2(-size.x / 2, -CUT_Y)
    target_top.position = Vector2(1060, FLOOR_Y - (size.y - CUT_Y) * TARGET_SCALE)

    samurai = AnimatedSprite2D.new()
    samurai.sprite_frames = build_frames(SHEET)
    samurai.scale = Vector2(1.35, 1.35)
    samurai.offset = Vector2(0, -110)    # pivot (128, 238) from animation.json
    samurai.position = Vector2(640, FLOOR_Y)
    add_child(samurai)
    samurai.frame_changed.connect(_on_frame_changed)

    cam = Camera2D.new()
    cam.position = Vector2(905, 515)
    cam.zoom = Vector2(0.85, 0.85)
    add_child(cam)

    await get_tree().create_timer(0.5).timeout
    samurai.play("dash_slash")

func make_half(tex: Texture2D, region: Rect2) -> Sprite2D:
    var s := Sprite2D.new()
    s.texture = tex
    s.centered = false
    s.region_enabled = true
    s.region_rect = region
    s.scale = Vector2(TARGET_SCALE, TARGET_SCALE)
    add_child(s)
    return s

func build_frames(sheet: Texture2D) -> SpriteFrames:
    var frames := SpriteFrames.new()
    frames.rename_animation("default", "dash_slash")
    frames.set_animation_speed("dash_slash", 10.0)
    frames.set_animation_loop("dash_slash", false)
    for i in FRAME_COUNT:
        var cell := AtlasTexture.new()
        cell.atlas = sheet
        cell.region = Rect2(Vector2(i % COLUMNS, i / COLUMNS) * Vector2(CELL), CELL)
        frames.add_frame("dash_slash", cell)
    return frames

func _on_frame_changed() -> void:
    if samurai.frame == 2:
        create_tween().tween_property(samurai, "position:x", samurai.position.x + 250.0, 0.24) \
            .set_trans(Tween.TRANS_QUAD).set_ease(Tween.EASE_OUT)
    if samurai.frame == IMPACT_FRAME and EFFECTS:
        hit(target_top.position + Vector2(0, -4))

func hit(at: Vector2) -> void:
    # 1. Hit-stop
    Engine.time_scale = 0.05
    await get_tree().create_timer(0.1, true, false, true).timeout
    Engine.time_scale = 1.0
    # 2. Screen shake
    shake = 10.0
    # 3. Flash both halves
    for half in [target_top, target_bottom]:
        half.modulate = Color(4, 4, 4)
        create_tween().tween_property(half, "modulate", Color.WHITE, 0.18)
    # 4. Sparks
    spawn_sparks(at)
    # 5. The slice: the top half slides off and drops to the floor
    var fall := create_tween()
    fall.tween_property(target_top, "position", target_top.position + Vector2(30, -8), 0.12).set_ease(Tween.EASE_OUT)
    fall.tween_property(target_top, "position", Vector2(target_top.position.x + 95, FLOOR_Y - 10), 0.45) \
        .set_trans(Tween.TRANS_QUAD).set_ease(Tween.EASE_IN)
    create_tween().tween_property(target_top, "rotation_degrees", 82.0, 0.57).set_trans(Tween.TRANS_QUAD).set_ease(Tween.EASE_IN)

func spawn_sparks(at: Vector2) -> void:
    var sparks := CPUParticles2D.new()
    sparks.position = at
    sparks.one_shot = true
    sparks.explosiveness = 1.0
    sparks.amount = 70
    sparks.lifetime = 0.6
    sparks.direction = Vector2(0.8, -1)
    sparks.spread = 75.0
    sparks.initial_velocity_min = 160.0
    sparks.initial_velocity_max = 360.0
    sparks.gravity = Vector2(0, 520)
    sparks.scale_amount_min = 5.0
    sparks.scale_amount_max = 8.0
    var ramp := Gradient.new()
    ramp.set_color(0, Color(1.0, 0.9, 0.45))
    ramp.set_color(1, Color(1, 0.35, 0.05, 0))
    sparks.color_ramp = ramp
    var glow := CanvasItemMaterial.new()
    glow.blend_mode = CanvasItemMaterial.BLEND_MODE_ADD
    sparks.material = glow
    sparks.emitting = true
    add_child(sparks)
    sparks.restart()

func add_petals() -> void:
    var petals := CPUParticles2D.new()
    petals.position = Vector2(900, 260)
    petals.emission_shape = CPUParticles2D.EMISSION_SHAPE_RECTANGLE
    petals.emission_rect_extents = Vector2(620, 10)
    petals.amount = 40
    petals.lifetime = 7.0
    petals.preprocess = 7.0
    petals.direction = Vector2(-0.4, 1)
    petals.spread = 20.0
    petals.initial_velocity_min = 30.0
    petals.initial_velocity_max = 60.0
    petals.gravity = Vector2(-6, 14)
    petals.angular_velocity_min = -90.0
    petals.angular_velocity_max = 90.0
    petals.scale_amount_min = 3.0
    petals.scale_amount_max = 5.0
    petals.color = Color(1.0, 0.72, 0.82)
    add_child(petals)

func _process(delta: float) -> void:
    if shake > 0.0:
        cam.offset = Vector2(randf_range(-shake, shake), randf_range(-shake, shake))
        shake = max(shake - 32.0 * delta, 0.0)
    else:
        cam.offset = Vector2.ZERO

Where the samurai came from

I didn't draw the character. I made it with SpriteFuse's Godot sprite sheet generator from one line of text:

A crimson-armored samurai with a long red scarf, side view facing right, crouches low, dashes forward and cuts a blazing horizontal arc of fire with his katana, then settles back into a ready stance.

It came back as 8 frames on a 4 × 2 grid of 256 px cells:

The export ZIP also has an animation.json with the grid, the frame timing and a pivot at the feet (128, 238). That pivot is why the code can set offset = Vector2(0, -110) once and the samurai stays on the floor in every frame. The temple background and the straw target are stand-in art I generated separately for the demo.

Don't code? I let AI write the whole thing

I wanted to know if someone who doesn't write GDScript could get the same result. So I gave OpenAI's latest model (gpt-6.1-sol, through the API) this prompt, with only the two images and the animation.json:

I'm making a 2D game in Godot 4 and I don't really code. I have two images in my project folder:
- samurai-sheet.png: a sprite sheet of an attack ("dash slash"). Here is its animation.json:
[paste the contents of your animation.json here]
- target.png: a straw target standing on a wooden post (about 296 x 976 px, transparent background).

Write ONE GDScript file I can attach to an empty Node2D. It should build everything in code:
1. Show the samurai on the left with its feet on the ground (use the pivot), and the target on the right, standing on the same ground line, with a Camera2D.
2. After half a second, play the attack once. Make it faster than the json timing, about 10 frames per second, and move the samurai forward during the dash so the slash reaches the target.
3. On the frame where the slash hits (frame 4, counting from 0), make it feel powerful: a 0.1 second hit-stop (freeze), a short screen shake, a white flash on the target, a burst of glowing orange sparks, and cut the target in two so the top half flies off and falls to the ground.

Use Godot 4 syntax only. After the code, tell me in 3 short steps where to put the files and how to run it.

It came back with a 367-line script and three setup steps. I pasted it into an empty Godot 4.7 project, changed nothing, and pressed play. It ran with no errors on the first try:

Honestly, better than I expected. It got the impact frame right, the hit-stop, the flash, the sparks and the cut. It even scaled the target to fit next to the character.

Where it needed a human:

It drew its own plain floor. No scene, no mood. Adding the background and framing the shot was my job.
The numbers were guesses. Reach, shake strength, how far the cut half flies. They worked, but the heavy, deliberate feel in my version came from tuning them by eye.
It wrote its own particle system across several dozen lines instead of using CPUParticles2D. That works, but it's more code to maintain than it needed.

If you try this yourself, three things made the prompt work: paste the real animation.json instead of describing the sheet, name the impact frame number, and ask for setup steps at the end.

What I learned

Hit-stop first. If you only add one effect, add the freeze. Three lines, and every other effect reads better because of it.
The impact frame is the whole trick. Find the first frame where the blade overlaps the target and hang everything on it.
AI is great at the first working version. It took one prompt and no edits. Making it feel heavy and deliberate was still about tuning five numbers by eye.

What's the one thing you add to every hit in your game: hit-stop, shake, or something weirder? I'd like to steal it. 👇

If you want to try it with your own character, the sprite sheet generator exports this same animation.json, and the full script above adapts to any row-major sheet: swap the images, then change the grid size and IMPACT_FRAME.

DEV Community: Chaowen Tan

My samurai's attack felt like swinging at fog. Here's how I fixed it in Godot 4 (I also let AI try)

The five tricks

Where the samurai came from

Don't code? I let AI write the whole thing

What I learned