Recommended start
Economy foundations
From a clear decision goal through flow, rates, one-session budget, trust, pacing, and readable feedback - the full beginner foundation graph.
Open the roadmapOpen learning graph
Start with a path or pick one topic
Free topics and paths for learning game development. Paths keep the sequence. Cards give a focused answer when you already know the question.
Learning paths
Learning path
Game Design foundations
Build readable player decisions: core loop, first-session teaching, meaningful choice, feedback timing, and fairness perception.
Open the roadmapLearning path
Unity Engine Foundations
GameObjects, components, scenes, hierarchy, and prefabs - the mental model every Unity project is built from, before you write a single system.
Open the roadmapLearning path
Unity Gameplay Systems
Input, physics, UI, data, and scene flow - the gameplay systems every Unity game actually needs, with ownership kept explicit.
Open the roadmapLearning path
Unity Shipping Systems
Pooling, profiling, saves, builds, and a ship checklist - the last mile between a working prototype and a released Unity game.
Open the roadmap- Object pooling in Unity with explicit state
- Coroutines vs State Machines: Sequencing Without Blocking Update
- Reading a Profiler Without Guessing
- Unity Mobile 60 FPS: Draw Calls & Zero-GC Budgeting
- Save Systems: What Survives a Session vs a Restart
- Build Settings and Platform Targets: What Changes at Build Time
- Ship Checklist: From Vertical Slice to Store Submission
Learning path
MCP for Game Development - Beginner
Build a safe mental model for MCP in game development: primitives, rules and skills, narrow Unity context, and client-specific control surfaces.
Open the roadmapLearning path
MCP for Game Development - Intermediate
Design narrow MCP tools, reduce context cost, gate changes with evidence, apply high-value Unity workflows, and protect permission boundaries.
Open the roadmapLearning path
MCP for Game Development - Advanced
Engineer production-ready MCP systems through lifecycle design, stable contracts, multi-agent ownership, outcome-level observability, hardening, and a verified Unity capstone.
Open the roadmapNo paths match this field.
Choose a field
All topics
Define a system goal
State the decision the model should support before adding resources.
Game economy flow: from goal to feedback
Trace one invented resource from goal through choice to a readable signal.
Source and sink balance
Compare the rate resources enter against the rate legitimate choices remove them.
Design a one-session economy budget
Plan earn and spend for one sitting so leftover and starvation stay readable.
Energy as a session gate
Bound a sitting with energy or stamina without cutting a core loop mid-beat.
Diagnose economy inflation
See what unchecked source rates do across many weeks of play.
Soft and hard currency
Draw the trust boundary between earned and paid currency.
Progression pacing curves
Read a reward curve's shape, not just its total.
Currency sink catalog
Sort a purchase into cosmetic, convenience, power, or time-skip, then match it to the currency whose trust boundary can carry it.
Core loop
Name the repeating intent → action → result → re-entry cycle players must feel.
Teach the loop in the first session
Rehearse the core loop early so the first sitting feels like a game, not a feature tour.
Meaningful choice
Force a tradeoff players can explain - not two buttons that feel the same.
Make risk and reward readable
Preview gain, cost, and downside before commit so bold forks teach instead of surprise.
Check the feedback loop
Ask how one choice changes the next visible decision.
Fairness perception
Players judge fairness by visible cause and effect, not spreadsheet evenness alone.
Core loop vs meta loop
Tell the loop that repeats in seconds apart from the one that repeats in sessions, or you'll fix the wrong one.
Game Feel & Juice: The 30ms Feedback Rule
Turn floaty mobile actions into punchy interactions using hitstop, camera damping, and micro-dopamine feedback.
Hybrid-Casual Architecture: Core Arcade to Deep Meta
Marry simple single-finger core mechanics with deep RPG/talent meta loops to maximize mobile LTV.
Idle Arcade & Stacking Pacing: Shifting Bottlenecks
Balance generator, porter logistics, and cashier sinks using exponential upgrade curves ($Cost = Base \times 1.15^N$).
Unity Mobile 60 FPS: Draw Calls & Zero-GC Budgeting
Eliminate frame stutter and thermal throttling by keeping batches under 100 and Update heap allocations at 0 Bytes.
What Unity Actually Is (Editor, Engine, Project)
See how the Editor, the runtime engine, and your project files divide responsibility before you write a line of code. Short card.
GameObjects and Components: Unity's Building Blocks
Compose behavior from small components instead of inheriting it, and see why that split shapes every Unity project.
Scenes and Hierarchy: Where Your Game Actually Lives
Read a scene as a saved GameObject tree, and see why hierarchy position controls more than you expect.
Transform and Space: Parent, Child, Local vs World
Separate local from world space before a parented object starts moving in ways you did not expect.
Prefabs: One Source, Many Instances
Separate the source prefab from its instances and overrides before scripting starts touching either one.
Define a component boundary
Give one invented runtime component one clear responsibility. Short card.
Reading Player Input: Devices, Actions, and Bindings
Separate a named action from the device binding that triggers it so your input keeps working across devices.
Rigidbody vs Collider vs Trigger: Who Owns the Bump?
Give physics, shape, and reaction each their own owner before two colliders start fighting over the same event.
Prefer events over Update ownership
Keep reaction ownership on the event that caused the change, not a polling Update.
UI Canvas Basics: Anchors, Scaling, and a Dumb View
Anchor UI to the screen it should survive, and keep the canvas a dumb view instead of a second source of truth.
ScriptableObjects as a Data Boundary
Move shared config into a ScriptableObject asset so invented economy data stops living inside a MonoBehaviour.
Scene Flow and Persistent Managers: Avoiding the God Object
Carry state across scenes with one narrow persistent manager instead of a single object that owns everything.
Object pooling in Unity with explicit state
Keep acquire, reset, and return ownership visible when reusing objects.
Coroutines vs State Machines: Sequencing Without Blocking Update
Compare a coroutine's linear wait against an explicit state machine's named states before sequencing gets tangled.
Reading a Profiler Without Guessing
Find the frame's actual cost in the profiler before guessing which system to optimize first.
Save Systems: What Survives a Session vs a Restart
Decide what state must survive a restart before picking a save format for it.
Build Settings and Platform Targets: What Changes at Build Time
See which decisions move from the Editor to build settings once you target a real platform.
Ship Checklist: From Vertical Slice to Store Submission
Work through the technical checklist that turns a vertical slice into a submittable build.
MCP for Game Development: A Bridge, Not Magic
Place MCP between an agent and approved game-development context without treating the connection as autonomous judgment.
MCP Tools, Resources, and Prompts
Choose the smallest MCP primitive for an action, a readable context source, or a reusable interaction template.
MCP vs Rules vs Skills vs Scripts
Separate live capabilities, standing instructions, reusable expertise, and deterministic automation before adding another layer.
Connect a Coding Agent to Unity Context Safely
Expose a narrow Unity context surface, verify it read-only first, and keep every mutation behind an explicit review boundary.
Claude Code, Cursor, Codex, and Antigravity: Same Server, Different Controls
Compare how four coding clients expose the same MCP server through different setup, approval, and control surfaces.
Design Narrow MCP Read and Write Tools
Give each MCP tool one bounded job, an explicit input contract, and a result small enough to review before widening permissions.
Do More with Less MCP Context
Use filtering, pagination, summaries, and progressive discovery so only decision-relevant Unity context reaches the model.
The Controlled MCP Change Loop
Turn an agent request into an inspect, plan, approve, change, test, and review sequence with evidence at every boundary.
High-Value Unity MCP Workflows
Apply narrow MCP capabilities to console triage, scene inspection, prefab review, build checks, and tests without granting broad control.
MCP Permissions, Secrets, and Prompt-Injection Boundaries
Keep least privilege, secret custody, untrusted tool output, and human approval explicit before an MCP workflow can mutate a project.
MCP Server Architecture, Transports, and Lifecycle
Design the server boundary from initialization and capability negotiation through transport-safe operation and shutdown.
Stable MCP Tool Contracts and Error Semantics
Keep tool inputs, structured outputs, errors, and cancellation behavior predictable as clients and servers evolve.
Multi-Agent Ownership, Handoffs, and Conflict Avoidance
Partition files, evidence, and write authority so parallel agents can hand work off without silently overwriting one another.
MCP Observability: From Tool Calls to Task Success
Trace progress, logs, tool results, verification gates, and user outcomes without mistaking call volume for useful work.
Production Hardening for MCP Servers
Harden version, authorization, secret, network, cancellation, and failure boundaries before a server reaches real projects.
Capstone: Unity Diagnosis to Verified Change
Combine bounded diagnosis, ownership, an approved mutation, tests, build evidence, and human review into one end-to-end Unity workflow.
No topics match these filters.