← OUTLINE

Save Point

The quest log

Quest log

← OUTLINE

Feel

The same game twice

Same game, twice

• Stretch on takeoff, squash on landing, a puff of dust.
• On the spike: the world freezes, the sprite flashes, the screen jolts, then home.
• Five changes, and the second game is the one people want to keep playing.

Game feel

• The mechanics answer what happened. Juice answers it louder and faster, so the player never has to ask.
• Players report juice as "it feels good" and its absence as "it feels floaty," and almost never as anything more specific.

Six channels

The rules of juice

• Feel never changes mechanics. Scale the sprite and leave the body alone. A squash that moves a landing is a bug.
• Snap in, ease out. The effect is instant; the recovery is the tween. The other way around reads as mush.
• Stack channels on one moment. One trick is a gimmick. Three tricks on the same frame is a feeling.
• Every number is a dial. An @export you can turn while the game runs. You will overshoot, then settle.
• Legible first. Juice tells the player what happened. If it hides the player or eats input, it is noise.

← OUTLINE

The Toolkit

Tweens, shake, hit stop, particles, and sound, in Godot

A Tween, in three lines

var tween := create_tween()
tween.tween_property(sprite, "scale", Vector2.ONE, 0.18)
tween.set_trans(Tween.TRANS_BACK).set_ease(Tween.EASE_OUT)

• A Tween animates one property from wherever it is to a target, over a time, then frees itself.
• tween_property(object, "property", target, seconds). Chain another call and it runs after; parallel() runs it alongside.
• Trans picks the curve (linear, sine, back, bounce, elastic). Ease picks which end gets the curve: EASE_OUT is fast then settling.
• TRANS_BACK with EASE_OUT overshoots the target a little before it lands. That overshoot reads as bounce.

Snap in, ease out

func _squash(to: Vector2) -> void:
    if squash_tween:
        squash_tween.kill()
    sprite.scale = to
    squash_tween = create_tween()
    squash_tween.tween_property(
        sprite, "scale", Vector2.ONE, squash_time
    ).set_trans(Tween.TRANS_BACK).set_ease(Tween.EASE_OUT)

• sprite.scale = to is the snap: instant. The tween only brings it back to Vector2.ONE.
• kill() first. A landing that interrupts a jump would otherwise leave two tweens fighting over one property.
• Only sprite scales. The body and its collision shape never hear about it: rule one.
• jump_squash, land_squash, and squash_time are exports. Dials.

The door is where it lives

func _change_state(new_state: State) -> void:
    var old_state := state
    state = new_state
    sprite.texture = TEXTURES[new_state]
    if old_state == State.AIR and new_state != State.AIR:
        _land()

func _jump() -> void:
    velocity.y = jump_velocity
    _squash(jump_squash)
    _play(jump_sound)

func _land() -> void:
    _squash(land_squash)
    dust.restart()
    _play(land_sound)

Shake is a camera job

extends Camera2D
## Screen shake. One job: jitter the camera's offset, then settle.

@export var decay: float = 60.0   # pixels of shake lost per second

var strength: float = 0.0

func shake(amount: float) -> void:
    strength = amount

func _process(delta: float) -> void:
    if strength <= 0.0:
        offset = Vector2.ZERO
        return
    offset = Vector2(randf_range(-strength, strength),
        randf_range(-strength, strength))
    strength = move_toward(strength, 0.0, decay * delta)

• offset nudges the view without moving the camera's position. It exists for this.
• Each frame: a random point inside a square of the current strength.
• move_toward walks the strength to zero at decay pixels per second, then the offset snaps home.
• One job, one script, one public method: shake(amount). The brain calls it; the camera decides nothing.

Stopping time

func hit_stop(scale: float, seconds: float) -> void:
    Engine.time_scale = scale
    await get_tree().create_timer(seconds, true, false, true).timeout
    Engine.time_scale = 1.0

• await parks the function until the timer fires, then the last line runs. Nothing else waits.
• The same function with 0.3 for half a second is slow motion. Two moods, one line of code.

The hit, in order

func respawn() -> void:
    if respawning:
        return
    respawning = true
    velocity = Vector2.ZERO
    died.emit()
    _flash()
    _play(hit_sound)
    await get_tree().create_timer(
        flash_time, true, false, true).timeout
    position = spawn_point
    respawning = false
    _change_state(State.AIR)

func _on_player_died() -> void:
    deaths += 1
    hud.show_deaths(deaths)
    camera.shake(hit_shake)
    hit_stop(hit_stop_scale, hit_stop_time)

