Godot Animation: Inspect Keys, Timing and Interruptions | Assignment 7

Build inspectable Godot animations with saved keys, clear timing and one owner of game state.

Walker Claude uses four baked animation resources and real bone-motion captures to connect authoring decisions to visible behavior. The 176 structure and phase checks cover tracks, keys, loop settings and reset behavior. The film distinguishes an animation changing the presentation from the game logic deciding what happened.

CSYE 7270, Assignment 7: Professor Bear’s worked example.

Your turn Read my animation phase table and existing game behavior tests. Create one inspectable clip, baking it if built in code. Check every track target, key time and loop mode. Keep the behavior pins unchanged. Give me a native capture plan at the phase boundaries before proposing a tuning change.

Chapters 0:00 Introduction 0:35 Choose The Authoring Route 1:45 Turn Timing Into Keys 3:09 Wire One Authority 4:35 Inspect, Revise, Explain 5:18 Closing

Sources and credits CSYE 7270 assignment brief; Walker Claude source, design records, test receipts and engine captures. Teaching direction: Nik Bear Brown. AI-assisted implementation, analysis and film production. Liam, in for Bear: synthetic Kokoro narration. Scripted engine input is labeled; no human playtest or learner approval is claimed.

Professor Bear Does His Assignments https://www.youtube.com/playlist?list=PLM51lFDKue_A

What this video covers

• 0:00 — Introduction
• 0:35 — Choose The Authoring Route
• 1:45 — Turn Timing Into Keys
• 3:09 — Wire One Authority
• 4:35 — Inspect, Revise, Explain
• 5:18 — Closing

Transcript

A lightly formatted transcript of the video, with timestamps so you can jump to any section on YouTube.

Introduction

[0:00] CSYE7270 assignment walkthroughs, animation you can inspect, make real motion, expose its keys, and preserve the game rules. Hello, this is Liam in for Bear for CSYE7270. A clip name changing is not proof that anything moves. Walker Claude lets us inspect saved keys, real bone motion, and the gameplay rules that animation must preserve. Prerequisite terms: track, a sequence targeting one property or bone; key, a value at a particular time; cycle, a clip that repeats; phase, a timed part of an action.

Choose The Authoring Route

[0:35] The canvas source asks for creation discipline alongside state wiring. Begin with the motion you want, choose an authoring route, expose its source, then inspect the actual result. A state counter alone misses silent tracks. Resource text gives exact key times, but can target non-existent paths. Code-built clips need baking for editor inspection. Drawn frames need registration. Imported clips need loop settings in the importer, so a fresh re-import them. Our original rig creates clips in code. The baker saves those actual animation resources as dot tres files. It changes their representation, not the movement rule, key timing, or amplitude. The course lab then loads the saved files. These are actual renderer snapshots during one input-triggered charge. The live arm rotations change across the phases. This is stronger than checking current animation's name, and it still does not establish that a person finds the action readable. The example uses its original nine-bone model and saved idle, walk, charge, and celebration resources. Generated sprite sheets would follow the asset assignments model log and registration rules. They are a different authoring route.

Turn Timing Into Keys

[1:45] Start from a phase or cycle table, convert its frames into times, put keys at the boundaries, read the resource back, and compare native phase frames. If the intent changes, revise the timing table rather than silently editing isolated keys. The committing action lasts 6/10 of a second. Its five keys lie at 0, 15/100, 3/10, 45/100, and 6/10. Other example cycles last 8/10. These values belong to this game, not every animation. At each phase, compare the pose to the timing record. Our live skeleton receipts pair the frame with state, charge, current clip, and bone quaternions. An AI reading these images is a claim. A measured human motion reference has not been invented. A track

Must resolve to the right node and target. Rotation tracks in this rig target named skeleton bones, so checking only the node is insufficient. The new test checks each bone, all key times, clip length, and loop mode. Continuous cycles match their start and end values. Frame tracks avoid a duplicate across the wrap and preserve the final interval. A frame index needs discrete updates. Our rotation cycles match end points. The charge clip is not looped. Godot 4 uses loop mode and speed scale, rather than the old loop boolean and playback speed. A resource loading is not sufficient proof of those settings. Read them back and keep imported animation settings where re-import will preserve them.

Wire One Authority

[3:09] Make the clips, then wire them to the existing state. Gameplay owns movement, the signal, and the gate. Animation observes those facts. A visual resource revision must not silently redefine when the player can move or when a signal completes. The rig plays a new clip only when the state changes with a short blend. It does not restart the same clip every frame. The following native sequence shows the actual state-linked movement and signal, rather than an animation name counter. Watch the character approach the pad and perform the charge. The game chooses walking and charging. The rig supplies the visible motion. This is a normal speed native recording driven by physical key events

With the diagnostic observer visible. Gameplay advances on ticks. The animation player's callback mode determines its own updates. Name both. Physical input events reach input handlers. Merely pressing an action programmatically may bypass those handlers and weaken a test. The phase edge test reaches charge at 9, 18, and 27 physics ticks using real input. Reset interrupts each case. After another second, no late gate opens. Those are actual checks of the mechanic separate from post structure. Intentional clip tuning can update its structural expectations. Changing the game's behavior pins is a separate decision after play. Animation tree users must also test the state table, advance mode, and expression-based node. This example uses an animation player.

Inspect, Revise, Explain

[4:35] Give the agent the phase table and real frames, then ask for one predicted change. Recapture and compare before deciding whether it helps. Normal speed play and a labeled slow replay serve different judgments. Neither replaces an honest human observation. The Canvas reviews animation set proposal retains 12 points, three for the simple clip, five for the sheet or rig, four for a cycle. The point is authoring with editable sources and readback, rather than merely possessing clips. The baked resources resolve tracks, phase edge checks, and native bone motion exist. Human motion reference measurements and playfield judgments remain separate. Keep the source, failed attempts, and contributions visible. A beautiful film cannot repair a clip that moves nothing.

Closing

[5:19] Let's recap with Claude. Choose an authoring route with its specific checks. Expose paths, keys, timing, and cycle seams. Wire animation to the game's existing authority. Inspect real motion and keep human judgments honest. Read my animation phase table and existing game behavior tests. Create one inspectable clip, baking it if built in code. Check every track target, key time, and loop mode. Keep the behavior pins unchanged. Give me a native capture plan at the phase boundaries before proposing a tuning change. Animation you can inspect at Nick Bear Brown.