1016 lines
33 KiB
Rust
1016 lines
33 KiB
Rust
//! Local developer overlays and their controller-driven palette.
|
|
|
|
use std::{collections::HashMap, time::Duration};
|
|
|
|
use bevy::{
|
|
camera::{CameraOutputMode, visibility::RenderLayers}, input::InputSystems, prelude::*, render::render_resource::BlendState, settings::{ReflectSettingsGroup, SaveSettingsDeferred, SettingsGroup},
|
|
};
|
|
use bevy_egui::{EguiContexts, EguiGlobalSettings, EguiPrimaryContextPass, PrimaryEguiContext, egui};
|
|
use bevy_ggrs::{RollbackFrameRate, RunGgrsSystems};
|
|
use enum_cycling::EnumCycle;
|
|
use enum_cycling_derive::EnumCycle;
|
|
|
|
use crate::{AppState, player::Player, replay::StopReplayRecording};
|
|
|
|
mod save_state;
|
|
|
|
pub const PLAYER_DEBUG_ROW_COUNT: usize = 6;
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, Reflect)]
|
|
pub enum FighterDebugRowKind {
|
|
None,
|
|
CurrentState,
|
|
Velocity,
|
|
Input,
|
|
Position,
|
|
Facing,
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Reflect)]
|
|
pub enum PresentationMotionMode {
|
|
#[default]
|
|
Interpolation,
|
|
Extrapolation,
|
|
}
|
|
|
|
impl PresentationMotionMode {
|
|
pub const fn label(self) -> &'static str {
|
|
match self {
|
|
Self::Interpolation => "Interpolation",
|
|
Self::Extrapolation => "Extrapolation",
|
|
}
|
|
}
|
|
|
|
fn cycle(&mut self) {
|
|
*self = match self {
|
|
Self::Interpolation => Self::Extrapolation,
|
|
Self::Extrapolation => Self::Interpolation,
|
|
};
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, EnumCycle, Reflect)]
|
|
pub enum GameSpeedDebug {
|
|
Full,
|
|
Half,
|
|
Quarter,
|
|
}
|
|
|
|
impl GameSpeedDebug {
|
|
pub const fn label(&self) -> &'static str {
|
|
match self {
|
|
GameSpeedDebug::Full => "1.0x",
|
|
GameSpeedDebug::Half => "0.5x",
|
|
GameSpeedDebug::Quarter => "0.25x",
|
|
}
|
|
}
|
|
|
|
pub fn frame_rate(&self) -> usize {
|
|
match self {
|
|
GameSpeedDebug::Full => 60,
|
|
GameSpeedDebug::Half => 30,
|
|
GameSpeedDebug::Quarter => 15,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl FighterDebugRowKind {
|
|
const ALL: [Self; 6] = [
|
|
Self::None,
|
|
Self::CurrentState,
|
|
Self::Velocity,
|
|
Self::Input,
|
|
Self::Position,
|
|
Self::Facing,
|
|
];
|
|
|
|
pub const fn label(self) -> &'static str {
|
|
match self {
|
|
Self::None => "None",
|
|
Self::CurrentState => "Current state",
|
|
Self::Velocity => "Velocity",
|
|
Self::Input => "Input",
|
|
Self::Position => "Position",
|
|
Self::Facing => "Facing",
|
|
}
|
|
}
|
|
|
|
fn cycle(self, direction: i8) -> Self {
|
|
let index = Self::ALL
|
|
.iter()
|
|
.position(|kind| *kind == self)
|
|
.expect("all row kinds must be listed") as i8;
|
|
let index = (index + direction).rem_euclid(Self::ALL.len() as i8) as usize;
|
|
Self::ALL[index]
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Copy)]
|
|
enum DebugFlag {
|
|
Network,
|
|
Ecb,
|
|
BlastZones,
|
|
StageCollision,
|
|
SpawnPositions,
|
|
AnimationBones,
|
|
AttackHitboxes,
|
|
Hurtboxes,
|
|
Camera,
|
|
LedgeGrab,
|
|
DrawThroughGeometry,
|
|
FrameStepping,
|
|
}
|
|
|
|
#[derive(Clone, Copy)]
|
|
enum DebugMenuEntry {
|
|
StopRecording {
|
|
label: &'static str,
|
|
},
|
|
Toggle {
|
|
label: &'static str,
|
|
flag: DebugFlag,
|
|
},
|
|
Submenu {
|
|
label: &'static str,
|
|
entries: &'static [DebugMenuEntry],
|
|
},
|
|
PlayerSlots {
|
|
label: &'static str,
|
|
},
|
|
MotionSampling {
|
|
label: &'static str,
|
|
},
|
|
GameSpeed {
|
|
label: &'static str,
|
|
},
|
|
}
|
|
|
|
const FIGHTER_MENU: &[DebugMenuEntry] = &[
|
|
DebugMenuEntry::PlayerSlots {
|
|
label: "Player windows",
|
|
},
|
|
DebugMenuEntry::Toggle {
|
|
label: "ECB",
|
|
flag: DebugFlag::Ecb,
|
|
},
|
|
DebugMenuEntry::Toggle {
|
|
label: "Animation bones",
|
|
flag: DebugFlag::AnimationBones,
|
|
},
|
|
DebugMenuEntry::Toggle {
|
|
label: "Camera",
|
|
flag: DebugFlag::Camera,
|
|
},
|
|
DebugMenuEntry::Toggle {
|
|
label: "Attack hitboxes",
|
|
flag: DebugFlag::AttackHitboxes,
|
|
},
|
|
DebugMenuEntry::Toggle {
|
|
label: "Ledge grab",
|
|
flag: DebugFlag::LedgeGrab,
|
|
},
|
|
DebugMenuEntry::Toggle {
|
|
label: "Hurtboxes",
|
|
flag: DebugFlag::Hurtboxes,
|
|
},
|
|
];
|
|
|
|
const WORLD_MENU: &[DebugMenuEntry] = &[
|
|
DebugMenuEntry::Toggle {
|
|
label: "Stage collision",
|
|
flag: DebugFlag::StageCollision,
|
|
},
|
|
DebugMenuEntry::Toggle {
|
|
label: "Blast zones",
|
|
flag: DebugFlag::BlastZones,
|
|
},
|
|
DebugMenuEntry::Toggle {
|
|
label: "Spawn points",
|
|
flag: DebugFlag::SpawnPositions,
|
|
},
|
|
DebugMenuEntry::GameSpeed {
|
|
label: "Game speed",
|
|
},
|
|
DebugMenuEntry::Toggle {
|
|
label: "Frame stepping",
|
|
flag: DebugFlag::FrameStepping,
|
|
},
|
|
];
|
|
|
|
const DIAGNOSTICS_MENU: &[DebugMenuEntry] = &[DebugMenuEntry::Toggle {
|
|
label: "Network stats",
|
|
flag: DebugFlag::Network,
|
|
}];
|
|
|
|
const RENDERING_MENU: &[DebugMenuEntry] = &[
|
|
DebugMenuEntry::MotionSampling {
|
|
label: "Motion sampling",
|
|
},
|
|
DebugMenuEntry::Toggle {
|
|
label: "Draw through geometry",
|
|
flag: DebugFlag::DrawThroughGeometry,
|
|
},
|
|
];
|
|
|
|
const ROOT_MENU: &[DebugMenuEntry] = &[
|
|
DebugMenuEntry::StopRecording {
|
|
label: "Stop replay recording",
|
|
},
|
|
DebugMenuEntry::Submenu {
|
|
label: "Fighter",
|
|
entries: FIGHTER_MENU,
|
|
},
|
|
DebugMenuEntry::Submenu {
|
|
label: "World",
|
|
entries: WORLD_MENU,
|
|
},
|
|
DebugMenuEntry::Submenu {
|
|
label: "Diagnostics",
|
|
entries: DIAGNOSTICS_MENU,
|
|
},
|
|
DebugMenuEntry::Submenu {
|
|
label: "Rendering",
|
|
entries: RENDERING_MENU,
|
|
},
|
|
];
|
|
|
|
#[derive(Clone, Copy)]
|
|
enum DebugMenuPage {
|
|
Static(&'static [DebugMenuEntry]),
|
|
PlayerList,
|
|
PlayerRows(usize),
|
|
}
|
|
|
|
#[derive(Resource, SettingsGroup, Reflect)]
|
|
#[reflect(Resource, SettingsGroup, Default)]
|
|
pub struct DebugSettings {
|
|
#[reflect(ignore)]
|
|
pub menu_open: bool,
|
|
#[reflect(ignore)]
|
|
controller: Option<Entity>,
|
|
#[reflect(ignore)]
|
|
pages: Vec<DebugMenuPage>,
|
|
#[reflect(ignore)]
|
|
selections: Vec<usize>,
|
|
#[reflect(ignore)]
|
|
pub player_rows: HashMap<usize, [FighterDebugRowKind; PLAYER_DEBUG_ROW_COUNT]>,
|
|
#[reflect(ignore)]
|
|
pub frame_stepping: bool,
|
|
pub network: bool,
|
|
pub ecb: bool,
|
|
pub blast_zones: bool,
|
|
pub stage_collision: bool,
|
|
pub spawn_positions: bool,
|
|
pub animation_bones: bool,
|
|
pub attack_hitboxes: bool,
|
|
pub hurtboxes: bool,
|
|
pub camera: bool,
|
|
pub ledge_grab: bool,
|
|
pub draw_through_geometry: bool,
|
|
pub motion_sampling: PresentationMotionMode,
|
|
pub game_speed: GameSpeedDebug,
|
|
}
|
|
|
|
impl Default for DebugSettings {
|
|
fn default() -> Self {
|
|
Self {
|
|
menu_open: false,
|
|
controller: None,
|
|
pages: vec![DebugMenuPage::Static(ROOT_MENU)],
|
|
selections: vec![0],
|
|
player_rows: HashMap::new(),
|
|
frame_stepping: false,
|
|
network: false,
|
|
ecb: false,
|
|
blast_zones: false,
|
|
stage_collision: false,
|
|
spawn_positions: false,
|
|
animation_bones: false,
|
|
attack_hitboxes: false,
|
|
hurtboxes: false,
|
|
camera: false,
|
|
ledge_grab: false,
|
|
draw_through_geometry: false,
|
|
motion_sampling: PresentationMotionMode::default(),
|
|
game_speed: GameSpeedDebug::Full,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl DebugSettings {
|
|
pub fn player_rows(
|
|
&self,
|
|
handle: usize,
|
|
) -> Option<&[FighterDebugRowKind; PLAYER_DEBUG_ROW_COUNT]> {
|
|
self.player_rows.get(&handle)
|
|
}
|
|
|
|
fn reset_navigation(&mut self) {
|
|
self.pages.truncate(1);
|
|
self.selections.truncate(1);
|
|
self.selections[0] = 0;
|
|
}
|
|
|
|
fn page(&self) -> DebugMenuPage {
|
|
*self
|
|
.pages
|
|
.last()
|
|
.expect("debug menu always has a root page")
|
|
}
|
|
|
|
fn selected(&self) -> usize {
|
|
*self
|
|
.selections
|
|
.last()
|
|
.expect("debug menu always has a root selection")
|
|
}
|
|
|
|
fn selected_mut(&mut self) -> &mut usize {
|
|
self.selections
|
|
.last_mut()
|
|
.expect("debug menu always has a root selection")
|
|
}
|
|
|
|
fn push_page(&mut self, page: DebugMenuPage) {
|
|
self.pages.push(page);
|
|
self.selections.push(0);
|
|
}
|
|
|
|
fn pop_page(&mut self) -> bool {
|
|
if self.pages.len() == 1 {
|
|
return false;
|
|
}
|
|
self.pages.pop();
|
|
self.selections.pop();
|
|
true
|
|
}
|
|
|
|
fn flag(&self, flag: DebugFlag) -> bool {
|
|
match flag {
|
|
DebugFlag::Network => self.network,
|
|
DebugFlag::Ecb => self.ecb,
|
|
DebugFlag::BlastZones => self.blast_zones,
|
|
DebugFlag::SpawnPositions => self.spawn_positions,
|
|
DebugFlag::StageCollision => self.stage_collision,
|
|
DebugFlag::AnimationBones => self.animation_bones,
|
|
DebugFlag::AttackHitboxes => self.attack_hitboxes,
|
|
DebugFlag::Hurtboxes => self.hurtboxes,
|
|
DebugFlag::DrawThroughGeometry => self.draw_through_geometry,
|
|
DebugFlag::Camera => self.camera,
|
|
DebugFlag::LedgeGrab => self.ledge_grab,
|
|
DebugFlag::FrameStepping => self.frame_stepping,
|
|
}
|
|
}
|
|
|
|
fn toggle_flag(&mut self, flag: DebugFlag) {
|
|
match flag {
|
|
DebugFlag::Network => self.network = !self.network,
|
|
DebugFlag::Ecb => self.ecb = !self.ecb,
|
|
DebugFlag::BlastZones => self.blast_zones = !self.blast_zones,
|
|
DebugFlag::StageCollision => self.stage_collision = !self.stage_collision,
|
|
DebugFlag::SpawnPositions => self.spawn_positions = !self.spawn_positions,
|
|
DebugFlag::AnimationBones => self.animation_bones = !self.animation_bones,
|
|
DebugFlag::AttackHitboxes => self.attack_hitboxes = !self.attack_hitboxes,
|
|
DebugFlag::Hurtboxes => self.hurtboxes = !self.hurtboxes,
|
|
DebugFlag::DrawThroughGeometry => {
|
|
self.draw_through_geometry = !self.draw_through_geometry
|
|
}
|
|
DebugFlag::Camera => self.camera = !self.camera,
|
|
DebugFlag::LedgeGrab => self.ledge_grab = !self.ledge_grab,
|
|
DebugFlag::FrameStepping => self.frame_stepping = !self.frame_stepping,
|
|
}
|
|
}
|
|
|
|
fn cycle_motion_sampling(&mut self) {
|
|
self.motion_sampling.cycle();
|
|
}
|
|
|
|
fn rows_mut(&mut self, handle: usize) -> &mut [FighterDebugRowKind; PLAYER_DEBUG_ROW_COUNT] {
|
|
self.player_rows
|
|
.entry(handle)
|
|
.or_insert([FighterDebugRowKind::None; PLAYER_DEBUG_ROW_COUNT])
|
|
}
|
|
}
|
|
|
|
pub struct DebugToolsPlugin;
|
|
|
|
#[derive(Resource, Default)]
|
|
struct FrameStepState {
|
|
requested: bool,
|
|
time_backup: Option<Time>,
|
|
last_step_time: Time
|
|
}
|
|
|
|
impl Plugin for DebugToolsPlugin {
|
|
fn build(&self, app: &mut App) {
|
|
app.init_resource::<DebugSettings>()
|
|
.init_resource::<FrameStepState>()
|
|
.init_resource::<save_state::DebugSaveState>()
|
|
.add_systems(OnEnter(AppState::InMatch), save_state::clear)
|
|
.add_systems(OnExit(AppState::InMatch), save_state::clear)
|
|
.add_systems(
|
|
PreUpdate,
|
|
prepare_frame_step
|
|
.after(InputSystems)
|
|
.before(RunGgrsSystems)
|
|
.run_if(in_state(AppState::InMatch)),
|
|
)
|
|
.add_systems(
|
|
PreUpdate,
|
|
save_state::save_or_restore
|
|
.after(InputSystems)
|
|
.before(RunGgrsSystems)
|
|
.run_if(in_state(AppState::InMatch)),
|
|
)
|
|
.add_systems(Startup, spawn_egui_camera)
|
|
.add_systems(PreUpdate, restore_frame_step_time.after(RunGgrsSystems))
|
|
.add_systems(
|
|
Update,
|
|
(handle_palette_input, sync_gizmo_depth_bias)
|
|
.chain()
|
|
.run_if(in_state(AppState::InMatch)),
|
|
)
|
|
.add_systems(EguiPrimaryContextPass, draw_palette);
|
|
}
|
|
}
|
|
|
|
pub fn spawn_egui_camera(mut commands: Commands, mut egui_global_settings: ResMut<EguiGlobalSettings>,) {
|
|
egui_global_settings.auto_create_primary_context = false;
|
|
commands.spawn((
|
|
// The `PrimaryEguiContext` component requires everything needed to render a primary context.
|
|
PrimaryEguiContext,
|
|
Camera2d,
|
|
// Setting RenderLayers to none makes sure we won't render anything apart from the UI.
|
|
RenderLayers::none(),
|
|
Camera {
|
|
order: 2,
|
|
output_mode: CameraOutputMode::Write {
|
|
blend_state: Some(BlendState::ALPHA_BLENDING),
|
|
clear_color: ClearColorConfig::None,
|
|
},
|
|
clear_color: ClearColorConfig::Custom(Color::NONE),
|
|
..default()
|
|
},
|
|
));
|
|
}
|
|
|
|
fn player_handles(players: &Query<&Player>) -> Vec<usize> {
|
|
let mut handles = players
|
|
.iter()
|
|
.map(|player| player.handle)
|
|
.collect::<Vec<_>>();
|
|
handles.sort_unstable();
|
|
handles.dedup();
|
|
handles
|
|
}
|
|
|
|
fn page_len(page: DebugMenuPage, player_handles: &[usize]) -> usize {
|
|
match page {
|
|
DebugMenuPage::Static(entries) => entries.len(),
|
|
DebugMenuPage::PlayerList => player_handles.len(),
|
|
DebugMenuPage::PlayerRows(_) => PLAYER_DEBUG_ROW_COUNT,
|
|
}
|
|
}
|
|
|
|
fn queue_settings_save(commands: &mut Commands) {
|
|
commands.queue(SaveSettingsDeferred(Duration::from_secs_f32(0.1)));
|
|
}
|
|
|
|
fn frame_step_duration(frame_rate: usize) -> Duration {
|
|
Duration::from_nanos(1_000_000_000u64 / frame_rate as u64)
|
|
}
|
|
|
|
fn prepare_frame_step(
|
|
settings: Res<DebugSettings>,
|
|
gamepads: Query<&Gamepad>,
|
|
key: Res<ButtonInput<KeyCode>>,
|
|
mut state: ResMut<FrameStepState>,
|
|
mut time: ResMut<Time>,
|
|
frame_rate: Res<RollbackFrameRate>,
|
|
) {
|
|
if !settings.frame_stepping {
|
|
state.requested = false;
|
|
return;
|
|
}
|
|
|
|
let pressed = gamepads
|
|
.iter()
|
|
.any(|gamepad| gamepad.pressed(GamepadButton::DPadDown));
|
|
|
|
let just_pressed = gamepads
|
|
.iter()
|
|
.any(|gamepad| gamepad.just_pressed(GamepadButton::DPadDown));
|
|
|
|
let just_pressed = key.just_pressed(KeyCode::F4) || just_pressed;
|
|
let pressed = key.pressed(KeyCode::F4) || pressed;
|
|
|
|
if just_pressed {
|
|
state.last_step_time = time.clone();
|
|
}
|
|
|
|
let can_repress = pressed && (time.elapsed() - state.last_step_time.elapsed()).as_millis() > 500;
|
|
|
|
if !settings.menu_open && (just_pressed || can_repress)
|
|
{
|
|
state.requested = true;
|
|
}
|
|
|
|
state.time_backup = Some(*time);
|
|
let delta = if state.requested {
|
|
frame_step_duration(**frame_rate)
|
|
} else {
|
|
Duration::ZERO
|
|
};
|
|
time.advance_by(delta);
|
|
}
|
|
|
|
fn restore_frame_step_time(mut state: ResMut<FrameStepState>, mut time: ResMut<Time>) {
|
|
if let Some(backup) = state.time_backup.take() {
|
|
*time = backup;
|
|
state.requested = false;
|
|
}
|
|
}
|
|
|
|
fn activate_selected(
|
|
settings: &mut DebugSettings,
|
|
page_len: usize,
|
|
player_handles: &[usize],
|
|
commands: &mut Commands,
|
|
) {
|
|
if page_len == 0 {
|
|
return;
|
|
}
|
|
|
|
match settings.page() {
|
|
DebugMenuPage::Static(entries) => match entries[settings.selected()] {
|
|
DebugMenuEntry::StopRecording { .. } => {
|
|
commands.insert_resource(StopReplayRecording);
|
|
}
|
|
DebugMenuEntry::Toggle { flag, .. } => {
|
|
settings.toggle_flag(flag);
|
|
if !matches!(flag, DebugFlag::FrameStepping) {
|
|
queue_settings_save(commands);
|
|
}
|
|
}
|
|
DebugMenuEntry::Submenu { entries, .. } => {
|
|
settings.push_page(DebugMenuPage::Static(entries));
|
|
}
|
|
DebugMenuEntry::PlayerSlots { .. } => settings.push_page(DebugMenuPage::PlayerList),
|
|
DebugMenuEntry::MotionSampling { .. } => {
|
|
settings.cycle_motion_sampling();
|
|
queue_settings_save(commands);
|
|
}
|
|
DebugMenuEntry::GameSpeed { .. } => {
|
|
commands.insert_resource(RollbackFrameRate(settings.game_speed.frame_rate()));
|
|
queue_settings_save(commands);
|
|
}
|
|
},
|
|
DebugMenuPage::PlayerList => {
|
|
let handle = player_handles[settings.selected()];
|
|
settings.rows_mut(handle);
|
|
settings.push_page(DebugMenuPage::PlayerRows(handle));
|
|
}
|
|
DebugMenuPage::PlayerRows(_) => {}
|
|
}
|
|
}
|
|
|
|
fn cycle_selected_value(settings: &mut DebugSettings, direction: i8, commands: &mut Commands) {
|
|
match settings.page() {
|
|
DebugMenuPage::Static(entries) => {
|
|
if let Some(entry) = entries.get(settings.selected()) {
|
|
match entry {
|
|
DebugMenuEntry::MotionSampling { .. } => {
|
|
settings.cycle_motion_sampling();
|
|
queue_settings_save(commands);
|
|
}
|
|
DebugMenuEntry::GameSpeed { .. } => {
|
|
settings.game_speed = if direction > 0 {
|
|
settings.game_speed.up()
|
|
} else {
|
|
settings.game_speed.down()
|
|
};
|
|
commands
|
|
.insert_resource(RollbackFrameRate(settings.game_speed.frame_rate()));
|
|
queue_settings_save(commands);
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
DebugMenuPage::PlayerRows(handle) => {
|
|
let selected = settings.selected();
|
|
let rows = settings.rows_mut(handle);
|
|
rows[selected] = rows[selected].cycle(direction);
|
|
queue_settings_save(commands);
|
|
}
|
|
DebugMenuPage::PlayerList => {}
|
|
}
|
|
}
|
|
|
|
fn handle_palette_input(
|
|
keyboard: Res<ButtonInput<KeyCode>>,
|
|
gamepads: Query<(Entity, &Gamepad)>,
|
|
players: Query<&Player>,
|
|
mut settings: ResMut<DebugSettings>,
|
|
mut commands: Commands,
|
|
) {
|
|
if keyboard.just_pressed(KeyCode::KeyT) {
|
|
settings.toggle_flag(DebugFlag::DrawThroughGeometry);
|
|
}
|
|
|
|
if keyboard.just_pressed(KeyCode::F3) {
|
|
settings.menu_open = !settings.menu_open;
|
|
settings.controller = None;
|
|
if settings.menu_open {
|
|
settings.reset_navigation();
|
|
}
|
|
return;
|
|
}
|
|
|
|
if !settings.menu_open {
|
|
for (entity, gamepad) in &gamepads {
|
|
if gamepad.just_pressed(GamepadButton::Start) && gamepad.pressed(GamepadButton::DPadUp)
|
|
{
|
|
settings.menu_open = true;
|
|
settings.controller = Some(entity);
|
|
settings.reset_navigation();
|
|
return;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
let gamepad = if let Some(controller) = settings.controller {
|
|
let Ok((_, gamepad)) = gamepads.get(controller) else {
|
|
settings.menu_open = false;
|
|
settings.controller = None;
|
|
return;
|
|
};
|
|
Some(gamepad)
|
|
} else {
|
|
None
|
|
};
|
|
let player_handles = player_handles(&players);
|
|
let page = settings.page();
|
|
let page_len = page_len(page, &player_handles);
|
|
|
|
if page_len != 0 && settings.selected() >= page_len {
|
|
*settings.selected_mut() = 0;
|
|
}
|
|
|
|
if (gamepad.is_some_and(|pad| pad.just_pressed(GamepadButton::DPadUp))
|
|
|| keyboard.just_pressed(KeyCode::ArrowUp)
|
|
|| keyboard.just_pressed(KeyCode::KeyW))
|
|
&& page_len != 0
|
|
{
|
|
let selected = settings.selected_mut();
|
|
*selected = selected.checked_sub(1).unwrap_or(page_len - 1);
|
|
}
|
|
if (gamepad.is_some_and(|pad| pad.just_pressed(GamepadButton::DPadDown))
|
|
|| keyboard.just_pressed(KeyCode::ArrowDown)
|
|
|| keyboard.just_pressed(KeyCode::KeyS))
|
|
&& page_len != 0
|
|
{
|
|
let selected = settings.selected_mut();
|
|
*selected = (*selected + 1) % page_len;
|
|
}
|
|
|
|
let direction = if gamepad.is_some_and(|pad| pad.just_pressed(GamepadButton::DPadLeft))
|
|
|| keyboard.just_pressed(KeyCode::ArrowLeft)
|
|
|| keyboard.just_pressed(KeyCode::KeyA)
|
|
{
|
|
Some(-1)
|
|
} else if gamepad.is_some_and(|pad| pad.just_pressed(GamepadButton::DPadRight))
|
|
|| keyboard.just_pressed(KeyCode::ArrowRight)
|
|
|| keyboard.just_pressed(KeyCode::KeyD)
|
|
{
|
|
Some(1)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
if let Some(direction) = direction {
|
|
cycle_selected_value(&mut settings, direction, &mut commands);
|
|
}
|
|
if (gamepad.is_some_and(|pad| pad.just_pressed(GamepadButton::South))
|
|
|| keyboard.just_pressed(KeyCode::Enter)
|
|
|| keyboard.just_pressed(KeyCode::Space))
|
|
&& page_len != 0
|
|
{
|
|
activate_selected(&mut settings, page_len, &player_handles, &mut commands);
|
|
}
|
|
if (gamepad.is_some_and(|pad| pad.just_pressed(GamepadButton::West))
|
|
|| keyboard.just_pressed(KeyCode::Escape))
|
|
&& !settings.pop_page()
|
|
{
|
|
settings.menu_open = false;
|
|
settings.controller = None;
|
|
}
|
|
}
|
|
|
|
fn sync_gizmo_depth_bias(settings: Res<DebugSettings>, mut configs: ResMut<GizmoConfigStore>) {
|
|
if !settings.is_changed() {
|
|
return;
|
|
}
|
|
let depth_bias = if settings.draw_through_geometry {
|
|
-1.0
|
|
} else {
|
|
0.0
|
|
};
|
|
for (_, config, _) in configs.iter_mut() {
|
|
config.depth_bias = depth_bias;
|
|
}
|
|
}
|
|
|
|
fn draw_palette(
|
|
mut contexts: EguiContexts,
|
|
mut settings: ResMut<DebugSettings>,
|
|
players: Query<&Player>,
|
|
mut commands: Commands,
|
|
) -> Result {
|
|
if !settings.menu_open {
|
|
return Ok(());
|
|
}
|
|
|
|
let player_handles = player_handles(&players);
|
|
let page = settings.page();
|
|
let page_len = page_len(page, &player_handles);
|
|
egui::Window::new("Debug")
|
|
.anchor(egui::Align2::RIGHT_TOP, egui::vec2(-12.0, 12.0))
|
|
.resizable(false)
|
|
.show(contexts.ctx_mut()?, |ui| {
|
|
ui.style_mut().override_font_id = Some(egui::FontId::proportional(20.0));
|
|
match page {
|
|
DebugMenuPage::Static(entries) => {
|
|
for (index, entry) in entries.iter().enumerate() {
|
|
ui.horizontal(|ui| {
|
|
ui.label(if index == settings.selected() {
|
|
">"
|
|
} else {
|
|
" "
|
|
});
|
|
match entry {
|
|
DebugMenuEntry::StopRecording { label } => {
|
|
if ui.button(*label).clicked() {
|
|
*settings.selected_mut() = index;
|
|
activate_selected(
|
|
&mut settings,
|
|
page_len,
|
|
&player_handles,
|
|
&mut commands,
|
|
);
|
|
}
|
|
}
|
|
DebugMenuEntry::Toggle { label, flag } => {
|
|
let mut value = settings.flag(*flag);
|
|
if ui.checkbox(&mut value, *label).changed() {
|
|
settings.toggle_flag(*flag);
|
|
if !matches!(flag, DebugFlag::FrameStepping) {
|
|
queue_settings_save(&mut commands);
|
|
}
|
|
}
|
|
}
|
|
DebugMenuEntry::Submenu { label, .. }
|
|
| DebugMenuEntry::PlayerSlots { label } => {
|
|
if ui.button(format!("{label} >")).clicked() {
|
|
*settings.selected_mut() = index;
|
|
activate_selected(
|
|
&mut settings,
|
|
page_len,
|
|
&player_handles,
|
|
&mut commands,
|
|
);
|
|
}
|
|
}
|
|
DebugMenuEntry::MotionSampling { label } => {
|
|
let old = settings.motion_sampling;
|
|
egui::ComboBox::from_id_salt(("debug-motion", index))
|
|
.width(180.0)
|
|
.selected_text(format!("{label}: {}", old.label()))
|
|
.show_ui(ui, |ui| {
|
|
ui.selectable_value(
|
|
&mut settings.motion_sampling,
|
|
PresentationMotionMode::Interpolation,
|
|
"Interpolation",
|
|
);
|
|
ui.selectable_value(
|
|
&mut settings.motion_sampling,
|
|
PresentationMotionMode::Extrapolation,
|
|
"Extrapolation",
|
|
);
|
|
});
|
|
if settings.motion_sampling != old {
|
|
queue_settings_save(&mut commands);
|
|
}
|
|
}
|
|
DebugMenuEntry::GameSpeed { label } => {
|
|
let old = settings.game_speed;
|
|
egui::ComboBox::from_id_salt(("debug-speed", index))
|
|
.width(180.0)
|
|
.selected_text(format!("{label}: {}", old.label()))
|
|
.show_ui(ui, |ui| {
|
|
for speed in [
|
|
GameSpeedDebug::Full,
|
|
GameSpeedDebug::Half,
|
|
GameSpeedDebug::Quarter,
|
|
] {
|
|
ui.selectable_value(
|
|
&mut settings.game_speed,
|
|
speed,
|
|
speed.label(),
|
|
);
|
|
}
|
|
});
|
|
if settings.game_speed != old {
|
|
commands.insert_resource(RollbackFrameRate(
|
|
settings.game_speed.frame_rate(),
|
|
));
|
|
queue_settings_save(&mut commands);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
}
|
|
DebugMenuPage::PlayerList => {
|
|
for (index, handle) in player_handles.iter().enumerate() {
|
|
ui.horizontal(|ui| {
|
|
ui.label(if index == settings.selected() {
|
|
">"
|
|
} else {
|
|
" "
|
|
});
|
|
if ui.button(format!("Player {} >", handle + 1)).clicked() {
|
|
*settings.selected_mut() = index;
|
|
activate_selected(
|
|
&mut settings,
|
|
page_len,
|
|
&player_handles,
|
|
&mut commands,
|
|
);
|
|
}
|
|
});
|
|
}
|
|
if player_handles.is_empty() {
|
|
ui.label("No players in match");
|
|
}
|
|
}
|
|
DebugMenuPage::PlayerRows(handle) => {
|
|
let rows = settings
|
|
.player_rows(handle)
|
|
.copied()
|
|
.unwrap_or([FighterDebugRowKind::None; PLAYER_DEBUG_ROW_COUNT]);
|
|
ui.label(format!("Player {}", handle + 1));
|
|
for (index, row) in rows.iter().enumerate() {
|
|
ui.horizontal(|ui| {
|
|
ui.label(if index == settings.selected() {
|
|
">"
|
|
} else {
|
|
" "
|
|
});
|
|
egui::ComboBox::from_id_salt(("debug-row", handle, index))
|
|
.width(180.0)
|
|
.selected_text(format!("Row {}: {}", index + 1, row.label()))
|
|
.show_ui(ui, |ui| {
|
|
let rows = settings.rows_mut(handle);
|
|
for kind in FighterDebugRowKind::ALL {
|
|
ui.selectable_value(&mut rows[index], kind, kind.label());
|
|
}
|
|
});
|
|
});
|
|
}
|
|
}
|
|
}
|
|
ui.separator();
|
|
let controls = if matches!(page, DebugMenuPage::PlayerRows(_)) {
|
|
"Arrows/WASD: select/change Escape/B: back"
|
|
} else {
|
|
"Arrows/WASD: select Enter/A: activate Escape/B: back"
|
|
};
|
|
ui.label(controls);
|
|
});
|
|
Ok(())
|
|
}
|
|
|
|
pub fn fighter_info_enabled(settings: Res<DebugSettings>) -> bool {
|
|
settings
|
|
.player_rows
|
|
.values()
|
|
.any(|rows| rows.iter().any(|row| *row != FighterDebugRowKind::None))
|
|
}
|
|
|
|
pub fn network_enabled(settings: Res<DebugSettings>) -> bool {
|
|
settings.network
|
|
}
|
|
|
|
pub fn ecb_enabled(settings: Res<DebugSettings>) -> bool {
|
|
settings.ecb
|
|
}
|
|
|
|
pub fn stage_collision_enabled(settings: Res<DebugSettings>) -> bool {
|
|
settings.stage_collision
|
|
}
|
|
|
|
pub fn blast_zones_enabled(settings: Res<DebugSettings>) -> bool {
|
|
settings.blast_zones
|
|
}
|
|
|
|
pub fn spawn_positions_enabled(settings: Res<DebugSettings>) -> bool {
|
|
settings.spawn_positions
|
|
}
|
|
|
|
pub fn animation_bones_enabled(settings: Res<DebugSettings>) -> bool {
|
|
settings.animation_bones
|
|
}
|
|
|
|
pub fn attack_hitboxes_enabled(settings: Res<DebugSettings>) -> bool {
|
|
settings.attack_hitboxes
|
|
}
|
|
|
|
pub fn hurtboxes_enabled(settings: Res<DebugSettings>) -> bool {
|
|
settings.hurtboxes
|
|
}
|
|
|
|
pub fn camera_debug_enabled(settings: Res<DebugSettings>) -> bool {
|
|
settings.camera
|
|
}
|
|
|
|
pub fn ledge_grab_enabled(settings: Res<DebugSettings>) -> bool {
|
|
settings.ledge_grab
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn player_rows_default_to_none_and_wrap() {
|
|
let mut settings = DebugSettings::default();
|
|
let rows = settings.rows_mut(2);
|
|
|
|
assert_eq!(*rows, [FighterDebugRowKind::None; PLAYER_DEBUG_ROW_COUNT]);
|
|
rows[0] = rows[0].cycle(-1);
|
|
assert_eq!(rows[0], FighterDebugRowKind::Facing);
|
|
rows[0] = rows[0].cycle(1);
|
|
assert_eq!(rows[0], FighterDebugRowKind::None);
|
|
}
|
|
|
|
#[test]
|
|
fn nested_navigation_preserves_parent_selection() {
|
|
let mut settings = DebugSettings::default();
|
|
*settings.selected_mut() = 2;
|
|
settings.push_page(DebugMenuPage::Static(DIAGNOSTICS_MENU));
|
|
|
|
assert!(settings.pop_page());
|
|
assert_eq!(settings.selected(), 2);
|
|
assert!(!settings.pop_page());
|
|
}
|
|
|
|
#[test]
|
|
fn player_row_configuration_is_slot_specific() {
|
|
let mut settings = DebugSettings::default();
|
|
settings.rows_mut(0)[0] = FighterDebugRowKind::CurrentState;
|
|
|
|
assert_eq!(
|
|
settings.player_rows(0).unwrap()[0],
|
|
FighterDebugRowKind::CurrentState
|
|
);
|
|
assert!(settings.player_rows(1).is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn presentation_motion_mode_cycles_between_choices() {
|
|
let mut mode = PresentationMotionMode::Interpolation;
|
|
|
|
mode.cycle();
|
|
assert_eq!(mode, PresentationMotionMode::Extrapolation);
|
|
mode.cycle();
|
|
assert_eq!(mode, PresentationMotionMode::Interpolation);
|
|
}
|
|
|
|
#[test]
|
|
fn game_speed_has_expected_frame_rates() {
|
|
assert_eq!(GameSpeedDebug::Full.frame_rate(), 60);
|
|
assert_eq!(GameSpeedDebug::Half.frame_rate(), 30);
|
|
assert_eq!(GameSpeedDebug::Quarter.frame_rate(), 15);
|
|
}
|
|
|
|
#[test]
|
|
fn frame_stepping_is_disabled_by_default_and_uses_game_speed_timestep() {
|
|
let settings = DebugSettings::default();
|
|
|
|
assert!(!settings.frame_stepping);
|
|
assert_eq!(frame_step_duration(60), Duration::from_nanos(16_666_666));
|
|
assert_eq!(frame_step_duration(30), Duration::from_nanos(33_333_333));
|
|
}
|
|
|
|
#[test]
|
|
fn empty_player_list_does_not_activate() {
|
|
let mut settings = DebugSettings::default();
|
|
settings.push_page(DebugMenuPage::PlayerList);
|
|
|
|
assert_eq!(page_len(settings.page(), &[]), 0);
|
|
assert_eq!(settings.selected(), 0);
|
|
}
|
|
}
|