//bevy system signatures often violate these rules #![allow(clippy::type_complexity)] #![allow(clippy::too_many_arguments)] use avian3d::prelude::*; use bevy::prelude::*; pub struct StatePlugin; impl Plugin for StatePlugin { fn build(&self, app: &mut App) { app.init_state::() .enable_state_scoped_entities::() .add_sub_state::() .add_sub_state::() .enable_state_scoped_entities::() .add_computed_state::() .configure_sets( FixedUpdate, GameSystemSet::LoadingTick.run_if(in_state(GameState::Loading)), ) .configure_sets( FixedUpdate, ( // these all run before physics, which is in FixedPostUpdate by default GameSystemSet::PreTick, ( GameSystemSet::PrePlan.run_if(in_state(Phase::Plan)), GameSystemSet::PreExecute.run_if(in_state(Phase::Execute)), ), GameSystemSet::Tick, ( GameSystemSet::Plan.run_if(in_state(Phase::Plan)), GameSystemSet::Execute.run_if(in_state(Phase::Execute)), ), GameSystemSet::StatusEffects, GameSystemSet::DealDamage, GameSystemSet::PostTick, ( GameSystemSet::PostPlan.run_if(in_state(Phase::Plan)), GameSystemSet::PostExecute.run_if(in_state(Phase::Execute)), ), ) .run_if(in_state(GameState::Running)) .chain(), ) .configure_sets( Update, ( GameSystemSet::UpdateInputs, GameSystemSet::UI, ( GameSystemSet::PreUpdate, GameSystemSet::Update, GameSystemSet::PostUpdate, ) .run_if(in_state(GameState::Running)) .chain(), ) .chain(), ) .add_systems(OnEnter(GameState::Running), start_physics) .add_systems(OnExit(GameState::Running), stop_physics); } } #[derive(States, Default, Debug, Hash, PartialEq, Eq, Clone)] pub enum AppState { #[default] Setup, Menu, Game, } #[derive(Debug, Clone, Eq, PartialEq, Hash, SubStates, Default)] #[source(AppState = AppState::Game)] pub enum GameState { Loading, #[default] Running, Paused, } /// this is what you should set to change the state. do not read this for scheduling #[derive(Debug, Clone, Eq, PartialEq, Hash, SubStates)] #[source(AppState = AppState::Game)] pub enum BasePhaseState { Execute { phase: u32 }, Plan { phase: u32 }, } impl Default for BasePhaseState { fn default() -> Self { Self::Plan { phase: 1 } } } impl BasePhaseState { pub fn phase_count(&self) -> u32 { match self { BasePhaseState::Execute { phase } => *phase, BasePhaseState::Plan { phase } => *phase, } } } /// this is what you should read, as it takes into account the game state #[derive(Debug, Clone, Eq, PartialEq, Hash)] pub enum Phase { Execute, Plan, } impl ComputedStates for Phase { type SourceStates = (BasePhaseState, GameState); fn compute(sources: Self::SourceStates) -> Option { match sources { (_, GameState::Loading) | (_, GameState::Paused) => None, (BasePhaseState::Execute { .. }, GameState::Running) => Some(Self::Execute), (BasePhaseState::Plan { .. }, GameState::Running) => Some(Self::Plan), } } } #[derive(SystemSet, Debug, Hash, PartialEq, Eq, Clone)] pub enum GameSystemSet { // fixed update - contains all gameplay logic. does not run when game is paused LoadingTick, PreTick, PreExecute, PrePlan, Tick, Execute, Plan, StatusEffects, DealDamage, PostTick, PostExecute, PostPlan, // runs even if game is not loaded/active UpdateInputs, UI, // update - cosmetic only. does not run while game is paused PreUpdate, Update, PostUpdate, } fn start_physics(mut time: ResMut>) { time.unpause(); } fn stop_physics(mut time: ResMut>) { time.pause(); }