Intro

Your team has a design doc. You've learned platformer mechanics in the Boot Camp. Now it's time to build.

In this lesson, you'll create your own playable piece—a level, chapter, room, or scenario within your team's shared concept. You'll hit three gates to keep the build on track:

• First Playable 🟢 — Core mechanic works; player can do the main thing your game is about.
• Playtested 🟡 — Real players have tried it; you've fixed the most obvious issues.
• Content Complete 🟢 — All levels/chapters/rooms are built and working; no major placeholders.

You'll work independently, but checkpoints keep you synced with the team.

Before You Start

You need:

• Your team's approved design doc from Lesson 3.1
• A copy of your Platformer Boot Camp project (Lesson 3.2) as the starting point
• Clarity on your playable piece: which level/chapter/room/scenario are you building?
• A playtest document (Google Doc or Word) shared with your team for feedback

Keep in mind: Each team member builds a separate playable piece in their own GDevelop project, but all pieces follow the same art style, mechanics, and HUD from the design doc. Your Art Lead has prepared a shared assets folder in Teams.

Task 1: First Playable 🟢

Goal: Show that the core mechanic works in your piece.

Duration: 1–2 class periods

1. Claim your piece. In your team's design doc, under "Build Plan," write your name next to the piece you're building (e.g., "Level 2," "Chapter 1," "Quiz Round"). If a teammate is already building it, pick the next one.
2. Set up your own GDevelop project.
   • Copy your Platformer Boot Camp project and rename it something clear, like YourName_Level2 or YourName_Chapter1.
   • Save it to H:\ICT 9\3_dev_team\platformer\ (Path B) or back it up regularly (Path A).
3. Build the layout.
   • For Play (platformer/top-down): Create the tilemap layout for your level using the tile palette your Art Lead provided. Test that the player can move, jump, collide, and the camera follows.
   • For Story (interactive fiction/visual novel): Set up your scene with background image, character sprites, and a dialogue box (or use a dialogue extension). Make sure the player can click to advance.
   • For Explore (quiz/simulation/tour): Create the first interactive screen: a quiz question with clickable buttons, a simulation parameter the player can adjust, or a tour waypoint with navigation buttons.
4. Implement the core mechanic.
   • For Play: A goal object (exit, flag, or trigger) that loads a "Next Level" or "Level Complete" scene when the player reaches it.
   • For Story: A choice or dialogue tree: the player sees two options and their choice changes the next scene.
   • For Explore: A correct answer triggers feedback or moves to the next question/screen; a wrong answer shows a hint or penalty.
5. Preview and test. Launch preview and play through your piece end-to-end. Does the main action work? Does the player feel like they accomplished something? 🟢 If yes, you've hit Gate 1.
6. Save and commit. If using Git (H: drive), commit your work with a message like First playable: Level 2 layout + goal.

Checkpoint: Your piece is playable start-to-finish. A player can do the main action (reach a goal, make a choice, answer a question) and see a clear outcome.

Task 2: Playtested 🟡

Goal: Get real feedback and fix the biggest issues.

Duration: 1–2 class periods

1. Create a playtest doc. In your team's shared folder, create a simple Google Doc or Word doc:
   YourName's Playtest Feedback
   
   Player name | Date | What worked | What confused you | What would you change
   Alex | Oct 8 | Loved the puzzle mechanic | Not clear which door opens first | Add an arrow hint
   Jordan | Oct 8 | Nice art | Too hard to time the jump | Make platforms wider
   
