Initial implementation of camera controls

src/main.rs

@@ -75,6 +75,7 @@ pub struct Game {
     mouse_pos: (i32, i32),
 
     server: server::Server,
+    focused: bool,
     chunk_builder: chunk_builder::ChunkBuilder,
 
     connect_reply: Option<mpsc::Receiver<Result<server::Server, protocol::Error>>>,
@@ -94,9 +95,9 @@ impl Game {
 
     pub fn tick(&mut self, delta: f64) {
         if !self.server.is_connected() {
-            self.renderer.camera.yaw += 0.005 * delta;
-            if self.renderer.camera.yaw > ::std::f64::consts::PI * 2.0 {
-                self.renderer.camera.yaw = 0.0;
+            self.server.yaw += 0.005 * delta;
+            if self.server.yaw > ::std::f64::consts::PI * 2.0 {
+                self.server.yaw = 0.0;
             }
         }
         let mut clear_reply = false;
@@ -108,6 +109,7 @@ impl Game {
                         self.screen_sys.pop_screen();
                         self.renderer.clear_chunks();
                         self.chunk_builder.wait_for_builders();
+                        self.focused = true;
                         self.server = val;
                     },
                     Err(err) => {
@@ -186,6 +188,7 @@ fn main() {
     let textures = renderer.get_textures();
     let mut game = Game {
         server: server::Server::dummy_server(resource_manager.clone(), con.clone()),
+        focused: false,
         renderer: renderer,
         screen_sys: screen_sys,
         resource_manager: resource_manager,
@@ -233,20 +236,41 @@ fn handle_window_event(window: &glutin::Window,
                        ui_container: &mut ui::Container,
                        event: glutin::Event) {
     use glutin::{Event, VirtualKeyCode};
+    use std::f64::consts::PI;
     match event {
         Event::Closed => game.should_close = true,
 
         Event::MouseMoved((x, y)) => {
             game.mouse_pos = (x, y);
             let (width, height) = window.get_inner_size_pixels().unwrap();
-
-            ui_container.hover_at(game, x as f64, y as f64, width as f64, height as f64);
+            if game.focused {
+                window.set_cursor_position((width/2) as i32, (height/2) as i32).unwrap();
+                let s = 2000.0 + 0.01;
+                let (rx, ry) = ((x-(width/2) as i32) as f64 / s, (y-(height/2) as i32) as f64 / s);
+                game.server.yaw -= rx;
+                game.server.pitch -= ry;
+                if game.server.pitch < (PI/2.0) + 0.01 {
+                    game.server.pitch = (PI/2.0) + 0.01;
+                }
+                if game.server.pitch > (PI/2.0)*3.0 - 0.01 {
+                    game.server.pitch = (PI/2.0)*3.0 - 0.01;
+                }
+            } else {
+                ui_container.hover_at(game, x as f64, y as f64, width as f64, height as f64);
+            }
         }
         Event::MouseInput(glutin::ElementState::Released, glutin::MouseButton::Left) => {
             let (x, y) = game.mouse_pos;
             let (width, height) = window.get_inner_size_pixels().unwrap();
 
-            ui_container.click_at(game, x as f64, y as f64, width as f64, height as f64);
+            if game.server.is_connected() && !game.focused {
+                game.focused = true;
+                window.set_cursor_position((width/2) as i32, (height/2) as i32).unwrap();
+                return;
+            }
+            if !game.focused {
+                ui_container.click_at(game, x as f64, y as f64, width as f64, height as f64);
+            }
         }
         Event::MouseWheel(delta) => {
             let (x, y) = match delta {
@@ -256,6 +280,11 @@ fn handle_window_event(window: &glutin::Window,
 
             game.screen_sys.on_scroll(x as f64, y as f64);
         }
+        Event::KeyboardInput(glutin::ElementState::Released, _, Some(VirtualKeyCode::Escape)) => {
+            if game.focused {
+                game.focused = false;
+            }
+        }
         Event::KeyboardInput(glutin::ElementState::Pressed, _, Some(VirtualKeyCode::Grave)) => {
             game.console.lock().unwrap().toggle();
         }

src/server.rs

@@ -35,7 +35,11 @@ pub struct Server {
     console: Arc<Mutex<console::Console>>,
     version: usize,
 
-    position: cgmath::Vector3<f64>,
+    pub position: cgmath::Vector3<f64>,
+    pub yaw: f64,
+    pub pitch: f64,
+
+    tick_timer: f64,
 }
 
 macro_rules! handle_packet {
@@ -141,7 +145,12 @@ impl Server {
             resources: resources,
             console: console,
             version: version,
+
             position: cgmath::Vector3::zero(),
+            yaw: 0.0,
+            pitch: 0.0,
+
+            tick_timer: 0.0,
         })
     }
 
@@ -165,7 +174,12 @@ impl Server {
             version: version,
             resources: resources,
             console: console,
+
             position: cgmath::Vector3::new(0.5, 13.2, 0.5),
+            yaw: 0.0,
+            pitch: 0.0,
+
+            tick_timer: 0.0,
         }
     }
 
@@ -173,7 +187,7 @@ impl Server {
         self.conn.is_some()
     }
 
-    pub fn tick(&mut self, renderer: &mut render::Renderer, _delta: f64) {
+    pub fn tick(&mut self, renderer: &mut render::Renderer, delta: f64) {
         let version = self.resources.read().unwrap().version();
         if version != self.version {
             self.version = version;
@@ -196,8 +210,30 @@ impl Server {
             self.read_queue = Some(rx);
         }
 
+        self.tick_timer += delta;
+        while self.tick_timer >= 3.0 && self.is_connected() {
+            self.minecraft_tick();
+            self.tick_timer -= 3.0;
+        }
+
         // Copy to camera
         renderer.camera.pos = cgmath::Point::from_vec(self.position + cgmath::Vector3::new(0.0, 1.8, 0.0));
+        renderer.camera.yaw = self.yaw;
+        renderer.camera.pitch = self.pitch;
+    }
+
+    pub fn minecraft_tick(&mut self) {
+
+        // Sync our position to the server
+        let packet = packet::play::serverbound::PlayerPositionLook {
+            x: self.position.x,
+            y: self.position.y,
+            z: self.position.z,
+            yaw: self.yaw as f32,
+            pitch: self.pitch as f32,
+            on_ground: false,
+        };
+        self.write_packet(packet);
     }
 
     pub fn write_packet<T: protocol::PacketType>(&mut self, p: T) {
@@ -215,6 +251,8 @@ impl Server {
         self.position.x = teleport.x;
         self.position.y = teleport.y;
         self.position.z = teleport.z;
+        self.yaw = teleport.yaw as f64;
+        self.pitch = teleport.pitch as f64;
 
         self.write_packet(packet::play::serverbound::PlayerPositionLook {
             x: teleport.x,