{"success":true,"course":{"concept_key":"CONCEPT#d9472145a6d050eaf66d39bee250854f","final_learning_outcomes":["Document a concise yet flexible vision for a game project","Choose an engine that matches project goals and skill set","Establish a Unity project under Git version control","Create GameObjects and components that form the game world","Code physics-based movement and jumping in Unity","Run structured playtests and iterate on feedback"],"description":"Follow a streamlined path from shaping your game idea to testing a playable prototype. You’ll document a clear vision, pick the right engine, set up your project with Git, create objects and player movement in Unity, and run effective playtests.","created_at":"2025-12-18T22:08:46.976876+00:00","average_segment_quality":7.947777777777778,"pedagogical_soundness_score":8.8,"title":"Build Your First Video Game","generation_time_seconds":64.93047833442688,"segments":[{"duration_seconds":276.0,"concepts_taught":["Primary purpose of a GDD","Communicating design ideas to self and others","Determining if a GDD is necessary","Core concept and design pillars","Limiting scope and essential features","Basic contents of a starter GDD"],"quality_score":8.2,"before_you_start":"Before diving into code or art, it’s essential to clarify what you’re actually making. A Game Design Document—your project’s blueprint—keeps everyone, including future-you, on the same page. In this short segment, you’ll discover the single purpose of a GDD and how it anchors scope and communication.","title":"Why You Need a GDD","url":"https://www.youtube.com/watch?v=bro4rwYVo0I&t=54s","sequence_number":1.0,"prerequisites":["Basic knowledge of game development workflow","Awareness of project scoping challenges"],"learning_outcomes":["Explain why the main purpose of a GDD is communication","Judge whether a project does or does not need a GDD","Identify appropriate design pillars for a new game","List the typical sections of a minimal GDD"],"video_duration_seconds":743.0,"transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"","overall_transition_score":0.0,"to_segment_id":"bro4rwYVo0I_54_330","pedagogical_progression_score":0.0,"vocabulary_consistency_score":0.0,"knowledge_building_score":0.0,"transition_explanation":"N/A (first segment)"},"segment_id":"bro4rwYVo0I_54_330","micro_concept_id":"game_vision_gdd"},{"duration_seconds":381.234,"concepts_taught":["Importance of document format","Blueprint analogy for effective communication","Choosing content based on audience","One-page design document approach","Benefits of conciseness and focus","Creating illustrations, charts and call-outs"],"quality_score":8.45,"before_you_start":"Now that you know why a GDD exists, you’re ready to see how it evolves. This video shows how a one-page vision can blossom into detailed sections on mechanics, art style, and story without becoming unwieldy.","title":"Scaling Your Design Document","url":"https://www.youtube.com/watch?v=bro4rwYVo0I&t=330s","sequence_number":2.0,"prerequisites":["Understanding of basic GDD purpose"],"learning_outcomes":["Explain why document format affects usability","Identify audiences and tailor GDD content accordingly","Describe key advantages of the one-page method","Apply single-objective focus when drafting a design page"],"video_duration_seconds":743.0,"transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"bro4rwYVo0I_54_330","overall_transition_score":9.0,"to_segment_id":"bro4rwYVo0I_330_711","pedagogical_progression_score":9.0,"vocabulary_consistency_score":9.0,"knowledge_building_score":9.0,"transition_explanation":"Builds on the basic purpose of a GDD by adding structure and scalability tips."},"segment_id":"bro4rwYVo0I_330_711","micro_concept_id":"game_vision_gdd"},{"duration_seconds":285.72,"concepts_taught":["Definition of a game engine","Analogy to content-creation tools","Reusable subsystems (graphics, physics, scripting, sound, AI)","Developer role vs. engine role","Case study: Jedi Outcast built on Quake 3"],"quality_score":8.075000000000001,"before_you_start":"With your game concept documented, the next step is choosing the tool that will bring it to life. Here, you’ll learn what a game engine is and why it saves you from reinventing graphics, physics, and audio from scratch.","title":"What Game Engines Do","url":"https://www.youtube.com/watch?v=xrqRuxAkkG8&t=0s","sequence_number":3.0,"prerequisites":["Basic familiarity with video games","General idea of software applications"],"learning_outcomes":["Define what a game engine is and its purpose","Identify major engine subsystems and their responsibilities","Explain how engines enable asset and behaviour reuse","Describe how Jedi Outcast was created by repurposing Quake 3"],"video_duration_seconds":607.0,"transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"bro4rwYVo0I_330_711","overall_transition_score":8.6,"to_segment_id":"xrqRuxAkkG8_0_285","pedagogical_progression_score":8.0,"vocabulary_consistency_score":9.0,"knowledge_building_score":8.5,"transition_explanation":"Moves from documenting vision to selecting the software framework that realises that vision."},"segment_id":"xrqRuxAkkG8_0_285","micro_concept_id":"choosing_game_engine"},{"duration_seconds":366.84,"concepts_taught":["Key selection criteria","Importance of community support","2D vs 3D capability match","Engine comparisons (Unity, Godot, GameMaker)","Risks of over-scoping first project"],"quality_score":7.700000000000001,"before_you_start":"Now that you know what engines provide, it’s time to weigh Unity against Unreal and others based on features, community, and your project needs. This segment equips you with practical selection criteria.","title":"Choosing the Right Engine","url":"https://www.youtube.com/watch?v=aMgB018o71U&t=0s","sequence_number":4.0,"prerequisites":["Basic understanding of what a game engine is","General familiarity with 2D and 3D games"],"learning_outcomes":["List the main factors to consider when selecting a game engine","Explain why community size influences problem-solving speed","Match common game scopes (2D, 3D, multiplayer) to suitable engines","Recognize pitfalls of starting with overly ambitious projects"],"video_duration_seconds":907.0,"transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"xrqRuxAkkG8_0_285","overall_transition_score":9.0,"to_segment_id":"aMgB018o71U_0_366","pedagogical_progression_score":9.0,"vocabulary_consistency_score":9.0,"knowledge_building_score":9.0,"transition_explanation":"Uses the foundational definition of engines to inform a comparative decision process."},"segment_id":"aMgB018o71U_0_366","micro_concept_id":"choosing_game_engine"},{"duration_seconds":406.15900000000005,"concepts_taught":["Git vs. GitHub basics","Creating repositories with README and .gitignore","Cloning with GitHub Desktop","Importing a Unity project into the repo","Unity meta files and asset serialization settings","Committing and pushing changes"],"quality_score":7.775,"before_you_start":"With an engine selected, you’ll create your first project and protect it with Git version control. You’ll see how to create a repository, clone it locally, and make your first commit—vital habits before any code changes happen.","title":"Setting Up Git with Unity","url":"https://www.youtube.com/watch?v=qpXxcvS-g3g&t=12s","sequence_number":5.0,"prerequisites":["Basic computer navigation","Familiarity with installing software"],"learning_outcomes":["Create and configure a GitHub repository for Unity","Explain the purpose of README and .gitignore files","Clone a repository using GitHub Desktop","Adjust Unity settings for version control","Commit and push Unity project changes to GitHub"],"video_duration_seconds":446.0,"transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"aMgB018o71U_0_366","overall_transition_score":8.2,"to_segment_id":"qpXxcvS-g3g_12_418","pedagogical_progression_score":8.0,"vocabulary_consistency_score":9.0,"knowledge_building_score":8.0,"transition_explanation":"Follows engine choice by establishing the technical workspace within that engine."},"segment_id":"qpXxcvS-g3g_12_418","micro_concept_id":"project_setup_version_control"},{"duration_seconds":392.199,"concepts_taught":["Starting a Unity Hub project","Navigating key Unity windows","Adding 3D cubes to scene","Using Transform to position & scale","Understanding Box Colliders","Applying basic materials"],"quality_score":7.700000000000001,"before_you_start":"Your project is under version control, so let’s explore the Unity workspace. You’ll create simple cubes, navigate the Scene, and understand where GameObjects and components live—foundations for everything you’ll script later.","title":"First Steps in Unity Scene","url":"https://www.youtube.com/watch?v=vQY4jsho1nQ&t=0s","sequence_number":6.0,"prerequisites":["Basic computer file management","Familiarity with Cartesian axes (X,Y,Z)"],"learning_outcomes":["Launch and configure a new Unity 3D project","Identify purpose of Hierarchy, Scene, Game, Inspector, Project windows","Create and transform 3D objects via gizmos and numeric input","Explain why different axes are scaled for ground thickness","Describe what a Box Collider does","Apply custom materials to objects"],"video_duration_seconds":1214.0,"transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"qpXxcvS-g3g_12_418","overall_transition_score":8.6,"to_segment_id":"vQY4jsho1nQ_0_392","pedagogical_progression_score":9.0,"vocabulary_consistency_score":9.0,"knowledge_building_score":8.0,"transition_explanation":"Builds on the freshly created project by exploring its core interface and objects."},"segment_id":"vQY4jsho1nQ_0_392","micro_concept_id":"objects_components_unity"},{"duration_seconds":281.6,"concepts_taught":["Updating packages in Unity","Creating player and ground sprites","Resetting transforms","Color-coding objects","Choosing aspect ratio in Game view","Adding Box vs. Capsule colliders","Why capsule collider prevents snagging"],"quality_score":7.700000000000001,"before_you_start":"Having placed basic 3D objects, you’ll now switch to a simple 2D setup, create a player square and ground, and prepare them for movement scripts. This scaffolds the scene for more advanced physics in the next step.","title":"Building Player and Ground","url":"https://www.youtube.com/watch?v=w9NmPShzPpE&t=0s","sequence_number":7.0,"prerequisites":["Basic Unity interface navigation"],"learning_outcomes":["Build a simple 2D scene with player and ground sprites","Apply appropriate colliders and explain the choice","Configure Game view aspect ratio for testing"],"video_duration_seconds":2068.0,"transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"vQY4jsho1nQ_0_392","overall_transition_score":8.1,"to_segment_id":"w9NmPShzPpE_0_281","pedagogical_progression_score":8.0,"vocabulary_consistency_score":9.0,"knowledge_building_score":8.0,"transition_explanation":"Extends object/component knowledge into a concrete player setup."},"segment_id":"w9NmPShzPpE_0_281","micro_concept_id":"player_movement_jump"},{"duration_seconds":568.14,"concepts_taught":["Rigidbody requirements","AddForce and ForceMode.Impulse","Tuning gravity and gravity scale","Collision detection modes","Calculating jump force for target height","Variable jump heights"],"quality_score":8.105,"before_you_start":"With your player object ready, it’s time to make it move. This segment dives into Rigidbody components and the AddForce method to achieve a responsive, physics-grounded jump—exactly the technique professional Unity devs use.","title":"Coding a Physics-Based Jump","url":"https://www.youtube.com/watch?v=c9kxUvCKhwQ&t=0s","sequence_number":8.0,"prerequisites":["Basic Unity interface familiarity","C# scripting fundamentals","Vector mathematics basics"],"learning_outcomes":["Add a Rigidbody and apply impulse force for jumping","Diagnose and fix floaty jumps via gravity tweaks","Compute force needed for a specific jump height","Implement variable jump heights with physics"],"video_duration_seconds":968.0,"transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"w9NmPShzPpE_0_281","overall_transition_score":9.0,"to_segment_id":"c9kxUvCKhwQ_0_568","pedagogical_progression_score":9.0,"vocabulary_consistency_score":9.0,"knowledge_building_score":9.0,"transition_explanation":"Takes the static player object and adds dynamic behaviour through code."},"segment_id":"c9kxUvCKhwQ_0_568","micro_concept_id":"player_movement_jump"},{"duration_seconds":266.95,"concepts_taught":["Why external playtests are essential","Developer bias and familiarity blindness","Categories: bug, alpha/beta, play testing","Minimum viable product philosophy","Timing: begin testing as early as possible"],"quality_score":7.825000000000001,"before_you_start":"Your prototype can jump and move—now you need real player feedback. This closing segment reveals why fresh eyes are crucial, how to run early playtests, and how to turn observations into actionable improvements.","title":"Playtesting Early and Often","url":"https://www.youtube.com/watch?v=Yb-znyOK5Kc&t=3s","sequence_number":9.0,"prerequisites":["Basic understanding of video-game development stages","General knowledge of software testing terminology"],"learning_outcomes":["Explain why self-testing is insufficient for objective feedback","Differentiate bug testing, alpha/beta testing, and playtesting","Describe what constitutes a minimum viable product in game development","Justify beginning external playtests early in development"],"video_duration_seconds":762.0,"transition_from_previous":{"suggested_bridging_content":"","from_segment_id":"c9kxUvCKhwQ_0_568","overall_transition_score":8.4,"to_segment_id":"Yb-znyOK5Kc_3_270","pedagogical_progression_score":8.0,"vocabulary_consistency_score":9.0,"knowledge_building_score":8.5,"transition_explanation":"Moves from implementing mechanics to validating them with players."},"segment_id":"Yb-znyOK5Kc_3_270","micro_concept_id":"playtesting_iteration_loop"}],"prerequisites":["Basic computer navigation","Very light C# familiarity (variables and functions)"],"micro_concepts":[{"prerequisites":[],"learning_outcomes":["Explain the purpose of a GDD","Outline core mechanics, story, and scope in a short GDD"],"difficulty_level":"beginner","concept_id":"game_vision_gdd","name":"Game Vision & GDD","description":"Learn how to clarify your game idea and document it in a concise Game Design Document (GDD).","sequence_order":0.0},{"prerequisites":["game_vision_gdd"],"learning_outcomes":["List key features of Unity vs. Unreal","Select an engine based on project requirements"],"difficulty_level":"beginner","concept_id":"choosing_game_engine","name":"Choosing a Game Engine","description":"Compare Unity and Unreal Engine and decide which fits your project’s needs, budget, and skills.","sequence_order":1.0},{"prerequisites":["choosing_game_engine"],"learning_outcomes":["Initialize a Unity/Unreal project","Commit and push first changes to GitHub"],"difficulty_level":"beginner","concept_id":"project_setup_version_control","name":"Project Setup & Git","description":"Create a new project in your chosen engine and set up Git version control to track changes safely.","sequence_order":2.0},{"prerequisites":["project_setup_version_control"],"learning_outcomes":["Create and configure GameObjects with components","Explain how OOP supports reusable game entities"],"difficulty_level":"intermediate","concept_id":"objects_components_unity","name":"Objects & Components Basics","description":"Understand GameObjects, components, and prefabs in Unity (or Actors in Unreal) using object-oriented principles.","sequence_order":3.0},{"prerequisites":["objects_components_unity"],"learning_outcomes":["Write code for smooth player movement","Use Rigidbody velocity/forces for jumping correctly"],"difficulty_level":"intermediate","concept_id":"player_movement_jump","name":"Player Movement & Jump","description":"Implement 2D/3D character movement and a physics-based jump using Rigidbody (Unity) or Character Movement (Unreal).","sequence_order":4.0},{"prerequisites":["player_movement_jump"],"learning_outcomes":["Run structured playtest sessions","Apply feedback to refine gameplay"],"difficulty_level":"intermediate","concept_id":"playtesting_iteration_loop","name":"Playtesting & Iteration Loop","description":"Learn to test your game early, gather feedback, and iterate to improve mechanics and fix bugs.","sequence_order":5.0}],"selection_strategy":"Begin with foundational design documentation where the learner showed a misconception, then move step-by-step through the canonical indie-game workflow (engine choice → project setup → object/component thinking → player controls → playtesting). For each micro-concept I selected 1-2 high-quality segments, starting with a simple explanation and, when time allowed, following with a deeper or more application-oriented piece. Total runtime kept under 60 min.","updated_at":"2026-03-05T08:38:58.070587+00:00","generated_at":"2025-12-18T22:08:12Z","overall_coherence_score":8.6,"interleaved_practice":[{"difficulty":"mastery","correct_option_index":2.0,"question":"You’ve just finished coding a Rigidbody-based jump. Mid-playtest, a tester says the jump feels too floaty. Which adjustment BEST addresses this without rewriting your AddForce logic?","option_explanations":["Increasing mass would also dampen horizontal forces and may require retuning all physics interactions.","Lowering fixed-timestep changes simulation frequency globally and often harms performance rather than jump feel.","Correct. Higher gravity scale steepens descent while preserving Rigidbody physics.","Using transform.Translate ignores physics and produces inconsistent collisions."],"options":["Increase the mass of the Rigidbody","Lower the project’s fixed-timestep value","Raise the gravity scale in Unity’s Physics settings","Switch to transform.Translate for upward movement"],"question_id":"ipq1","related_micro_concepts":["player_movement_jump","playtesting_iteration_loop"],"discrimination_explanation":"Raising the gravity scale increases downward acceleration, tightening jump feel without altering the AddForce impulse. Mass and timestep changes have broader side effects, and transform.Translate bypasses physics entirely, defeating the purpose."},{"difficulty":"mastery","correct_option_index":2.0,"question":"During engine selection, you list ‘large 3D open world’ as a core requirement in your GDD. Which criterion from the course MOST directly supports choosing Unreal over Unity for this project?","option_explanations":["C# scripting points toward Unity, not Unreal.","2D animation tools are unrelated to a 3D open world focus.","Correct. Unreal’s rendering pipeline excels at large landscapes.","Licensing cost matters but is not the primary technical match here."],"options":["Availability of C# scripting","Superior 2D animation tools","Optimised large-world rendering pipeline","Lower annual licensing cost"],"question_id":"ipq2","related_micro_concepts":["game_vision_gdd","choosing_game_engine"],"discrimination_explanation":"Unreal’s strength in handling expansive 3D environments aligns with the large-world requirement. The other factors are either irrelevant to open worlds or favour Unity."},{"difficulty":"hard","correct_option_index":0.0,"question":"A teammate commits directly to the main branch and breaks the build. Which Git practice from the course would have PREVENTED this issue with the least workflow overhead?","option_explanations":["Correct. Feature branches keep unstable code away from main.","git gc only cleans storage; it doesn’t prevent bad commits.","Re-cloning doesn’t protect main; errors repeat during push.","Tracking all files clutters history and won’t stop build breaks."],"options":["Creating a feature branch from dev for the new work","Running git gc after every commit","Cloning the repository again before coding","Removing the .gitignore to track all files"],"question_id":"ipq3","related_micro_concepts":["project_setup_version_control"],"discrimination_explanation":"Feature branches isolate experimental changes until tested and reviewed, protecting main from breakage. The other options don’t address code isolation or safety."},{"difficulty":"hard","correct_option_index":1.0,"question":"A playtester is confused about the goal because your prototype lacks on-screen instructions. According to the GDD sections discussed, where should this usability note be recorded for the NEXT iteration?","option_explanations":["Art style is visual aesthetics, not usability text.","Correct. Mechanics encompass player guidance and interaction rules.","Story covers narrative beats, not interface clarity.","A commit message records the change but is not the planning document."],"options":["Art style guide","Mechanics detail section","Story synopsis","Git commit message"],"question_id":"ipq4","related_micro_concepts":["game_vision_gdd","playtesting_iteration_loop"],"discrimination_explanation":"UI/UX instructions relate to gameplay mechanics; updating the mechanics section ensures the next build includes clear instructional elements."},{"difficulty":"mastery","correct_option_index":0.0,"question":"You notice your Rigidbody player occasionally clips through the ground on high-speed falls. Which Unity component hierarchy insight from the course offers the FIRST troubleshooting step?","option_explanations":["Correct. Without a Collider, physics can’t detect ground contact.","Mass influences force reactions but not collision detection surfaces.","Mesh Renderer only affects visuals, not physics.","Changing time scale slows everything and masks rather than fixes physics issues."],"options":["Confirm the ground GameObject has a Collider component","Reduce the player’s mass value","Disable the Mesh Renderer on the player","Set the project’s time scale to 0.5"],"question_id":"ipq5","related_micro_concepts":["objects_components_unity","player_movement_jump"],"discrimination_explanation":"A missing or incorrectly sized Collider on the ground is the most direct cause of tunnelling. Mass and time scale tweaks are secondary, and rendering changes have no collision effect."}],"target_difficulty":"beginner","course_id":"course_1766094773","image_description":"A modern, inviting illustration aimed at high-school beginners. Foreground: a young developer wearing headphones sits at a desk covered with colourful sticky notes labeled “Idea”, “Jump”, and “Test”. On a large monitor in the middle ground, a Unity scene shows a simple character leaping between platforms. To the left of the screen, a neatly organised Game Design Document with sketchy icons is pinned to a corkboard; to the right, a GitHub window displays commit history. Background shows softly blurred shelves with game boxes and controller. Colour palette centres on energetic teal and warm orange accents, balanced by neutral greys for the workspace. Composition leaves the top third lightly detailed for overlay text, focusing the eye on the monitor and GDD. Mood: encouraging and creative, signalling a step-by-step journey from idea to playable game.","tradeoffs":[],"image_url":"https://course-builder-course-thumbnails.s3.us-east-1.amazonaws.com/courses/course_1766094773/thumbnail.png","generation_progress":100.0,"all_concepts_covered":["Creating and scaling a Game Design Document","Understanding and selecting a game engine","Setting up Git version control with Unity","Working with GameObjects and components","Implementing physics-based player movement and jump","Conducting effective early playtests"],"created_by":"Rahul Subramaniam","generation_error":null,"rejected_segments_rationale":"Skipped Unreal-specific animation and jump videos to keep focus on one engine (Unity) and avoid tool-switching load. Omitted longer Git workflow (10.5 min) due to time budget. Left out marketing and advanced system-design content as beyond beginner scope.","considerations":["Future iterations could add a segment on polishing visuals or sound","Git segment is moderate; a simpler intro might further lower entry barrier"],"assembly_rationale":"The course mirrors a mini production pipeline: document idea → pick tools → set up project → build core gameplay → test and iterate. This sequence matches authentic development practice, corrects identified misconceptions, and stays within 60-minute attention span. Complexity never jumps abruptly; each segment primes the next.","user_id":"google_102157240803562925683","strengths":["Focuses on practical steps with immediate application","Directly remedies learner’s documented knowledge gaps"],"key_decisions":["bro4rwYVo0I_54_330: Corrects learner’s GDD misconception; positioned first as simple design foundation.","bro4rwYVo0I_330_711: Builds detail on GDD scope; placed second to deepen same concept before moving on.","xrqRuxAkkG8_0_285: Introduces game-engine purpose; natural bridge from documenting vision to selecting tools.","aMgB018o71U_0_366: Provides criteria for choosing engines; follows introductory engine segment.","qpXxcvS-g3g_12_418: Gives hands-on Git/Unity workflow; satisfies project_setup_version_control concept.","vQY4jsho1nQ_0_392: First look at GameObjects/components; simple, visual, low cognitive load.","w9NmPShzPpE_0_281: Sets up sprites and rigidbody objects; gentle entry to movement code.","c9kxUvCKhwQ_0_568: Implements physics-based jump; directly addresses pre-test error.","Yb-znyOK5Kc_3_270: Introduces structured playtesting; final segment to instil iterative mindset."],"estimated_total_duration_minutes":53.0,"is_public":true,"generation_status":"completed","generation_step":"completed"}}