365 lines
12 KiB
Rust
365 lines
12 KiB
Rust
use std::ops::DerefMut;
|
|
|
|
use crate::{
|
|
GameState,
|
|
config::{UI_BUTTON_HOVERED, UI_BUTTON_NORMAL, UI_BUTTON_PRESSED},
|
|
despawn,
|
|
resources::{Lives, Score},
|
|
};
|
|
|
|
use bevy::{
|
|
color::palettes::css::{BLACK, DARK_GRAY, GREEN, RED, WHITE},
|
|
prelude::*,
|
|
};
|
|
|
|
/// Plugin for the main menu
|
|
pub struct PluginGameMenu;
|
|
|
|
impl Plugin for PluginGameMenu {
|
|
fn build(&self, app: &mut App) {
|
|
app.add_systems(OnEnter(GameState::TitleScreen), spawn_menu)
|
|
.add_systems(OnExit(GameState::TitleScreen), despawn::<MarkerMainMenu>)
|
|
.add_systems(
|
|
Update,
|
|
(handle_spacebar, operate_buttons).run_if(in_state(GameState::TitleScreen)),
|
|
);
|
|
}
|
|
}
|
|
|
|
/// Plugin for the "get ready" period as gameplay starts.
|
|
pub struct PluginGetReady;
|
|
|
|
impl Plugin for PluginGetReady {
|
|
fn build(&self, app: &mut App) {
|
|
app.add_systems(OnEnter(GameState::GetReady), spawn_get_ready)
|
|
.add_systems(OnExit(GameState::GetReady), despawn::<OnReadySetGo>)
|
|
.add_systems(
|
|
Update,
|
|
(animate_get_ready_widget).run_if(in_state(GameState::GetReady)),
|
|
)
|
|
.insert_resource(ReadySetGoTimer(Timer::from_seconds(3.0, TimerMode::Once)));
|
|
}
|
|
}
|
|
|
|
/// Plugin for the in-game HUD
|
|
pub struct PluginGameHud;
|
|
|
|
impl Plugin for PluginGameHud {
|
|
fn build(&self, app: &mut App) {
|
|
app.add_systems(OnEnter(GameState::Playing), spawn_ui)
|
|
.add_systems(OnExit(GameState::Playing), despawn::<MarkerHUD>)
|
|
.add_systems(Update, (operate_ui).run_if(in_state(GameState::Playing)));
|
|
}
|
|
}
|
|
|
|
/// Plugin for the game-over screen
|
|
pub struct PluginGameOver;
|
|
|
|
impl Plugin for PluginGameOver {
|
|
fn build(&self, app: &mut App) {
|
|
app.add_systems(OnEnter(GameState::GameOver), spawn_gameover_ui)
|
|
.add_systems(OnExit(GameState::GameOver), despawn::<MarkerGameOver>)
|
|
.add_systems(
|
|
Update,
|
|
operate_buttons.run_if(in_state(GameState::GameOver)),
|
|
);
|
|
}
|
|
}
|
|
|
|
// Marker component for the title screen UI entity.
|
|
// This way, a query for the TitleUI can be used to despawn the title screen
|
|
#[derive(Component)]
|
|
struct MarkerMainMenu;
|
|
|
|
/// Marker component for things on the get-ready indicator
|
|
#[derive(Component)]
|
|
struct OnReadySetGo;
|
|
|
|
/// Marker for things on the game-over screen
|
|
#[derive(Component)]
|
|
struct MarkerGameOver;
|
|
|
|
/// Marker for things on the HUD (the in-game UI elements)
|
|
#[derive(Component)]
|
|
struct MarkerHUD;
|
|
|
|
/// Action specifier for the buttons on the menus.
|
|
///
|
|
/// Instead of holding function pointers for use as callbacks, I'm doing enum-
|
|
/// dispatch. Add a variant according to what action the button press should
|
|
/// trigger.
|
|
///
|
|
/// Only [`PluginGameMenu`] and [`PluginGameOver`] will use it to this
|
|
/// component. There is no always-on, global system.
|
|
#[derive(Component)]
|
|
enum ButtonMenuAction {
|
|
ToMainMenu,
|
|
StartGame,
|
|
Quit,
|
|
}
|
|
|
|
/// Newtype wrapper for `Timer`. Used to count down during the "get ready" phase.
|
|
#[derive(Deref, DerefMut, Resource)]
|
|
struct ReadySetGoTimer(Timer);
|
|
|
|
/// Marker for the counter text segment
|
|
#[derive(Component)]
|
|
struct CountdownText;
|
|
|
|
/// Marker for the counter bar segment
|
|
#[derive(Component)]
|
|
struct CountdownBar;
|
|
|
|
/// Utility function for creating a standard button.
|
|
fn button_bundle(text: &str) -> impl Bundle {
|
|
(
|
|
Button,
|
|
// TODO: Generic action
|
|
Node {
|
|
width: Val::Px(150.0),
|
|
height: Val::Px(65.0),
|
|
border: UiRect::all(Val::Px(2.0)),
|
|
justify_content: JustifyContent::Center,
|
|
align_items: AlignItems::Center,
|
|
margin: UiRect::all(Val::Px(5.0)),
|
|
..default()
|
|
},
|
|
BorderColor::all(Color::BLACK),
|
|
BorderRadius::MAX,
|
|
BackgroundColor(UI_BUTTON_NORMAL),
|
|
children![(
|
|
Text::new(text),
|
|
TextColor(Color::srgb(0.9, 0.9, 0.9)),
|
|
TextShadow::default(),
|
|
)],
|
|
)
|
|
}
|
|
|
|
fn spawn_menu(mut commands: Commands) {
|
|
commands
|
|
.spawn((
|
|
MarkerMainMenu,
|
|
Node {
|
|
width: Val::Percent(100.0),
|
|
height: Val::Percent(100.0),
|
|
align_items: AlignItems::Center,
|
|
justify_content: JustifyContent::Center,
|
|
flex_direction: FlexDirection::Column,
|
|
..Default::default()
|
|
},
|
|
))
|
|
.with_children(|cmds| {
|
|
cmds.spawn((
|
|
Text::new("Robert's Bad Asteroids Game"),
|
|
TextFont::from_font_size(50.0),
|
|
TextLayout::new_with_justify(Justify::Center),
|
|
TextShadow::default(),
|
|
));
|
|
cmds.spawn((
|
|
Text::new("Press space to begin"),
|
|
TextFont::from_font_size(20.0),
|
|
TextColor(Color::srgb(0.7, 0.7, 0.7)),
|
|
TextShadow::default(),
|
|
));
|
|
cmds.spawn((button_bundle("Start Game"), ButtonMenuAction::StartGame));
|
|
cmds.spawn((button_bundle("Quit"), ButtonMenuAction::Quit));
|
|
});
|
|
}
|
|
|
|
fn spawn_get_ready(mut commands: Commands, mut timer: ResMut<ReadySetGoTimer>) {
|
|
timer.reset();
|
|
commands.spawn((
|
|
OnReadySetGo, // marker, so this can be de-spawned properly
|
|
Node {
|
|
align_self: AlignSelf::Center,
|
|
justify_self: JustifySelf::Center,
|
|
align_items: AlignItems::Center,
|
|
justify_content: JustifyContent::Center,
|
|
flex_direction: FlexDirection::Column,
|
|
width: Val::Percent(30.),
|
|
height: Val::Percent(30.),
|
|
..default()
|
|
},
|
|
BackgroundColor(Color::NONE),
|
|
children![
|
|
(Text::new("Get Ready!"), TextColor(WHITE.into())),
|
|
(
|
|
CountdownBar,
|
|
Node {
|
|
width: Val::Percent(90.0),
|
|
height: Val::Percent(10.),
|
|
..default()
|
|
},
|
|
BackgroundColor(GREEN.into()),
|
|
),
|
|
(
|
|
CountdownText,
|
|
Text::new("<uninit timer>"),
|
|
TextColor(RED.into()),
|
|
)
|
|
],
|
|
));
|
|
}
|
|
|
|
/// Spawns the game over screen.
|
|
///
|
|
/// Used by [`PluginGameOver`] when entering the [`GameState::GameOver`] state.
|
|
fn spawn_gameover_ui(mut commands: Commands) {
|
|
commands.spawn((
|
|
MarkerGameOver, // Marker, so `despawn<T>` can remove this on state exit.
|
|
Node {
|
|
width: Val::Percent(100.0),
|
|
height: Val::Percent(100.0),
|
|
align_items: AlignItems::Center,
|
|
justify_content: JustifyContent::Center,
|
|
flex_direction: FlexDirection::Column,
|
|
..default()
|
|
},
|
|
children![
|
|
(
|
|
Text::new("Game Over"),
|
|
TextFont::from_font_size(35.0),
|
|
TextShadow::default(),
|
|
),
|
|
(button_bundle("Main Menu"), ButtonMenuAction::ToMainMenu,),
|
|
(button_bundle("Quit"), ButtonMenuAction::Quit),
|
|
],
|
|
));
|
|
}
|
|
|
|
fn animate_get_ready_widget(
|
|
mut text_segment: Single<&mut Text, With<CountdownText>>,
|
|
mut bar_segment: Single<&mut Node, With<CountdownBar>>,
|
|
time: Res<Time>,
|
|
mut timer: ResMut<ReadySetGoTimer>,
|
|
mut game_state: ResMut<NextState<GameState>>,
|
|
) {
|
|
// Advance the timer, read the remaining time and write it onto the label.
|
|
timer.tick(time.delta());
|
|
|
|
// Add one to the visual value so the countdown starts at 3 and stops at 1.
|
|
// Otherwise it starts at 2 and disappears after showing 0.
|
|
// That feels wrong even though it's functionally identical.
|
|
let tval = timer.0.remaining().as_secs() + 1;
|
|
**text_segment = format!("{tval}").into();
|
|
|
|
// Shrink the progress bar Node
|
|
bar_segment.width = Val::Percent(100.0 * (1.0 - timer.fraction()));
|
|
|
|
// If the timer has expired, change state to playing.
|
|
if timer.is_finished() {
|
|
game_state.set(GameState::Playing);
|
|
}
|
|
}
|
|
|
|
/// Handles interactions with the menu buttons.
|
|
///
|
|
/// The buttons are used by the main menu and the game-over menu to change
|
|
/// between game states.
|
|
///
|
|
/// Button animation and action handling is done entirely within this system.
|
|
///
|
|
/// There are no checks for current state. If a "quit" button was put somewhere
|
|
/// on the HUD, this system would quit the game. The same will happen for
|
|
/// returning to the title screen. This should be useful for making a pause
|
|
/// menu, too.
|
|
#[allow(clippy::type_complexity)]
|
|
fn operate_buttons(
|
|
mut interactions: Query<
|
|
(
|
|
&Interaction,
|
|
&mut BackgroundColor,
|
|
&mut BorderColor,
|
|
&ButtonMenuAction,
|
|
),
|
|
(Changed<Interaction>, With<Button>),
|
|
>,
|
|
mut game_state: ResMut<NextState<GameState>>,
|
|
mut app_exit_events: MessageWriter<AppExit>,
|
|
) {
|
|
// TODO: Better colors. These are taken from the example and they're ugly.
|
|
for (interaction, mut color, mut border_color, menu_action) in &mut interactions {
|
|
match *interaction {
|
|
Interaction::Pressed => {
|
|
*color = UI_BUTTON_PRESSED.into();
|
|
border_color.set_all(DARK_GRAY);
|
|
match menu_action {
|
|
ButtonMenuAction::ToMainMenu => {
|
|
game_state.set(GameState::TitleScreen);
|
|
}
|
|
ButtonMenuAction::StartGame => {
|
|
game_state.set(GameState::GetReady);
|
|
}
|
|
ButtonMenuAction::Quit => {
|
|
app_exit_events.write(AppExit::Success);
|
|
}
|
|
}
|
|
}
|
|
Interaction::Hovered => {
|
|
*color = UI_BUTTON_HOVERED.into();
|
|
border_color.set_all(WHITE);
|
|
}
|
|
Interaction::None => {
|
|
*color = UI_BUTTON_NORMAL.into();
|
|
border_color.set_all(BLACK);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Main menu input listener. Starts game when the spacebar is pressed.
|
|
fn handle_spacebar(input: Res<ButtonInput<KeyCode>>, mut game_state: ResMut<NextState<GameState>>) {
|
|
if input.just_pressed(KeyCode::Space) {
|
|
game_state.set(GameState::GetReady);
|
|
}
|
|
}
|
|
|
|
pub fn spawn_ui(mut commands: Commands, score: Res<Score>, lives: Res<Lives>) {
|
|
let score = score.0;
|
|
let lives = lives.0;
|
|
commands.spawn((
|
|
MarkerHUD,
|
|
Node {
|
|
width: Val::Percent(100.0),
|
|
height: Val::Percent(100.0),
|
|
align_items: AlignItems::Start,
|
|
justify_content: JustifyContent::SpaceBetween,
|
|
padding: UiRect::all(Val::Px(5.0)),
|
|
..default()
|
|
},
|
|
children![
|
|
(
|
|
Text::new(format!("Score: {score}")),
|
|
TextFont::from_font_size(25.0),
|
|
TextShadow::default(),
|
|
),
|
|
(
|
|
Text::new(format!("Lives: {lives}")),
|
|
TextFont::from_font_size(25.0),
|
|
TextShadow::default(),
|
|
)
|
|
],
|
|
));
|
|
}
|
|
|
|
/// Updates the HUD with the current score & life count
|
|
///
|
|
/// TODO: some kind of event-based thing. Touching the text nodes every frame
|
|
/// seems expensive.
|
|
fn operate_ui(
|
|
mut query: Single<(&Node, &Children), With<MarkerHUD>>,
|
|
mut text_query: Query<&mut Text>,
|
|
lives: Res<Lives>,
|
|
score: Res<Score>,
|
|
) {
|
|
let (_node, children) = query.deref_mut();
|
|
let score = score.0;
|
|
let lives = lives.0;
|
|
// TODO: Something smarter than `unwrap()`
|
|
let mut score_text = text_query.get_mut(children[0]).unwrap();
|
|
**score_text = format!("Score: {score}");
|
|
|
|
let mut lives_text = text_query.get_mut(children[1]).unwrap();
|
|
**lives_text = format!("Lives: {lives}");
|
|
}
|