Chapter 6 Exercises: The Core Loop

Exercise 1: Core Loop Decomposition

Type: Analytical
Time: 40-50 minutes
Deliverable: Five completed core loop diagrams with written analysis

Choose five games you have significant experience with. They must come from at least three different genres. For each game:

1. Identify the core loop. Apply the thirty-second test: if you watch someone play for thirty seconds, what cycle are they repeating? Describe the loop in one sentence using verbs (e.g., "Kill enemies, collect loot, equip upgrades, fight harder enemies").

2. Draw a circular diagram. Use boxes or circles for each phase. Use arrows to show the flow. Label each arrow with what flows along it (resources, experience, access, knowledge, currency). The diagram should make the cycle visually clear --- a reader who has never played the game should understand the loop from the diagram alone.

3. Identify the escalation. What changes between the first cycle and the tenth? Is it power escalation, skill escalation, complexity escalation, or scope escalation? Is it a combination?

4. Rate the loop. On a scale of 1-5, rate how well the loop answers each of these questions: - Does the output of one cycle naturally feed the input of the next? (Self-sustaining quality) - Is the feedback immediate and clear? (Feedback quality) - Does the loop produce escalation --- does each cycle feel different from the last? (Escalation quality) - Could you happily repeat this loop for 50 hours? (Durability)

5. Identify the weakest phase. Every loop has a phase that is less satisfying than the others. Which phase is it? Why? What would you change --- one specific, implementable change --- to strengthen that phase?

After completing all five, write a paragraph comparing them. Which game has the tightest loop? Which has the loosest? Is there a correlation between loop tightness and the number of hours you have played each game?

What this teaches you: Diagrams force you to see the loop as a structure, not just a feeling. Rating each loop against the same criteria builds your critical vocabulary. The comparison paragraph builds your ability to analyze loop quality across genres.

Exercise 2: The Progressive Project Core Loop

Type: Implementation / Design
Time: 60-90 minutes
Deliverable: Playable Godot prototype demonstrating one complete core loop cycle

Build the core loop prototype described in Section 6.11. This is the most important exercise in the chapter. Requirements:

1. Create the GameManager autoload. Implement the GameManager.gd script from Section 6.10 as an autoload singleton. Verify that it is accessible from other scripts by printing the current phase to the console.

2. Create at least two connected areas. These can be separate scenes connected by an Area2D trigger, or rooms within a single scene separated by walls. The player should be able to move between them using the movement system from Chapter 3.

3. Place at least two enemies. They do not need AI yet. A stationary CharacterBody2D with a health variable that decreases when the player's attack hitbox overlaps it is sufficient. When health reaches zero, the enemy is destroyed and drops a CollectibleItem.

4. Implement the CollectibleItem. Use the script from Section 6.10. When the player touches the collectible, resources increase in the GameManager.

5. Create an upgrade point. This can be a simple Area2D with a prompt. When the player enters the area and presses a button, GameManager.apply_upgrade() is called, spending resources and increasing player_power.

6. Add escalation. After upgrading, something changes. The simplest approach: spawn new enemies in the second area that were not there before. Or unlock a door to a third area. The player should feel that the cycle has advanced.

7. Play the loop at least twice. Complete the cycle (explore, fight, collect, upgrade, explore) at least two times. The second cycle should feel different from the first because of the escalation.

Stretch goals: - Add a Label node displaying current resources and power level - Make enemies drop collectibles with variable resource_value - Add a visual change to the player when they upgrade (modulate color, scale increase)

What this teaches you: This is where theory becomes practice. Drawing a loop diagram takes five minutes. Making the loop work in an engine takes an hour and exposes every assumption you have not examined. If any phase of your loop feels wrong when you play it, go back and iterate. The prototype is a test of the design.

Exercise 3: The Core Loop Speed Test

Type: Analytical / Timed
Time: 30 minutes
Deliverable: Timed data table with analysis

Choose a game you are currently playing or have recently played. You will play it three times, timing each cycle of the core loop.

Setup: 1. Define the core loop precisely. Write it down before you start. (e.g., "One cycle = enter dungeon, clear a floor, collect loot, return to town, sell/equip.") 2. Set a timer.

Round 1: Play the game. Start the timer when you begin a cycle. Stop the timer when the cycle completes and the next one begins. Time five consecutive cycles. Record each time.

Round 2: Wait 10 minutes (to reset your mental state). Play again. Time five more cycles.

Round 3: Same. Five more cycles.

Data table:

