davidbirchall/squad-skills-game-development

Camera engineering in Unity with Cinemachine - Cinemachine 2 vs 3 differences, virtual cameras or CinemachineCamera, brain, priority-based switching, follow and aim behaviours, blends, impulse and screen shake, confiner and collision avoidance, third-person orbital, first person, top-down and 2D pixel perfect cameras, Timeline and cutscene cameras, camera state tied to game state, camera-relative input, split-screen, FOV effects, motion-sickness accessibility options, update method and jitter, performance, and debugging. Load when setting up or debugging cameras, shake, blends, camera jitter, or player view options.

Character movement engineering in Unity and C# - choosing CharacterController vs Rigidbody kinematic or dynamic vs custom kinematic controller, Update vs FixedUpdate placement, input to intent to motion separation, ground detection with raycast spherecast or overlap, slopes and steps, gravity and variable-height jump with coyote time and buffering, acceleration curves, moving platforms, collision layers, Animator integration and root motion tradeoffs, locomotion state machine, camera-relative movement, 2D vs 3D differences, tuning exposure, gizmo debugging, and testing. Load when building or debugging player or NPC movement, jumping, grounding, slopes, platforms, or animation sync.

Unity-flavoured C# standards - naming, serialized fields vs public fields, properties, namespaces mapped to assembly definitions, nullable reference types caveats, Unity's overloaded null on UnityEngine.Object, readonly and const, events and unsubscription, coroutines vs async/await vs Awaitable vs UniTask with cancellation, LINQ and allocation habits, strings and boxing, struct vs class, generics, enums and flags, attributes, XML docs, analyzers and .editorconfig, and logging conventions. Load when writing or reviewing Unity C# code, setting a code style, or deciding on async, event, or null-handling patterns.

Accessibility in games - vision (colour-blind-safe palettes, non-colour cues, text scaling, contrast, high-contrast mode, screen reader and text-to-speech for menus), hearing (subtitles with size and background options, visual cues for audio, per-bus volume), motor (full remapping, hold versus toggle, adjustable timing and QTE alternatives, one-handed schemes, aim assist, input buffering), cognitive (difficulty and assist options, clear objectives, pause anywhere, reduced flashing and motion, photosensitivity limits), settings UX and persistence, designing options into systems early, testing checklist, and established guidelines. Load when designing or reviewing game options, menus, controls, UI, audio, or when auditing a game for accessibility.

NPC AI engineering in Unity - choosing between finite state machines, hierarchical FSMs, behaviour trees, utility AI, GOAP, and steering; separating perception, decision, and action; sight and hearing perception with memory; NavMesh navigation with the AI Navigation package; A* alternatives; time-sliced updates and AI LOD; blackboards; group coordination; difficulty exposure; debugging, determinism, and testing AI as plain C#. Load when designing, implementing, debugging, or optimising enemy or NPC behaviour.

