use bevy::asset::embedded_asset;
use bevy::prelude::*;
use crate::audio::{SfxConfig, SfxEvent, SfxRequest};
use crate::player::PlayerConfig;
use crate::world::{ChunkManager, WorldConfig};
pub const EMBEDDED_NOTO_SANS_PATH: &str = "embedded://voxel_framework/ui/NotoSans-Regular.ttf";
pub const EMBEDDED_NOTO_SYMBOLS_PATH: &str =
"embedded://voxel_framework/ui/NotoSansSymbols2-Regular.ttf";
#[derive(States, Debug, Clone, PartialEq, Eq, Hash, Default)]
pub enum PauseMenuState {
#[default]
Playing,
Paused,
Settings,
}
const BTN_NORMAL: Color = Color::srgb(0.15, 0.15, 0.20);
const BTN_HOVERED: Color = Color::srgb(0.25, 0.25, 0.35);
const BTN_PRESSED: Color = Color::srgb(0.35, 0.35, 0.50);
const OVERLAY: Color = Color::srgba(0.0, 0.0, 0.0, 0.78);
#[derive(Component)]
struct PauseMenuRoot;
#[derive(Component)]
struct SettingsMenuRoot;
#[derive(Component)]
struct FovLabel;
#[derive(Component)]
struct VolumeLabel;
#[derive(Component)]
struct RenderDistLabel;
#[derive(Component)]
struct SensitivityLabel;
#[derive(Component)]
enum PauseButton {
Resume,
Settings,
Quit,
}
#[derive(Component)]
enum SettingsButton {
FovInc,
FovDec,
VolumeInc,
VolumeDec,
RenderDistInc,
RenderDistDec,
SensitivityInc,
SensitivityDec,
Back,
}
#[derive(Message, Debug, Clone)]
pub struct SaveSettingsRequest;
#[derive(Resource, Clone)]
pub struct PauseMenuConfig {
pub font: Handle<Font>,
pub symbol_font: Handle<Font>,
}
impl Default for PauseMenuConfig {
fn default() -> Self {
Self {
font: Handle::default(),
symbol_font: Handle::default(),
}
}
}
pub struct PauseMenuPlugin;
impl Plugin for PauseMenuPlugin {
fn build(&self, app: &mut App) {
embedded_asset!(app, "NotoSans-Regular.ttf");
embedded_asset!(app, "NotoSansSymbols2-Regular.ttf");
app.init_resource::<PauseMenuConfig>();
app.init_state::<PauseMenuState>();
app.add_message::<SaveSettingsRequest>();
app.add_systems(Startup, load_default_font);
app.add_systems(
Update,
toggle_pause.run_if(in_state(PauseMenuState::Playing)),
);
app.add_systems(
OnEnter(PauseMenuState::Paused),
(spawn_pause_menu, release_cursor),
);
app.add_systems(OnExit(PauseMenuState::Paused), despawn_pause_menu);
app.add_systems(
Update,
(handle_pause_buttons, escape_to_resume).run_if(in_state(PauseMenuState::Paused)),
);
app.add_systems(OnEnter(PauseMenuState::Settings), spawn_settings_menu);
app.add_systems(OnExit(PauseMenuState::Settings), despawn_settings_menu);
app.add_systems(
Update,
handle_settings_buttons.run_if(in_state(PauseMenuState::Settings)),
);
}
}
fn load_default_font(mut cfg: ResMut<PauseMenuConfig>, asset_server: Res<AssetServer>) {
if cfg.font == Handle::default() {
cfg.font = asset_server.load(EMBEDDED_NOTO_SANS_PATH);
}
if cfg.symbol_font == Handle::default() {
cfg.symbol_font = asset_server.load(EMBEDDED_NOTO_SYMBOLS_PATH);
}
}
fn release_cursor(mut windows: Query<&mut bevy::window::CursorOptions>) {
for mut cursor in &mut windows {
cursor.grab_mode = bevy::window::CursorGrabMode::None;
cursor.visible = true;
}
}
fn lock_cursor(windows: &mut Query<&mut bevy::window::CursorOptions>) {
for mut cursor in windows.iter_mut() {
cursor.grab_mode = bevy::window::CursorGrabMode::Locked;
cursor.visible = false;
}
}
fn toggle_pause(
keys: Res<ButtonInput<KeyCode>>,
mut next: ResMut<NextState<PauseMenuState>>,
mut sfx: MessageWriter<SfxRequest>,
) {
if keys.just_pressed(KeyCode::Escape) {
next.set(PauseMenuState::Paused);
sfx.write(SfxRequest {
event: SfxEvent::PauseOpen,
position: None,
});
}
}
fn escape_to_resume(
keys: Res<ButtonInput<KeyCode>>,
mut next: ResMut<NextState<PauseMenuState>>,
mut windows: Query<&mut bevy::window::CursorOptions>,
mut sfx: MessageWriter<SfxRequest>,
) {
if keys.just_pressed(KeyCode::Escape) {
next.set(PauseMenuState::Playing);
lock_cursor(&mut windows);
sfx.write(SfxRequest {
event: SfxEvent::PauseClose,
position: None,
});
}
}
fn spawn_btn<C: Component>(
parent: &mut ChildSpawnerCommands,
label: &str,
action: C,
width: f32,
height: f32,
font: Handle<Font>,
) {
parent
.spawn((
action,
Button,
Node {
width: Val::Px(width),
height: Val::Px(height),
justify_content: JustifyContent::Center,
align_items: AlignItems::Center,
..default()
},
BackgroundColor(BTN_NORMAL),
))
.with_children(|b| {
b.spawn((
Text::new(label),
TextFont {
font,
font_size: 20.0,
..default()
},
TextColor(Color::WHITE),
));
});
}
fn overlay_node() -> (Node, BackgroundColor) {
(
Node {
width: Val::Percent(100.0),
height: Val::Percent(100.0),
flex_direction: FlexDirection::Column,
justify_content: JustifyContent::Center,
align_items: AlignItems::Center,
row_gap: Val::Px(14.0),
..default()
},
BackgroundColor(OVERLAY),
)
}
fn spawn_pause_menu(mut commands: Commands, config: Res<PauseMenuConfig>) {
let (node, bg) = overlay_node();
commands
.spawn((PauseMenuRoot, node, bg))
.with_children(|p| {
p.spawn((
Text::new("PAUSED"),
TextFont {
font: config.font.clone(),
font_size: 52.0,
..default()
},
TextColor(Color::WHITE),
Node {
margin: UiRect::bottom(Val::Px(28.0)),
..default()
},
));
spawn_btn(
p,
"Resume",
PauseButton::Resume,
280.0,
52.0,
config.font.clone(),
);
spawn_btn(
p,
"Settings",
PauseButton::Settings,
280.0,
52.0,
config.font.clone(),
);
spawn_btn(
p,
"Quit",
PauseButton::Quit,
280.0,
52.0,
config.font.clone(),
);
});
}
fn despawn_pause_menu(mut commands: Commands, q: Query<Entity, With<PauseMenuRoot>>) {
for e in &q {
commands.entity(e).despawn();
}
}
fn handle_pause_buttons(
mut q: Query<
(&Interaction, &mut BackgroundColor, &PauseButton),
(Changed<Interaction>, With<Button>),
>,
mut next: ResMut<NextState<PauseMenuState>>,
mut windows: Query<&mut bevy::window::CursorOptions>,
mut app_exit: MessageWriter<AppExit>,
mut sfx: MessageWriter<SfxRequest>,
) {
for (interaction, mut bg, action) in &mut q {
*bg = BackgroundColor(match interaction {
Interaction::Hovered => BTN_HOVERED,
Interaction::Pressed => BTN_PRESSED,
Interaction::None => BTN_NORMAL,
});
if *interaction != Interaction::Pressed {
continue;
}
match action {
PauseButton::Resume => {
next.set(PauseMenuState::Playing);
lock_cursor(&mut windows);
sfx.write(SfxRequest {
event: SfxEvent::PauseClose,
position: None,
});
}
PauseButton::Settings => next.set(PauseMenuState::Settings),
PauseButton::Quit => {
app_exit.write(AppExit::Success);
}
}
}
}
fn spawn_settings_menu(
mut commands: Commands,
sfx_config: Res<SfxConfig>,
world_config: Option<Res<WorldConfig>>,
player_config: Option<Res<PlayerConfig>>,
camera_q: Query<&Projection, With<Camera3d>>,
config: Res<PauseMenuConfig>,
) {
let fov_deg = camera_q
.single()
.ok()
.and_then(|p| {
if let Projection::Perspective(pp) = p {
Some(pp.fov.to_degrees())
} else {
None
}
})
.unwrap_or(90.0);
let volume_pct = sfx_config.volume * 100.0;
let render_dist_chunks = world_config
.as_ref()
.map(|wc| ((wc.load_distance / 16.0).round() as i32).clamp(4, 32) as i32)
.unwrap_or(10);
let render_dist_chunks = if render_dist_chunks % 2 == 0 {
render_dist_chunks
} else {
render_dist_chunks + 1
};
let sensitivity_pct = player_config
.as_ref()
.map(|pc| ((pc.sensitivity * 100.0).round() as i32).clamp(10, 100))
.unwrap_or(100);
let (node, bg) = overlay_node();
commands
.spawn((SettingsMenuRoot, node, bg))
.with_children(|p| {
p.spawn((
Text::new("SETTINGS"),
TextFont {
font: config.font.clone(),
font_size: 42.0,
..default()
},
TextColor(Color::WHITE),
Node {
margin: UiRect::bottom(Val::Px(20.0)),
..default()
},
));
spawn_slider_row(
p,
"Field of View",
format!("{fov_deg:.0}°"),
FovLabel,
SettingsButton::FovDec,
SettingsButton::FovInc,
config.font.clone(),
config.symbol_font.clone(),
);
spawn_slider_row(
p,
"SFX Volume",
format!("{volume_pct:.0}%"),
VolumeLabel,
SettingsButton::VolumeDec,
SettingsButton::VolumeInc,
config.font.clone(),
config.symbol_font.clone(),
);
spawn_slider_row(
p,
"Render Distance",
format!("{render_dist_chunks} chunks"),
RenderDistLabel,
SettingsButton::RenderDistDec,
SettingsButton::RenderDistInc,
config.font.clone(),
config.symbol_font.clone(),
);
spawn_slider_row(
p,
"Sensitivity",
format!("{sensitivity_pct:.0}%"),
SensitivityLabel,
SettingsButton::SensitivityDec,
SettingsButton::SensitivityInc,
config.font.clone(),
config.symbol_font.clone(),
);
p.spawn(Node {
margin: UiRect::top(Val::Px(20.0)),
..default()
})
.with_children(|row| {
spawn_btn(
row,
"< Back",
SettingsButton::Back,
200.0,
50.0,
config.font.clone(),
);
});
});
}
fn spawn_slider_row<L: Component, D: Component, I: Component>(
parent: &mut ChildSpawnerCommands,
label: &str,
value: String,
value_marker: L,
dec: D,
inc: I,
font: Handle<Font>,
symbol_font: Handle<Font>,
) {
parent
.spawn(Node {
flex_direction: FlexDirection::Row,
align_items: AlignItems::Center,
column_gap: Val::Px(12.0),
..default()
})
.with_children(|row| {
row.spawn((
Text::new(label),
TextFont {
font: font.clone(),
font_size: 20.0,
..default()
},
TextColor(Color::srgb(0.8, 0.8, 0.8)),
Node {
width: Val::Px(200.0),
..default()
},
));
spawn_btn(row, "\u{25C0}", dec, 44.0, 44.0, symbol_font.clone());
row.spawn((
value_marker,
Text::new(value),
TextFont {
font: font.clone(),
font_size: 22.0,
..default()
},
TextColor(Color::WHITE),
Node {
width: Val::Px(80.0),
justify_content: JustifyContent::Center,
..default()
},
));
spawn_btn(row, "\u{25B6}", inc, 44.0, 44.0, symbol_font);
});
}
fn despawn_settings_menu(mut commands: Commands, q: Query<Entity, With<SettingsMenuRoot>>) {
for e in &q {
commands.entity(e).despawn();
}
}
#[allow(clippy::too_many_arguments)]
fn handle_settings_buttons(
mut q: Query<
(&Interaction, &mut BackgroundColor, &SettingsButton),
(Changed<Interaction>, With<Button>),
>,
mut sfx_config: ResMut<SfxConfig>,
mut world_config: Option<ResMut<WorldConfig>>,
mut chunk_manager: Option<ResMut<ChunkManager>>,
mut player_config: Option<ResMut<PlayerConfig>>,
mut next: ResMut<NextState<PauseMenuState>>,
mut fov_label: Query<
&mut Text,
(
With<FovLabel>,
Without<VolumeLabel>,
Without<RenderDistLabel>,
Without<SensitivityLabel>,
),
>,
mut vol_label: Query<
&mut Text,
(
With<VolumeLabel>,
Without<FovLabel>,
Without<RenderDistLabel>,
Without<SensitivityLabel>,
),
>,
mut rdist_label: Query<
&mut Text,
(
With<RenderDistLabel>,
Without<FovLabel>,
Without<VolumeLabel>,
Without<SensitivityLabel>,
),
>,
mut sens_label: Query<
&mut Text,
(
With<SensitivityLabel>,
Without<FovLabel>,
Without<VolumeLabel>,
Without<RenderDistLabel>,
),
>,
mut camera_q: Query<&mut Projection, With<Camera3d>>,
mut save_writer: MessageWriter<SaveSettingsRequest>,
) {
for (interaction, mut bg, action) in &mut q {
*bg = BackgroundColor(match interaction {
Interaction::Hovered => BTN_HOVERED,
Interaction::Pressed => BTN_PRESSED,
Interaction::None => BTN_NORMAL,
});
if *interaction != Interaction::Pressed {
continue;
}
match action {
SettingsButton::FovInc | SettingsButton::FovDec => {
if let Ok(mut proj) = camera_q.single_mut() {
if let Projection::Perspective(ref mut pp) = *proj {
let delta = if matches!(action, SettingsButton::FovInc) {
5.0
} else {
-5.0
};
let new_fov = (pp.fov.to_degrees() + delta).clamp(50.0, 120.0);
pp.fov = new_fov.to_radians();
if let Ok(mut t) = fov_label.single_mut() {
**t = format!("{new_fov:.0}°");
}
}
}
}
SettingsButton::VolumeInc | SettingsButton::VolumeDec => {
let delta = if matches!(action, SettingsButton::VolumeInc) {
0.1
} else {
-0.1
};
sfx_config.volume = (sfx_config.volume + delta).clamp(0.0, 1.0);
let pct = sfx_config.volume * 100.0;
if let Ok(mut t) = vol_label.single_mut() {
**t = format!("{pct:.0}%");
}
}
SettingsButton::RenderDistInc | SettingsButton::RenderDistDec => {
if let Some(ref mut wc) = world_config {
let current = ((wc.load_distance / 16.0).round() as i32).clamp(4, 32);
let current = if current % 2 == 0 {
current
} else {
current + 1
};
let delta: i32 = if matches!(action, SettingsButton::RenderDistInc) {
2
} else {
-2
};
let new_chunks = (current + delta).clamp(4, 32);
wc.load_distance = new_chunks as f32 * 16.0;
wc.unload_distance = wc.load_distance + 32.0;
if let Some(ref mut cm) = chunk_manager {
cm.load_distance = wc.load_distance;
cm.unload_distance = wc.unload_distance;
}
if let Ok(mut t) = rdist_label.single_mut() {
**t = format!("{new_chunks} chunks");
}
}
}
SettingsButton::SensitivityInc | SettingsButton::SensitivityDec => {
if let Some(ref mut pc) = player_config {
let current_pct = (pc.sensitivity * 100.0).round() as i32;
let delta: i32 = if matches!(action, SettingsButton::SensitivityInc) {
1
} else {
-1
};
let new_pct = (current_pct + delta).clamp(10, 100);
pc.sensitivity = new_pct as f32 / 100.0;
if let Ok(mut t) = sens_label.single_mut() {
**t = format!("{new_pct:.0}%");
}
}
}
SettingsButton::Back => {
save_writer.write(SaveSettingsRequest);
next.set(PauseMenuState::Paused);
}
}
}
}