Analysis (write 1 page):

1. What is the average cycle time? How consistent is it across rounds?
2. Are later cycles in each round faster (because you are in flow) or slower (because the game is escalating)?
3. Does the cycle time feel right? Is each cycle too fast (rushed, not enough time to appreciate the reward), too slow (dragging, bottleneck phase), or just right?
4. Where in the cycle do you spend the most time? Is that the most enjoyable phase, or is it a bottleneck?
5. Compare your cycle time to the game's session context. If the average cycle is 8 minutes and the target audience plays in 15-minute sessions, how many complete loops does a player experience per session? Is that enough to feel satisfying?
6. How would you adjust the cycle time if you were the designer? What specific change would speed up or slow down which phase?

What this teaches you: Pacing is one of the most overlooked aspects of core loop design. Timing your loops makes pacing tangible and measurable. Many designers never think about how long a single cycle takes. This exercise ensures you do.

Exercise 4: Nested Loop Identification

Type: Analytical
Time: 30-40 minutes
Deliverable: Three-layer loop diagram with written analysis

Choose a game with clear progression systems (RPGs, roguelikes, strategy games, and farming sims work best). Identify and diagram all three loop levels:

1. The micro loop (moment-to-moment, 3-30 seconds). What is the smallest repeating action? How long does it take? What is its feedback?

2. The core loop (session structure, 2-30 minutes). What is the cycle that structures a play session? How many micro loops fit inside one core loop cycle?

3. The meta loop (long-term progression, hours to months). What brings the player back across sessions? How many core loops feed into one meta loop cycle?

Draw all three as nested diagrams (three concentric loops, or three diagrams with arrows showing how each feeds the one above it).

Then answer:

• How does the micro loop feed the core loop? What resource, progress, or information flows upward?
• How does the core loop feed the meta loop? What persists between sessions?
• Is there a loop level that feels weaker than the others? If so, what is missing?
• If you removed the meta loop entirely (no persistent progression, no saves, no unlocks), would the core loop still be satisfying on its own? What does your answer tell you about where the game's engagement actually comes from?

Stretch: Repeat this exercise for a second game from a different genre. Compare the two. Which game has a stronger micro loop? Which has a stronger meta loop? Does the balance between loop levels correspond to the type of player each game attracts?

Exercise 5: Dead Loop Diagnosis

Type: Analytical / Prescriptive
Time: 25-30 minutes
Deliverable: Diagnosis and design fix for a broken loop

Choose a game you stopped playing --- one where you lost interest, not one you finished. Apply the core loop failure taxonomy from Section 6.7:

1. Write the game's core loop in one sentence.

2. Identify the failure pattern. Is it a Dead End (output goes nowhere)? A Flat Loop (no escalation)? A Bottleneck (one slow phase)? An Invisible Loop (no feedback)? A Parasitic Loop (unintended shortcut)? Or a combination?

3. Locate the break point. At which specific phase of the loop did the failure occur? Be precise: "The loot phase was broken because drops were too rare and too random, so the loop cycle produced no meaningful reward 80% of the time."

4. Design the fix. Propose one specific, implementable change to the broken phase that would repair the loop without fundamentally changing the game's identity. Explain why your fix works in terms of the loop: what flow does it restore? What connection does it repair?

5. Predict the side effects. Your fix will have consequences. If you increase drop rates (fixing a Dead End), you might accelerate progression and make the game shorter. If you add a new system to address a Flat Loop, you add complexity. What trade-off does your fix introduce, and is it worth making?

What this teaches you: Most players quit games because the core loop breaks, but they describe the experience as "I got bored" or "it wasn't for me." Translating that feeling into a structural diagnosis --- identifying where the loop broke and why --- is a core design skill. And proposing fixes with awareness of trade-offs is what separates armchair critics from working designers.

Exercise 6: Verb Exploration

Type: Creative / Design
Time: 25-30 minutes
Deliverable: Three one-paragraph core loop pitches based on three different verbs

Choose three verbs from the list below (or choose your own --- as long as they are specific physical actions, not abstract concepts like "have fun" or "experience the world"):

Verb options: Climb, Harvest, Dodge, Aim, Stack, Solve, Navigate, Trade, Combine, Repair, Sneak, Dig, Assemble, Balance, Launch

For each verb, design a core loop pitch in one paragraph. The pitch must include:

• The verb (what the player does)
• The feedback (what happens immediately after)
• The reward (what the player gains)
• The escalation (how the next cycle differs)
• One sentence about why a player would repeat this loop for 20 hours