Game telemetry in Unity - event schema (session, level, economy, tutorial, error events), typed event classes and naming, batching and offline queue, sampling and cost, privacy (consent gate, no PII, children's data caution), funnels, D1/D7/D30 retention cohorts, difficulty and balance metrics, economy health, crash and performance telemetry, dev-build versus release gating, analysing with SQL or spreadsheets, feeding results into logged balance decisions, and testing the pipeline. Load when adding telemetry to a game, designing events, analysing player behaviour, or tuning difficulty and economy from data.

Localisation engineering for Unity and C# games - string tables and keys with no hardcoded text, Unity Localization package basics, locale-aware formatting of numbers, dates, plurals and gender, fonts and glyph coverage (CJK, Arabic, Cyrillic), text expansion budgets and UI layout, right-to-left support, localising audio, images and voice, pseudo-localisation testing, translator and machine-translation context notes, fallback locale, locale persistence, build size impact, QA checklist, and scripts to extract and validate strings. Load when adding text to a game, preparing for translation, adding a language, or debugging missing glyphs, overflow, or wrong formatting.

Runtime performance practices for Unity games - frame budgets, CPU and GC allocation avoidance, caching, event-driven updates, pooling, Jobs and Burst when justified, rendering cost (batching, SRP Batcher, instancing, overdraw, LOD, culling, lighting, post-processing, dynamic resolution), memory, loading hitches, mobile constraints, quality tiers, per-feature budgets, and regression guarding. Load when a game misses its frame or memory target, when reviewing code for runtime cost, or when setting performance budgets. Measure first with game-profiling.

Measure Unity CPU, GPU, memory, GC, loading, and build-size problems using Profiler, Frame Debugger, Memory Profiler, target devices, and automated reports. Load when investigating a performance symptom or collecting evidence; use game-performance for the fix.

Game flow and runtime state in Unity and C# - game state machine for boot, menu, loading, playing, paused and game over, stack states for pause and overlays, scene loading flow with additive and async loads, bootstrap scene and loading screens, Time.timeScale pause pitfalls, runtime vs persistent state, single source of truth and state ownership, state change events, session and run data, persistent service lifetime and DontDestroyOnLoad, static state with domain reload disabled, and testing state machines. Load when designing game flow, pause, scene transitions, global services, or debugging state that leaks between sessions or scenes.

Store distribution preparation for Unity (C#) games across PC, console and mobile stores in a platform-neutral way - store requirements checklist (build format, age rating, privacy policy, store page assets, trailer and screenshot specs), build pipeline to uploadable artifacts, versioning and build numbers, achievements, cloud saves and entitlements behind interfaces, store SDK isolation, crash and log reporting, EULA and third-party notices from the licence register, pre-submission test matrix, staged rollout and beta branches, patch and hotfix paths, post-release metrics and review monitoring as data, and refund and delisting awareness. Load when preparing a game for a store submission, integrating store services, or planning release and post-release operations.

Gameplay feature engineering in Unity and C# - composable component-based entities, ability and effect pipelines, stats with base/add/multiply modifiers, health and damage pipeline with resistances and death handling, interaction systems with raycast or overlap, inventory and item data as ScriptableObject definitions vs runtime instances, status effects with central ticking, event decoupling between systems, spawning and pooling, objectives and quest state, cooldowns, exposed tuning values, fixed timestep determinism, and testing gameplay rules as plain C#. Load when building or reviewing abilities, combat, stats, inventory, interactions, quests, or spawners.

Unity Input System package engineering - Input Actions asset, action maps and control schemes, PlayerInput vs generated C# class vs direct action references, action types Value Button and PassThrough, interactions and processors, composite bindings, started/performed/canceled callbacks vs polling, runtime rebinding with saved overrides, multiple devices and local multiplayer with PlayerInputManager, device switching and prompt glyphs, gamepad dead zones and rumble, touch input, input buffering and coyote windows, enabling maps by game state, unsubscribing on disable, testing with InputTestFixture, and legacy Input Manager migration. Load when adding or reviewing player input, rebinding, controller support, or input bugs.

Multiplayer networking engineering for Unity and C# games - deciding whether multiplayer is worth its cost, topologies (authoritative client-server, host-client, peer-to-peer, relay), choosing a networking library (Netcode for GameObjects, Mirror, Fish-Net, Photon and others) by criteria, authority and ownership, state synchronisation vs RPCs vs events, tick rate and snapshot interpolation, client-side prediction and reconciliation, lag compensation basics, bandwidth budgets, determinism pitfalls, serialisation, anti-cheat basics, lobbies, matchmaking and relay services, testing under simulated latency and loss, debugging desync, and keeping single-player code separable. Load when adding or evaluating multiplayer, designing network architecture, syncing gameplay state, or debugging lag, desync, or cheating.

Unity physics engineering for 3D (PhysX) and 2D (Box2D) - FixedUpdate rules, Rigidbody movement (forces, velocity, MovePosition), interpolation and collision detection modes, collider choice, trigger versus collision callbacks, layers and the collision matrix, raycasts and overlap queries with non-allocating variants, materials, joints, timestep settings, determinism limits, transform sync cost, ragdolls, projectiles and tunnelling, debugging, and performance. Load when implementing or debugging physics, collisions, queries, projectiles, or physics cost.

Procedural content generation engineering in Unity C# - seeded deterministic generation, noise, algorithm selection (BSP, cellular automata, drunkard's walk, wave function collapse, L-systems, Poisson-disc, graph grammars, tile versus voxel), validation passes, data-first generation pipelines, chunking and time-sliced streaming, Mesh API basics, Burst and Jobs options, authored hybrids, saving as seed plus deltas, debug tooling, and testing with fixed seeds. Load when building or debugging level, terrain, dungeon, or item generators.

Persistence engineering for Unity and C# games - what to save vs derive, save data models as plain serialisable classes, stable unique ids for saveable objects, serialisation choices (JsonUtility, Newtonsoft JSON, binary), Application.persistentDataPath, atomic writes with backups, versioning and migrations, corruption handling and validation, checksums vs encryption, autosave and checkpoint policy, slots with metadata and thumbnails, cloud saves, async IO, saving during scene transitions, PlayerPrefs for small settings, and round-trip and migration testing. Load when designing save files, adding saveable state, migrating save formats, or debugging lost or corrupt saves.

In-game and menu UI engineering in Unity - UI Toolkit versus uGUI selection, Canvas setup and scaling, safe area, layout cost and canvas splitting, TextMeshPro, gamepad and keyboard navigation with the EventSystem, new Input System UI module, MVP and MVVM binding to game state, screen stack and modal management, event-driven HUDs, localisation readiness, accessibility, animation, virtualised lists, loading screens, UI performance, and testing UI flows. Load when building or reviewing menus, HUDs, popups, UI navigation, or UI performance.

Runtime architecture for Unity C# projects - composition over inheritance, thin MonoBehaviours with logic in plain C# classes, dependency injection options, ScriptableObject event channels vs C# events vs message buses, singletons and bootstrapping, update loop ownership, initialisation order, data-driven design, model-view separation, state machines, assembly boundaries enforcing dependency direction, testing with the Unity Test Framework, and when to adopt ECS/DOTS. Load when designing systems, splitting code into assemblies, choosing communication patterns, structuring for testability, or reviewing coupling.

Unity asset pipeline and memory management - import settings for textures, models and audio, naming and folders, Addressables groups, labels, async loading, reference counting and release, remote content and catalog updates, comparison with Resources and direct references, AssetBundles, memory budgets, shared dependencies and duplicates, atlasing, LODs, Git LFS, asset auditing, art and audio hand-off specs, loading strategies, and leak detection. Load when configuring imports, adopting Addressables, setting memory or size budgets, auditing assets, or fixing loading hitches and leaks.

Unity builds and release engineering - Build Profiles vs Build Settings, scripting backends Mono and IL2CPP, managed code stripping and link.xml, player settings and versioning, scripting define symbols, development vs release builds, scenes in build, batchmode CI builds with GameCI or the Unity CLI, BuildPipeline scripts, licence activation in CI, signing and platform requirements, size optimisation and build reports, release checklists, crash reporting and analytics, QA smoke tests on target hardware, rollback, and store submission. Load when setting up builds or CI, cutting a release, debugging build-only failures, or reducing build size.

Unity Editor productivity and workflows - custom inspectors and PropertyDrawers, inspector attributes, OnValidate, editor-only code separation with Editor folders, asmdefs and UNITY_EDITOR, gizmos and debug draws, menu items and editor scripts for repeatable tasks, ScriptableObject-based tooling, validation tooling, prefab workflow, Play Mode domain reload settings and pitfalls, layouts and shortcuts, version control hygiene, batchmode automation, Test Framework runs, and Cinemachine and Timeline hand-offs. Load when building editor tools, improving data-authoring workflows, validating project data, or configuring the Editor.

Unity project structure and repository hygiene - folder layout, naming, scene organisation with bootstrap and additive scenes, prefab rules for nesting, variants and overrides, ScriptableObject use for config and event channels, avoiding Resources, package manifest pinning, Git setup with .gitignore, .gitattributes, Git LFS, force-text serialization and UnityYAMLMerge, meta files, tags and layers policy, Project Settings as code, render pipeline asset setup (URP default), assembly definitions, a project README for future sessions, and branching for binary assets. Load when creating a Unity project, reorganising folders, setting up version control, or recording project conventions.

Automated testing for Unity projects - Unity Test Framework with NUnit, Edit Mode versus Play Mode tests, test assembly definitions, structuring code for testability with plain C# logic classes, interfaces and ScriptableObject data, testing coroutines and async with UnityTest, deterministic time and random number injection, input testing with Input System fixtures, scene and prefab smoke tests, balance data validation tests, performance tests, headless CI runs with batchmode and results XML, flaky test policy, and what not to test. Load when adding tests to a Unity project, making game code testable, setting up CI test runs, or fixing flaky tests.