Rust Game Development

Build and review Bevy game asset loading pipelines with typed asset catalogs, path validation, loading states, handle ownership, sprite sheets, audio, and runtime resource checks. Use when organizing Bevy assets, replacing hard-coded paths, adding loading screens, diagnosing missing handles, or packaging Rust game resources.

Design and review Bevy 2D collision broadphase systems with AABB bounds, spatial indexes, typed collision events, and benchmark-driven test beds. Use when replacing O(n^2) collision checks, adding spatial partitioning, diagnosing Bevy collision performance, or separating broadphase, narrowphase, and response systems in Rust games.

Design and review Bevy fixed-step 2D physics loops with velocity components, deterministic movement, collision prediction, interpolation, impulses, and tweened presentation. Use when movement depends on frame rate, collision misses appear at high speed, physics and animation are tangled, or Bevy gameplay needs stable simulation steps.

Build and review Bevy procedural world generation with grid resources, deterministic seeds, reachability checks, chunk or room spawning, background generation boundaries, and gameplay-safe entity materialization. Use when creating tile maps, dungeon-like spaces, mining bases, or generated levels in Rust Bevy games.

Design and review Bevy game state flow with plugins, AppState enums, OnEnter and OnExit setup, state-scoped cleanup, menus, pause screens, transitions, and run conditions. Use when adding reusable Bevy game state management, debugging duplicated entities after transitions, or separating menu, loading, playing, paused, and game-over logic.

Build and review bracket-lib style Rust 2D game loops, state structs, game modes, input handling, rendering calls, and restart flow. Use when creating a small Rust game with bracket-lib, porting a tutorial loop, or debugging tick/update/render state behavior.

Move Rust game monsters, items, loot, effects, spawn weights, level gates, and balance numbers into validated data files using Serde-friendly schemas. Use when replacing hard-coded spawn functions, adding RON or JSON content templates, or making game content editable without recompiling.

Finish and package small Rust games with MVP lock, playability checks, resource packaging, release builds, smoke tests, and disciplined post-MVP polish. Use when preparing a Rust game prototype for sharing, packaging bracket-lib assets, or deciding what finishing work belongs before release.

Plan small, playable Rust game implementation slices from a short design brief, MVP, stretch goals, and acceptance checks. Use when starting a Rust game, scoping a prototype, converting a game idea into work items, or preventing an AI coding agent from overbuilding.

Design and review Rust ECS gameplay code using Legion-style entities, components, resources, systems, schedules, queries, command buffers, and spawners. Use when building ECS-driven Rust game features, migrating game state into ECS, or debugging system ordering and component composition.

Design and review Rust roguelike procedural maps, map-builder traits, generator harnesses, field-of-view, spatial memory, Dijkstra/pathfinding, and simple monster AI. Use when adding dungeon generation, FOV, map memory, chasing behavior, or visibility-constrained AI to a Rust game.

Design and review Rust tile maps, map indexing, collision checks, map builders, camera-relative rendering, layered drawing, and tile themes. Use when building 2D grid worlds, roguelike maps, tile cameras, or bracket-lib style rendering systems.

Build and review turn-based Rust game flow using turn-state enums, phase-specific schedules, intent messages, movement resolution, combat resolution, wait actions, and win/loss states. Use when implementing roguelike turns, tactical action order, ECS message entities, or decoupled input and action systems.