• died.emit() fires first, so the brain freezes time and shakes the camera before the Bearcat moves.
• Flash, sound, then wait on the same real-seconds timer. The teleport lands exactly as time resumes.
• respawning guards the door: the spike can fire again while the body sits on it during the freeze.

Dust and sound

func _flash() -> void:
    sprite.modulate = flash_color
    var tween := create_tween()
    tween.tween_property(sprite, "modulate", Color.WHITE, flash_time)

func _play(sound: AudioStreamPlayer) -> void:
    sound.pitch_scale = randf_range(
        1.0 - pitch_wobble, 1.0 + pitch_wobble)
    sound.play()

• Particles: a CPUParticles2D with One Shot on and Emitting off; dust.restart() fires one burst. Set in the Inspector, fired from the door.
• Sound: one AudioStreamPlayer per event, a child of the thing that makes the noise. The plain player is right for one screen; the 2D one fades with distance.
• Pitch wobble: the same sample at a random pitch between 0.9 and 1.1 stops sounding like a sample.

Containers own their children

← OUTLINE

Lab 5 Launch

Juice your platformer, or the kit

Lab 5: Game Feel

Milestones

• M0: pick a start, run it. Find the three spots in player.gd that get juiced.
• M1: the shell. HUD (time, deaths), a brain on the main scene, pause menu, clear screen, title screen. Week 7, on your game.
• M2: the jump. Squash and stretch through the door, landing dust.
• M3: the hit. Camera shake, hit stop, flash, delayed respawn. Freeze, flash, shake.
• M4: sound. Four events, pitch wobble on at least one.
• M5 (required): your signature. One more moment, two channels, from the menu or your own.

The contract

← OUTLINE

Rituals

Close Sprint 1, plan Sprint 2

A sprint has rituals

Why the rituals matter

• Planning turns a wish list into a list a team of two can finish in three weeks. Without it, the backlog decides for you.
• The board is the status report. A spoken "almost done" is worth nothing; a card in Done that runs on main is worth everything.
• The gate is a deadline you cannot negotiate with, which is the point. Studios ship because of milestones.
• The feedback log is where stakeholders find out they were heard, including when the answer is no.
• The report is the retrospective: what slipped, and what you will do differently. Same-mistake-twice is the thing it prevents.

Close Sprint 1

Nothing gets deleted. Slipped cards are the first candidates for Sprint 2.

Sprint 2: the goal

Sprint planning, the process

1. Start from the sheets. Each stakeholder note gets a verdict in FEEDBACK.md: adopt, adapt, or decline, with one reason. Adopted and adapted notes become issues.
2. Pull the MUSTs. Every MUST from the proposal that is not on the board yet becomes an issue: a player-facing title and a Done when list.
3. Carry the slipped cards. Keep them, split them if they slipped because they were too big.
4. Count the sittings. Two people, three weeks, about twelve sittings of real work. If the cards need more, something moves to WANT today, in writing.
5. Order the top. Alpha checklist rows first, then adopted feedback, then juice. Label sprint-2, assign one owner per card.
6. Read the board as the report. The Sprint 2 board is the Next sprint section of tonight's Sprint 1 report.

Co-op: plan Sprint 2

The Sprint 1 board stays as it is. Sprint 2 is a new label and a fresh Todo order on the same project.

Sprint check

The Sprint 1 report, tonight

Due tonight, 9:59 PM: docs/sprint-1.md in the team repo, with FEEDBACK.md at the root, and the repo URL on Canvas. Short. Pulled from the board you just built.

← OUTLINE

Game Over Screen

What you know now

Checkpoint reached

Sources

• [1] Swink, Game Feel: A Game Designer's Guide to Virtual Sensation (Morgan Kaufmann, 2009).
• [2] Jonasson and Purho, Juice It or Lose It (talk, Nordic Game Indie Night, 2012).
• [3] Nijman, The Art of Screenshake (talk, INDIGO Classes, 2013).
• [4] Brown, Secrets of Game Feel and Juice, Game Maker's Toolkit (video essay, 2015).
• [5] Thomas and Johnston, The Illusion of Life (Disney, 1981): the twelve principles, squash and stretch first.
• [6] Godot docs: Tween, CPUParticles2D, Camera2D, AudioStreamPlayer, Engine.time_scale, SceneTree.create_timer.
• [7] Lab 5 repo: GUIDE.md, milestones M0 to M5.
• [8] Schwaber and Sutherland, The Scrum Guide (2020): sprint planning, review, and retrospective.
• [9] Keith, Agile Game Development, 2nd ed. (Addison-Wesley, 2020): sprints and milestones in game studios.