Constraints: Each pitch must be a different genre. If your first pitch is an action game, your second cannot be an action game. This forces you to explore how the same verb can produce radically different loops depending on context.

Example (verb: "Throw"): "The player throws objects at targets in a physics-based puzzle game. Each throw produces ragdoll physics and destruction effects. Successful hits clear obstacles and reveal the next puzzle. Each puzzle introduces new physics constraints (wind, gravity changes, bouncing surfaces) that require the player to rethink throwing angles and timing. The loop sustains because the physics engine produces emergent comedy --- objects bounce, collide, and interact in unexpected ways, and the player is rewarded for creative solutions as much as precise ones."

What this teaches you: The verb is the seed of the loop. A different verb produces a different game even with the same reward structure, the same escalation pattern, and the same meta loop. Practicing verb-first design helps you see possibilities that theme-first or story-first design misses.

Exercise 7: Loop Comparison --- Mobile vs. Console

Type: Analytical / Comparative
Time: 30-35 minutes
Deliverable: Side-by-side comparison table with analysis

Choose one game from each category:

• Mobile game with a session length under 5 minutes (e.g., Candy Crush, Flappy Bird, Crossy Road, Subway Surfers, 2048)
• Console/PC game with a session length over 30 minutes (e.g., Elden Ring, Civilization VI, Stardew Valley, XCOM 2, Hades)

For each game, fill in a comparison table:

Analysis (write 1 page):

1. How does session length change loop design? What is fundamentally different about a loop designed for 3-minute sessions vs. one designed for 60-minute sessions?
2. Which game has more cycles per session? Which game has more decisions per cycle? Is there an inverse relationship?
3. The mobile game likely has higher feedback intensity per cycle (more particles, sounds, screen effects per second of play). Why? What problem is intense feedback solving in the mobile context that it does not need to solve on console?
4. How do the meta loops differ? The mobile game likely uses extrinsic motivation (daily rewards, progression systems, social pressure). The console game likely uses intrinsic motivation (story, mastery, exploration). Why does session context drive this difference?
5. Could you adapt the mobile game's core loop for a console context, or vice versa? What would you need to change? What would be lost?

Exercise 8: Feedback Mapping

Type: Observational / Analytical
Time: 20-25 minutes
Deliverable: Feedback inventory for one game's core loop

Choose a game with strong "game feel" (games with satisfying combat, precise platforming, or polished interactions work best --- Hades, Celeste, Dead Cells, Hollow Knight, Ori and the Blind Forest, Slay the Spire).

Play for 10 minutes. During play, focus entirely on feedback. For each phase of the core loop, catalog every piece of feedback the game provides:

1. Visual feedback: screen shake, hit flash, particle effects, color changes, animation changes, camera zoom, slow-motion, UI updates
2. Audio feedback: sound effects, music changes, voice lines, ambient shifts
3. Haptic feedback: controller rumble patterns (if applicable)
4. Informational feedback: damage numbers, health bar changes, resource counters, notification messages

Organize your findings by loop phase. For example, if the core loop is "attack, kill, collect, move to next room":

After completing the inventory: - Count the total number of feedback elements across all phases. (You may be surprised by how many there are.) - Which phase has the most feedback? Why do you think the designers concentrated feedback there? - Which phase has the least feedback? Is this intentional (e.g., movement is quiet to create contrast with combat) or a missed opportunity? - Identify one specific feedback element that does double duty --- it provides both information (telling you what happened) and emotion (making you feel something). Explain how it accomplishes both.

What this teaches you: Good feedback is invisible when it is working. You do not notice screen shake in Hades until you turn it off. This exercise makes the invisible visible. You will use this inventory as a reference when you add feedback in Chapter 8.

Exercise 9: The Anti-Loop

Type: Creative / Critical
Time: 20-25 minutes
Deliverable: One-page design of a deliberately broken core loop, with analysis

Design a core loop that deliberately fails. Choose one of the five failure patterns from Section 6.7 (Dead End, Flat Loop, Bottleneck, Invisible Loop, Parasitic Loop) and design a simple game concept where that failure is the defining feature.

Your design should include: - A one-sentence description of the game - A core loop diagram with the failure clearly visible - A three-sentence explanation of why this loop fails --- what flow is broken, what connection is missing, what experience results

Then: propose one change that converts the broken loop into a working one. Draw the fixed diagram. Explain what the change repairs.

