everything-game-dev-code

Generate real game assets (images, skyboxes, 3D models, SFX, music, voice, video) from text prompts through the provider registry, with provenance and acceptance gates.

Define creation, naming, and replacement rules for placeholder assets so the game is testable before final art exists.

Compose Godot 3D scenes with sound Node3D structure, cameras, physics bodies, environment ownership, and 3D performance patterns.

Define authoring, export, root motion, and retargeting rules for skeletal 3D animation clips.

Define export, scale, pivot, and naming rules for 3D assets so every model imports correctly without per-asset fixes.

Define lighting policy, light budgets, LOD chains, and culling rules so 3D scenes look intentional and hit frame budgets.

Define material libraries, PBR texture conventions, and shader budgets so surfacing stays consistent and batchable.

Define skeleton, skinning, and attachment conventions so rigs deform well, share animations, and stay within budgets.

Build real-time 3D scenes for browser games — scene/camera/light setup, glTF pipeline, GPU budgets, and disposal discipline.

Implement Godot input through InputMap actions with correct event propagation, device support, and rebinding.

Implement Unreal input with Enhanced Input — Input Actions, Mapping Contexts, triggers/modifiers, and runtime remapping.

Design moment-to-moment feedback — hit-stop, screen shake, tweening, and response timing — so actions feel readable and satisfying.

Design procedural content systems with seeds, constraints, and validation gates so generated output stays fun and shippable.

Configure build tooling and ship browser game builds to static hosts with repeatable release hygiene.

Apply canvas 2D and WebGL rendering conventions for crisp scaling, clean layering, and batched draws.

Structure the game loop, fixed-timestep simulation, state machines, and decoupled systems for a browser game.

Abstract input into named actions across keyboard, mouse, touch, and gamepad, including mobile on-screen controls.

Write readable, maintainable JavaScript or TypeScript game code with consistent modules, typing, and tooling.

Keep a browser game inside its frame budget through allocation discipline, pooling, and devtools-driven profiling.

Organize a web game project so the entry point, modules, assets, configuration, and tests stay predictable.

Test browser games with fast unit tests for pure logic, headless smoke tests, and a deliberate browser matrix.

Define authoring, import, and state machine rules for frame-by-frame and skeletal 2D animations.

Define acceptance, validation, and runtime integration rules for raster assets generated with image models before they become real project content.

Define import, slicing, atlas packing, and naming rules for 2D sprite assets.

Define transition, feedback, and state-driven animation rules for UI elements.

Define import, 9-slice, atlas packing, theming, and naming rules for UI visual assets (buttons, panels, icons, bars).

Define the primary player activity loop and the support loops that sustain mastery, variety, and progression.

Structure animation state, blending, events, and sync so authored motion remains reliable under gameplay pressure.

Define system ownership, boundaries, state flow, and extensibility for gameplay code across engines.

Design input around player intent and supported device families instead of hardcoding device-specific behavior everywhere.

Set and manage frame, load, memory, streaming, or bandwidth budgets before performance debt becomes structural.

Structure HUD and menu implementation so UI remains understandable, maintainable, and aligned with UX goals.

Build a coverage matrix that shows what must be tested, on which configurations, and at what milestone confidence level.

Evaluate whether a build is genuinely ready for external testing, certification, store submission, or launch.

Create or update a Game Design Document that is actionable for design, engineering, QA, production, and content teams.

Build milestone plans that are dependency-aware, risk-aware, and tied to real delivery outcomes.

Turn feature intent into a Technical Design Document that is implementable, reviewable, and testable.

Define a vertical slice that proves gameplay, quality bars, and production viability without over-building the full game.

Define tileset creation, auto-tile rules, collision shapes, and tilemap configuration for 2D levels.

Manage dialogue and text content so it remains editable, implementable, localizable, and testable.