Sefism Game Development Cheat Sheet

What this cheat sheet is

The Game development cheat sheet is the quick-revision companion to Sefism's Game development roadmap. It covers how games are made, programming in your engine, the engine's core systems, game maths and feel, design, art and audio, performance, builds, shipping and careers, in nine chapters that follow the roadmap's order.

Each concept is written the same way: what it is in plain words, why it matters, a short code snippet where code helps, and the classic mistake people make with it. It is meant to be skimmed before a jam or a new feature, and each chapter links to library resources when a concept needs more depth.

Three editions: Unity, Godot and Unreal Engine

Most of the sheet is shared, because a vector, a playtest or a store page works the same in any engine. The engine-specific parts change with the edition you read:

• Unity edition: C# scripting and the MonoBehaviour lifecycle, GetComponent, prefabs, the Input System and Unity's physics.
• Godot edition: typed GDScript, nodes, scenes and the scene tree, signals, packed scenes, the input map and physics bodies.
• Unreal Engine edition: Blueprints first, then C++ with UCLASS, UPROPERTY and UFUNCTION, actors and components, the gameplay framework and Enhanced Input.

Each edition has around 76 to 77 concepts. Every edition is public at its own address, so you can read the code in your own engine before you sign up.

Chapter by chapter

1. How games are made (9 concepts)

The game loop (with a short pseudocode loop), what a game engine is, engine licences and fees, scope control, cloning classic games, choosing 2D or 3D, prototypes and vertical slices, game jams, and version control for games, including what an engine project should leave out of Git.

2. Programming for games (13 concepts across editions)

How game code is structured: the script lifecycle, components and composition, exposed variables and events (C# events, Godot signals or Unreal dispatchers). The edition-specific concepts sit here: MonoBehaviour and GetComponent and C# essentials for Unity; nodes, scenes and the scene tree and GDScript with static typing for Godot; Blueprints, the UCLASS, UPROPERTY and UFUNCTION macros and the Unreal gameplay framework for Unreal. It closes with state machines and debugging games.

3. The engine in depth (9 concepts)

Scenes and levels, prefabs, packed scenes and Blueprint classes, input actions, physics bodies, collisions, triggers and layers, animation state machines, game UI, game audio, and saving and loading.

4. Game maths and feel (9 concepts)

Vectors, transforms and spaces, delta time, the fixed timestep, interpolation and easing, rotations and quaternions, the game camera, juice and game feel, and randomness done well. This is the chapter to reread when movement feels wrong.

5. Game design basics (8 concepts)

The core loop, mechanics, dynamics and aesthetics, level design, difficulty curves, onboarding, playtesting, using player feedback, and the one-page design document.

6. Art and audio for programmers (9 concepts)

Greyboxing and placeholder art, asset licences, free asset sources, pixel art basics, low-poly 3D, sprite sheets and atlases, sound effects, music and mixing, and visual readability.

7. Performance and builds (9 concepts)

The frame budget, the profiler, draw calls and batching, object pooling (with code), garbage and memory, build targets, mobile builds, platform requirements, and testing builds on real hardware.

8. Shipping and publishing (8 concepts)

Releasing on itch.io, Steam Direct, the Coming Soon page, the store page, the trailer, wishlists and marketing, mobile store release, and launch and updates.

9. Money and careers (7 concepts)

Indie income as it really is, payouts and tax forms, studio roles, the game portfolio, studio programming tests, publishers and deals, and the scams aimed at game developers.

Rules of thumb and glossary

The sheet ends with rules of thumb and an A to Z glossary. Ten rules apply to each edition: nine shared ones (finish small games, make the core mechanic fun with grey boxes first, multiply movement and timers by delta time, watch people play without helping, keep a credits file, test a real build every week, profile before optimising, check licences and store rules on the official pages, never pay a publisher upfront) and one for your engine. The glossary gathers the sheet's concepts and 133 to 139 smaller terms depending on the edition, so you can look up a word you meet in a tutorial without leaving the sheet.

How to use it with the roadmap

• After each stage: read the matching chapter and check you can explain every concept without looking. Anything you cannot explain is what to revisit.
• Before a jam or a new feature: skim the chapters on the systems you are about to touch (input, physics, UI, saving) and the pitfalls attached to them.
• While building: keep the maths and feel chapter and the performance chapter open; they answer most "why does this stutter or feel floaty" questions.
• Before a studio programming test: chapters 2, 4 and 7 cover the core gameplay programming ground.

How it works on Sefism

The public page at /cheatsheets/game-dev/ shows every chapter's title and introduction, with the first chapters open to read in full. Everything on Sefism is free to learn from. Keeping a cheat sheet is one of the few actions that uses credits; new members get starting credits when they join, and if you are learning seriously and run out you can ask for more. Keeping the sheet opens every chapter in the member area.

If you follow the Game development roadmap, the cheat sheet comes with it: following a roadmap also unlocks its own cheat sheet, and your first roadmap is free. Each roadmap topic links to the concepts in the sheet that cover it.

Related on Sefism

• The Game development roadmap this sheet accompanies.
• Game Programming Patterns, linked from the first chapter.
• Red Blob Games for the maths chapter.
• Kenney assets and Freesound for the art and audio chapter.
• Finished small 2D game with a playtest log, a project to apply the whole sheet to.

Frequently asked questions

Is this a substitute for the engine's documentation? No. It is a revision tool. Each chapter points to the official manual or docs for your engine, and the roadmap reminds you to trust the docs for your engine version when a tutorial disagrees.

Which edition should I read? The one for the engine you build in. If you are still choosing, read chapter 1 and the engine licences concept, then pick one and stay with it.

Does it cover Steam and mobile store releases? Yes, at concept level: chapter 8 covers Steam Direct, the Coming Soon page, store pages, trailers, wishlists and mobile store release. Fees and rules change, so the sheet tells you to confirm them on the official pages.