|
|
|
use winit::event::*;
|
|
|
|
|
|
|
|
use crate::state;
|
|
|
|
use crate::util;
|
|
|
|
|
|
|
|
pub trait System {
|
|
|
|
fn start(&mut self, state: &mut state::State);
|
|
|
|
fn process_input(&mut self, keycode: VirtualKeyCode, pressed: bool) -> bool;
|
|
|
|
fn update_state(&self, state: &mut state::State);
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct MenuSystem {
|
|
|
|
enter_pressed: bool,
|
|
|
|
down_pressed: bool,
|
|
|
|
up_pressed: bool,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl MenuSystem {
|
|
|
|
pub fn new() -> Self {
|
|
|
|
Self {
|
|
|
|
enter_pressed: false,
|
|
|
|
down_pressed: false,
|
|
|
|
up_pressed: false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl System for MenuSystem {
|
|
|
|
fn start(&mut self, state: &mut state::State) {
|
|
|
|
self.enter_pressed = false;
|
|
|
|
self.down_pressed = false;
|
|
|
|
self.up_pressed = false;
|
|
|
|
state.player1.score = 0;
|
|
|
|
state.player2.score = 0;
|
|
|
|
state.ball.visible = false;
|
|
|
|
state.player1.visible = false;
|
|
|
|
state.player2.visible = false;
|
|
|
|
state.title_text.visible = true;
|
|
|
|
state.play_button.visible = true;
|
|
|
|
state.play_button.focused = true;
|
|
|
|
state.quit_button.visible = true;
|
|
|
|
state.player1_score.visible = false;
|
|
|
|
state.player2_score.visible = false;
|
|
|
|
state.win_text.visible = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
fn process_input(&mut self, keycode: VirtualKeyCode, pressed: bool) -> bool {
|
|
|
|
match keycode {
|
|
|
|
VirtualKeyCode::Up | VirtualKeyCode::W => {
|
|
|
|
self.up_pressed = pressed;
|
|
|
|
true
|
|
|
|
}
|
|
|
|
VirtualKeyCode::Down | VirtualKeyCode::S => {
|
|
|
|
self.down_pressed = pressed;
|
|
|
|
true
|
|
|
|
}
|
|
|
|
VirtualKeyCode::Return
|
|
|
|
| VirtualKeyCode::NumpadEnter
|
|
|
|
| VirtualKeyCode::Space => {
|
|
|
|
self.enter_pressed = pressed;
|
|
|
|
true
|
|
|
|
}
|
|
|
|
_ => false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn update_state(&self, state: &mut state::State) {
|
|
|
|
|
|
|
|
if state.play_button.focused && self.down_pressed {
|
|
|
|
state.play_button.focused = false;
|
|
|
|
state.quit_button.focused = true;
|
|
|
|
} else if state.quit_button.focused && self.up_pressed {
|
|
|
|
state.quit_button.focused = false;
|
|
|
|
state.play_button.focused = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if state.play_button.focused && self.enter_pressed {
|
|
|
|
state.game_state = state::GameState::Serving;
|
|
|
|
} else if state.quit_button.focused && self.enter_pressed {
|
|
|
|
state.game_state = state::GameState::Quiting;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct PlaySystem {
|
|
|
|
player1_up_pressed: bool,
|
|
|
|
player1_down_pressed: bool,
|
|
|
|
player2_up_pressed: bool,
|
|
|
|
player2_down_pressed: bool,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl PlaySystem {
|
|
|
|
pub fn new() -> Self {
|
|
|
|
Self {
|
|
|
|
player1_up_pressed: false,
|
|
|
|
player1_down_pressed: false,
|
|
|
|
player2_up_pressed: false,
|
|
|
|
player2_down_pressed: false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl System for PlaySystem {
|
|
|
|
fn start(&mut self, state: &mut state::State) {
|
|
|
|
self.player1_up_pressed = false;
|
|
|
|
self.player1_down_pressed = false;
|
|
|
|
self.player2_up_pressed = false;
|
|
|
|
self.player2_down_pressed = false;
|
|
|
|
state.ball.visible = true;
|
|
|
|
state.player1.visible = true;
|
|
|
|
state.player2.visible = true;
|
|
|
|
state.title_text.visible = false;
|
|
|
|
state.play_button.visible = false;
|
|
|
|
state.quit_button.visible = false;
|
|
|
|
state.player1_score.visible = true;
|
|
|
|
state.player2_score.visible = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
fn process_input(&mut self, keycode: VirtualKeyCode, pressed: bool) -> bool {
|
|
|
|
match keycode {
|
|
|
|
VirtualKeyCode::W => {
|
|
|
|
self.player1_up_pressed = pressed;
|
|
|
|
true
|
|
|
|
}
|
|
|
|
VirtualKeyCode::S => {
|
|
|
|
self.player1_down_pressed = pressed;
|
|
|
|
true
|
|
|
|
}
|
|
|
|
VirtualKeyCode::Up => {
|
|
|
|
self.player2_up_pressed = pressed;
|
|
|
|
true
|
|
|
|
}
|
|
|
|
VirtualKeyCode::Down => {
|
|
|
|
self.player2_down_pressed = pressed;
|
|
|
|
true
|
|
|
|
}
|
|
|
|
_ => false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn update_state(&self, state: &mut state::State) {
|
|
|
|
// move the players
|
|
|
|
if self.player1_up_pressed {
|
|
|
|
state.player1.position.y += 0.025;
|
|
|
|
}
|
|
|
|
if self.player1_down_pressed {
|
|
|
|
state.player1.position.y -= 0.025;
|
|
|
|
}
|
|
|
|
if self.player2_up_pressed {
|
|
|
|
state.player2.position.y += 0.025;
|
|
|
|
}
|
|
|
|
if self.player2_down_pressed {
|
|
|
|
state.player2.position.y -= 0.025;
|
|
|
|
}
|
|
|
|
|
|
|
|
// normalize players
|
|
|
|
if state.player1.position.y > 1.0 {
|
|
|
|
state.player1.position.y = 1.0;
|
|
|
|
} else if state.player1.position.y < -1.0 {
|
|
|
|
state.player1.position.y = -1.0;
|
|
|
|
}
|
|
|
|
if state.player2.position.y > 1.0 {
|
|
|
|
state.player2.position.y = 1.0;
|
|
|
|
} else if state.player2.position.y < -1.0 {
|
|
|
|
state.player2.position.y = -1.0;
|
|
|
|
}
|
|
|
|
|
|
|
|
state.ball.position += state.ball.velocity;
|
|
|
|
if state.ball.position.y > 1.0 {
|
|
|
|
state.ball.position.y = 1.0;
|
|
|
|
state.ball.velocity.y *= -1.0;
|
|
|
|
} else if state.ball.position.y < -1.0 {
|
|
|
|
state.ball.position.y = -1.0;
|
|
|
|
state.ball.velocity.y *= -1.0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if state.ball.position.x > 1.0 {
|
|
|
|
state.player1.score += 1;
|
|
|
|
state.game_state = state::GameState::Serving;
|
|
|
|
} else if state.ball.position.x < -1.0 {
|
|
|
|
state.player2.score += 1;
|
|
|
|
state.game_state = state::GameState::Serving;
|
|
|
|
}
|
|
|
|
|
|
|
|
if state.player1.score > 2 || state.player2.score > 2 {
|
|
|
|
state.game_state = state::GameState::GameOver;
|
|
|
|
}
|
|
|
|
|
|
|
|
// bounce the ball off the players
|
|
|
|
if state.player1.contains(&state.ball) {
|
|
|
|
state.ball.position.x -= state.ball.velocity.x - state.player1.size.x;
|
|
|
|
state.ball.velocity.x *= -1.0;
|
|
|
|
} else if state.player2.contains(&state.ball) {
|
|
|
|
state.ball.position.x -= state.ball.velocity.x + state.player2.size.x;
|
|
|
|
state.ball.velocity.x *= -1.0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
pub struct ServingSystem {
|
|
|
|
last_time: std::time::Instant,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ServingSystem {
|
|
|
|
pub fn new() -> Self {
|
|
|
|
Self {
|
|
|
|
last_time: std::time::Instant::now(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl System for ServingSystem {
|
|
|
|
fn start(&mut self, state: &mut state::State) {
|
|
|
|
self.last_time = std::time::Instant::now();
|
|
|
|
state.ball.visible = true;
|
|
|
|
state.player1.visible = true;
|
|
|
|
state.player2.visible = true;
|
|
|
|
state.title_text.visible = false;
|
|
|
|
state.play_button.visible = false;
|
|
|
|
state.quit_button.visible = false;
|
|
|
|
state.ball.position = (0.0, 0.0).into();
|
|
|
|
state.ball.velocity = util::random_vec2_scaled(0.025);
|
|
|
|
state.player1_score.visible = true;
|
|
|
|
state.player2_score.visible = true;
|
|
|
|
state.player1_score.text = format!("{}", state.player1.score);
|
|
|
|
state.player2_score.text = format!("{}", state.player2.score);
|
|
|
|
}
|
|
|
|
|
|
|
|
fn process_input(&mut self, _keycode: VirtualKeyCode, _pressed: bool) -> bool {
|
|
|
|
false
|
|
|
|
}
|
|
|
|
|
|
|
|
fn update_state(&self, state: &mut state::State) {
|
|
|
|
let current_time = std::time::Instant::now();
|
|
|
|
let delta_time = current_time - self.last_time;
|
|
|
|
if delta_time.as_secs_f32() > 1.0 {
|
|
|
|
state.game_state = state::GameState::Playing;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct GameOverSystem {
|
|
|
|
last_time: std::time::Instant,
|
|
|
|
key_pressed: bool,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl GameOverSystem {
|
|
|
|
pub fn new() -> Self {
|
|
|
|
Self {
|
|
|
|
last_time: std::time::Instant::now(),
|
|
|
|
key_pressed: false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl System for GameOverSystem {
|
|
|
|
fn start(&mut self, state: &mut state::State) {
|
|
|
|
self.last_time = std::time::Instant::now();
|
|
|
|
self.key_pressed = false;
|
|
|
|
state.ball.visible = false;
|
|
|
|
|
|
|
|
state.win_text.text = if state.player1.score > state.player2.score {
|
|
|
|
String::from("Player1 wins!")
|
|
|
|
} else {
|
|
|
|
String::from("Player2 wins!")
|
|
|
|
};
|
|
|
|
state.win_text.visible = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
fn process_input(&mut self, _keycode: VirtualKeyCode, _pressed: bool) -> bool {
|
|
|
|
false
|
|
|
|
}
|
|
|
|
|
|
|
|
fn update_state(&self, state: &mut state::State) {
|
|
|
|
let current_time = std::time::Instant::now();
|
|
|
|
let delta_time = current_time - self.last_time;
|
|
|
|
if delta_time.as_secs_f32() > 1.0 {
|
|
|
|
state.game_state = state::GameState::MainMenu;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|