use crate::{ hud::{DebugInfo, Event as HudEvent, Hud}, key_state::KeyState, render::Renderer, scene::Scene, settings::Settings, window::{Event, GameInput, Window}, Direction, Error, GlobalState, PlayState, PlayStateResult, }; use client::{self, Client}; use common::{clock::Clock, comp, comp::phys::Pos, msg::ClientState}; use glutin::MouseButton; use std::{cell::RefCell, mem, rc::Rc, time::Duration}; use vek::*; const FPS: u64 = 60; pub struct SessionState { scene: Scene, client: Rc>, key_state: KeyState, hud: Hud, } /// Represents an active game session (i.e., the one being played). impl SessionState { /// Create a new `SessionState`. pub fn new(window: &mut Window, client: Rc>, settings: Settings) -> Self { // Create a scene for this session. The scene handles visible elements of the game world. let scene = Scene::new(window.renderer_mut(), &client.borrow()); Self { scene, client, key_state: KeyState::new(), hud: Hud::new(window), } } } // Background colour const BG_COLOR: Rgba = Rgba { r: 0.0, g: 0.3, b: 1.0, a: 1.0, }; impl SessionState { /// Tick the session (and the client attached to it). pub fn tick(&mut self, dt: Duration) -> Result<(), Error> { // Calculate the movement input vector of the player from the current key presses // and the camera direction. let ori = self.scene.camera().get_orientation(); let unit_vecs = ( Vec2::new(ori[0].cos(), -ori[0].sin()), Vec2::new(ori[0].sin(), ori[0].cos()), ); let dir_vec = self.key_state.dir_vec(); let move_dir = unit_vecs.0 * dir_vec[0] + unit_vecs.1 * dir_vec[1]; for event in self .client .borrow_mut() .tick(comp::Control { move_dir }, dt)? { match event { client::Event::Chat(msg) => { self.hud.new_message(msg); } client::Event::Disconnect => { // TODO } } } Ok(()) } /// Clean up the session (and the client attached to it) after a tick. pub fn cleanup(&mut self) { self.client.borrow_mut().cleanup(); } /// Render the session to the screen. /// /// This method should be called once per frame. pub fn render(&mut self, renderer: &mut Renderer) { // Clear the screen renderer.clear(BG_COLOR); // Render the screen using the global renderer self.scene.render(renderer, &mut self.client.borrow_mut()); // Draw the UI to the screen self.hud.render(renderer, self.scene.globals()); // Finish the frame renderer.flush(); } } impl PlayState for SessionState { fn play(&mut self, _: Direction, global_state: &mut GlobalState) -> PlayStateResult { // Trap the cursor. global_state.window.grab_cursor(true); // Set up an fps clock. let mut clock = Clock::new(); self.client.borrow_mut().clear_terrain(); // Game loop let mut current_client_state = self.client.borrow().get_client_state(); while let ClientState::Pending | ClientState::Character | ClientState::Dead = current_client_state { let alive = self.client.borrow().get_client_state() == ClientState::Character; // Handle window events. for event in global_state.window.fetch_events() { // Pass all events to the ui first. if self.hud.handle_event(event.clone(), global_state) { continue; } match event { Event::Close => { return PlayStateResult::Shutdown; } Event::InputUpdate(GameInput::Attack, true) => { self.client.borrow_mut().attack(); self.client.borrow_mut().respawn(); } Event::InputUpdate(GameInput::Jump, true) => { self.client.borrow_mut().jump(); } Event::InputUpdate(GameInput::MoveForward, state) => self.key_state.up = state, Event::InputUpdate(GameInput::MoveBack, state) => self.key_state.down = state, Event::InputUpdate(GameInput::MoveLeft, state) => self.key_state.left = state, Event::InputUpdate(GameInput::MoveRight, state) => self.key_state.right = state, Event::InputUpdate(GameInput::Glide, state) => { self.client.borrow_mut().glide(state) } // Pass all other events to the scene event => { self.scene.handle_input_event(event); } // TODO: Do something if the event wasn't handled? } } // Perform an in-game tick. if let Err(err) = self.tick(clock.get_last_delta()) { log::error!("Failed to tick the scene: {:?}", err); return PlayStateResult::Pop; } // Maintain global state global_state.maintain(); // extract HUD events ensuring the client borrow gets dropped let hud_events = self.hud.maintain( &self.client.borrow(), global_state, DebugInfo { tps: clock.get_tps(), ping_ms: self.client.borrow().get_ping_ms(), coordinates: self .client .borrow() .state() .ecs() .read_storage::() .get(self.client.borrow().entity()) .unwrap() .0, }, &self.scene.camera(), ); // Maintain the UI. for event in hud_events { match event { HudEvent::SendMessage(msg) => { // TODO: Handle result self.client.borrow_mut().send_chat(msg); } HudEvent::Logout => return PlayStateResult::Pop, HudEvent::Quit => { return PlayStateResult::Shutdown; } HudEvent::AdjustViewDistance(view_distance) => { self.client.borrow_mut().set_view_distance(view_distance); global_state.settings.graphics.view_distance = view_distance; global_state.settings.save_to_file(); } HudEvent::AdjustVolume(volume) => { global_state.audio.set_volume(volume); global_state.settings.audio.music_volume = volume; global_state.settings.save_to_file(); } HudEvent::ChangeAudioDevice(name) => { global_state.audio.set_device(name.clone()); global_state.settings.audio.audio_device = Some(name); global_state.settings.save_to_file(); } } } // Maintain the scene. self.scene .maintain(global_state.window.renderer_mut(), &self.client.borrow()); // Render the session. self.render(global_state.window.renderer_mut()); // Display the frame on the window. global_state .window .swap_buffers() .expect("Failed to swap window buffers!"); // Wait for the next tick. clock.tick(Duration::from_millis(1000 / FPS)); // Clean things up after the tick. self.cleanup(); current_client_state = self.client.borrow().get_client_state(); } PlayStateResult::Pop } fn name(&self) -> &'static str { "Session" } }