This technical overview is tailored for a review by a Senior Game Engine Architecture Committee. This group focuses on framework ergonomics, API evolution, and the implementation of ECS (Entity Component System) patterns for performant game logic.

Abstract:

This workshop provides an architectural deep dive into game development using Bevy 0.18, utilizing a Flappy Bird clone as the reference implementation. The material focuses on the transition to modern Bevy patterns, specifically highlighting the "Required Components" feature for automated entity composition and the "Observer" pattern for decoupled event handling. Key technical segments include the configuration of deterministic 2D projections for multi-resolution scaling, manual global transform computation for precise collision detection, and the integration of custom WGSL shaders for GPU-accelerated background scrolling. The session serves as a blueprint for bootstrapping Rust-based game projects, emphasizing modularity through the Bevy Plugin system and the separation of concerns between rendering schedules and fixed-step physics logic.

Technical Implementation Summary: Flappy Bird in Bevy 0.18

• [0:00] Engine Bootstrapping: Utilization of the Bevy CLI and App builder API to initialize the engine. The workflow emphasizes the DefaultPlugins suite, which handles modularized features like window management, asset loading, and 2D rendering.
• [5:02] Deterministic Camera Projections: Implementation of OrthographicProjection using ScalingMode::AutoMax. This ensures a fixed virtual resolution (480x270), providing a stable 16:9 aspect ratio that scales via integer multiples to 1080p and 4K, maintaining spatial consistency across various display hardware.
• [11:16] Component Composition via Requirements: Deployment of the "Required Components" attribute. By defining Player to require Gravity and Velocity, the engine automatically manages component insertion and initialization, reducing boilerplate and ensuring data integrity for game entities.
• [15:32] Schedule Synchronization: Separation of game logic into Update and FixedUpdate schedules. Movement and gravity calculations are assigned to FixedUpdate to ensure frame-rate independent physics, while rendering-specific updates remain in the variable-rate Update loop.
• [17:19] Event-Driven Observers: Implementation of the Observer pattern to handle EndGame events. This allows the system to trigger complex state changes—such as entity repositioning and component re-initialization—immediately following the conclusion of the triggering system's execution.
• [21:27] Modular Architecture: Organization of spatial logic into a standalone PipePlugin. This demonstrates the use of Bevy's Plugin trait to encapsulate systems, resources, and constants, facilitating a modular and maintainable codebase.
• [24:52] Asset Pipeline and Texture Filtering: Usage of 9-patch slicing (SpriteImageMode::Sliced) for pipe sprites to allow vertical scaling without distorting pixel art. The implementation also specifies ImageSampler::nearest filtering to maintain high-fidelity pixel edges on modern GPUs.
• [32:15] High-Precision Collision Detection: Construction of on-the-fly AABB2D and BoundingCircle volumes using the IntersectsVolume trait. To ensure zero-latency collision, the TransformHelper is used to force a synchronous update of GlobalTransform data before the standard end-of-frame accumulation.
• [34:44] Debug Gizmo Integration: Utilization of the Gizmos API for real-time visualization of invisible collision boundaries. The system demonstrates how to toggle these visuals via GizmoConfigGroup for development and production builds.
• [36:34] Reactive Resource Management: Implementation of a global Score resource. UI updates are optimized using the run_if(resource_changed::<Score>) condition, ensuring text rendering systems only execute when data state transitions occur.
• [38:45] WGSL Shader Programming: Integration of custom GPU logic through Material2d. A WGSL fragment shader is implemented to scroll UV coordinates over time, leveraging AddressMode::Repeat and global time uniforms to create a performant parallax background effect.
• [42:35] Procedural Animation and Polish: Final implementation of procedural pipe positioning using sine waves and dynamic sprite rotation. The bird's orientation is calculated using Vec2::angle_to, mapping its velocity vector to the Z-axis rotation for improved visual feedback during flight arcs.