Why this exercise exists: It is easier to recognize broken patterns when you build them intentionally. Designing a deliberate failure and then fixing it is faster and more instructive than discovering a failure accidentally in your own project six months from now. Failure patterns are easier to diagnose once you have constructed them yourself.

Exercise 10: Core Loop Pitch Session

Type: Collaborative / Design
Time: 40-50 minutes (requires a partner or small group)
Deliverable: Two refined core loop pitches with peer feedback

This exercise requires at least one other person --- a classmate, friend, or fellow designer.

Round 1 (15 minutes): Each person designs a core loop for a game concept in a genre they have never worked in before. (If you mostly play action games, design a puzzle game. If you play RPGs, design a sports game.) The design should include: - One sentence: the player fantasy - One sentence: the core verb - A four-phase core loop diagram - One sentence: the escalation - One sentence: the session arc (how long is one cycle, when does the player feel satisfied?)

Round 2 (15 minutes): Exchange designs. Each person plays "playtester" for the other's loop. Without looking at the designer's notes, examine only the loop diagram and answer: - What would I be doing in a typical 30-second slice of this game? - Where in the loop would I feel most engaged? Where would I feel least engaged? - What is the weakest connection between phases? What flow is unclear? - Would I play this for 20 hours? Why or why not?

Write your feedback as three bullet points: one thing that works, one thing that concerns you, one specific suggestion.

Round 3 (10 minutes): Return the feedback. Each person revises their loop based on the critique. The revised version should address the concern and incorporate (or deliberately reject, with a reason) the suggestion.

What this teaches you: Core loops that sound good in your head often break when someone else examines them. The gap between your intention and another person's interpretation is the same gap between your design and your player's experience. Getting peer feedback on a loop before you build it saves weeks of iteration after the prototype is playable.

Exercise 11: Historical Loop Analysis

Type: Research / Analytical
Time: 30-35 minutes
Deliverable: Two-game comparison across eras

Choose one game from before 2000 and one game from after 2020 in the same genre. (Examples: Pac-Man (1980) and Vampire Survivors (2022); Super Mario Bros. (1985) and Celeste (2018); Tetris (1984) and Tetris Effect (2018); Diablo (1996) and Hades (2020).)

For each game, identify and diagram the core loop. Then compare:

1. How many phases does each loop have? Are modern loops more complex or simpler?
2. How has feedback evolved? Compare the feedback density (number of feedback elements per loop cycle) of the older game to the newer one.
3. How has escalation changed? Does the newer game escalate differently?
4. What has the newer game added to the loop that the older game did not have? (Meta progression? Choice within the loop? Procedural variation?)
5. What has the newer game preserved from the older game? What is timeless about the loop structure?
6. Which game has the better core loop? This is subjective, but defend your answer with reference to the loop criteria: self-sustaining quality, feedback, escalation, durability.

What this teaches you: Core loop design has evolved enormously in four decades, but the fundamental structure --- act, feedback, reward, escalation --- has not changed. Understanding what is timeless about loop design (the structure) and what is evolving (the density, the meta-layers, the feedback technology) makes you a more informed designer.

Exercise 12: Your Loop, Their Loop

Type: Experiential / Observational
Time: 30-40 minutes (requires one other person)
Deliverable: Observation notes and one-page reflection

Hand your Chapter 6 progressive project prototype to someone who has never seen it. Do not explain anything. Do not tell them what the core loop is. Do not say "you need to go fight that enemy." Just hand them the controller and observe.

Watch for: - Do they discover the loop on their own? How long does it take? - What do they try first? (This tells you what the game's visual language is communicating.) - At what point do they understand the cycle? Is it after the first collect? After the first upgrade? After the second full cycle? - Where do they get stuck or confused? Which connection between loop phases is unclear? - Do they voluntarily start a second cycle, or do they put the controller down?

After 10 minutes, stop the session. Ask: - "What was the game about?" (Compare their answer to your intended fantasy.) - "What were you supposed to do?" (Compare to the actual loop.) - "Was anything confusing?" - "Would you play again?" (This is the only question that matters.)

Write a one-page reflection comparing your intended loop to their experienced loop. Where did the gaps appear? What would you change to close them?

What this teaches you: This is a preview of Chapter 31's playtesting methodology, applied to the core loop specifically. The most dangerous thing about core loop design is the Curse of Knowledge: you know the loop because you designed it. Your player does not. Watching someone discover (or fail to discover) your loop is the fastest way to identify what is working and what is not.