2. Run at least two playtests.
   • Invite two teammates or another student from class (not your team—they'll give honest feedback).
   • Watch them play without helping. Let them struggle a bit so you see real problems.
   • Ask: "What was confusing? What felt unfair? What did you like?"
   • Record feedback in your doc.
3. Prioritize fixes. Look at your playtest feedback. Pick the top 3 issues:
   • Bugs (player gets stuck, crashes, unintended behavior)
   • Clarity (player doesn't understand what to do)
   • Balance (too easy / too hard / takes too long)
4. Implement fixes. In GDevelop, fix each issue. Examples:
   • Add a hint on screen if players miss the goal.
   • Adjust platform spacing or enemy speed.
   • Add a tutorial text if the mechanic is new.
   • Remove invisible walls that trap the player.
5. Playtest again. Invite one of your first testers back. Do they run into the same problems? If yes, dig deeper. If no, you're on the right track.
6. Update your playtest doc. Add a "Fixes applied" section noting what you changed.
   Fixes applied:
   - Widened platforms by 50px (feedback: too hard to time)
   - Added on-screen hint: "Reach the red flag to complete" (feedback: unclear goal)
   - Slowed enemy speed from 180 to 140 (feedback: unfair side hits)
   
7. Save and commit. Message: Playtested: fixed spacing, added hints, tuned difficulty.

Checkpoint: Your piece has been played by at least two people; you've documented their feedback and fixed the most critical issues.

Task 3: Content Complete 🟢

Goal: Finish building all the content for your piece (all levels, all chapters, all quiz rounds, etc.).

Duration: 2–3 class periods

1. List everything you need to build. From your design doc, write down every level/chapter/room/screen in your piece. Example for Play:
   • Level 1: Intro (teach basic jump) ✓ Done
   • Level 2: Platforms puzzle ✓ Done
   • Level 3: Enemy gauntlet ☐ Not started
   • Level 4: Boss ☐ Not started
2. Build remaining levels/chapters/rooms. You can copy and modify your first level as a template. For each:
   • For Play: Use the same tilemap, enemy types, and HUD. Increase difficulty or introduce new mechanics (moving platforms, springs, new enemy type, collectibles).
   • For Story: Write the dialogue, position character sprites, set up the choice branches.
   • For Explore: Write all quiz questions, set up simulation parameters, plan tour waypoints.
3. Polish visuals and flow.
   • Check that all sprites use the team's art style (colors, size, proportion).
   • Make sure transitions between levels/chapters are smooth (use scene-change events, not just "go to next scene").
   • Ensure the HUD and fonts are consistent throughout.
4. Playtest the whole piece. Play from start to end. Does every level work? Can you reach every goal? Are there any crashes or soft locks?
5. Remove placeholders. Delete any "TODO" comments, placeholder sprites, or debug text. Everything should feel intentional.
6. Final preview. Export or run preview. Play the entire piece once more. If you're happy with it, you're done. 🟢 Content Complete.
7. Save and commit. Message: Content complete: all levels built and polished.

Checkpoint: All content for your piece is built, playable, and polished. No placeholders or major bugs remain.

Blue Tasks: Deeper Learning

Once you've hit all three gates, try one of these:

• Advanced enemy AI. Add an enemy that uses pathfinding or patrols between multiple waypoints (Play tracks).
• Dynamic difficulty. Keep track of how many times the player fails and scale difficulty (easier platforms, slower enemies) if they're struggling too much (Play).
• Branching storyline. Create a second branch: two different choices lead to two different outcomes (Story).
• Leaderboard. Track the player's score or time and save it to show on a results screen (Play/Explore).
• Accessibility pass. Add colorblind-friendly palettes, bigger text, or controls remapping (any track).

Reflection

• Describe your First Playable moment. What was the core mechanic that had to work?
• What was the most surprising piece of playtest feedback you got? How did you fix it?
• If you had more time, what would you add or change in your piece?
• How did your team's design doc help you know what to build? What was unclear?

Hand It In

Submit to Teams under "Lesson 3.3 — Build It."

• Your GDevelop project file (cloud link or attachment)
• A short preview clip (10–20s, showing all three gates in action if possible)
• Your playtest doc (link to shared Google Doc or Word file with feedback)
• Your reflection (the four prompts answered)
• A screenshot of the scene list showing all levels/chapters/rooms you built