From 285cf2f973c9d8cfb8767edfdfb6ac4e4b37f295 Mon Sep 17 00:00:00 2001
From: Joshua Barretto <joshua.s.barretto@gmail.com>
Date: Tue, 25 Jun 2019 17:13:30 +0100
Subject: [PATCH 01/16] Added proper 3D collisions

---
 common/src/sys/phys.rs      | 53 ++++++++++++++++++++++++++++++-------
 voxygen/src/scene/camera.rs |  2 +-
 2 files changed, 44 insertions(+), 11 deletions(-)

diff --git a/common/src/sys/phys.rs b/common/src/sys/phys.rs
index 44dfdeecd3..8744899ab4 100644
--- a/common/src/sys/phys.rs
+++ b/common/src/sys/phys.rs
@@ -168,16 +168,49 @@ impl<'a> System<'a> for Sys {
             vel.0 = integrate_forces(dt.0, vel.0, friction);
 
             // Basic collision with terrain
-            let mut i = 0.0;
-            while terrain
-                .get(pos.0.map(|e| e.floor() as i32))
-                .map(|vox| !vox.is_empty())
-                .unwrap_or(false)
-                && i < 6000.0 * dt.0
-            {
-                pos.0.z += 0.0025;
-                vel.0.z = 0.0;
-                i += 1.0;
+
+            // Iterate through nearby blocks, prioritise closer ones
+            let near_iter = [0, -1, 1].into_iter()
+                .map(move |i| [0, -1, 1].into_iter()
+                    .map(move |j| [0, 1, -1, 2].into_iter()
+                        .map(move |k| (*i, *j, *k))))
+                .flatten()
+                .flatten();
+
+            // For every nearby block...
+            for (i, j, k) in near_iter {
+                let block_pos = pos.0.map(|e| e.floor() as i32) + Vec3::new(i, j, k);
+
+                // ...check to see whether it is solid...
+                if terrain
+                    .get(block_pos)
+                    .map(|vox| !vox.is_empty())
+                    .unwrap_or(false)
+                {
+                    // ...and calculate bounding boxes for both the player's body and the block.
+                    let this_body_aabb = Aabb { min: pos.0 + Vec3::new(-0.4, -0.4, 1.0), max: pos.0 + Vec3::new(0.4, 0.4, 2.0) };
+                    let other_aabb = Aabb { min: block_pos.map(|e| e as f32), max: block_pos.map(|e| e as f32) + 1.0 };
+
+                    // If the bounding boxes collide, resolve the collision
+                    if this_body_aabb.collides_with_aabb(other_aabb) {
+                        let dir = this_body_aabb.collision_vector_with_aabb(other_aabb);
+
+                        let max_axis = dir.map(|e| e.abs()).reduce_partial_min();
+                        let resolve_dir = dir.map(|e| if e.abs() == max_axis { e } else { 0.0 });
+
+                        pos.0 -= resolve_dir;
+                        vel.0 = vel.0.map2(resolve_dir, |e, d| if d == 0.0 { e } else { 0.0 });
+                    }
+
+                    // Now, calculate a binding box for the player's feet...
+                    let this_feet_aabb = Aabb { min: pos.0 + Vec3::new(-0.3, -0.3, 0.0), max: pos.0 + Vec3::new(0.3, 0.3, 1.0) };
+
+                    // ...if it collides with the block, snap the player to the top of it...
+                    if this_feet_aabb.collides_with_aabb(other_aabb) {
+                        pos.0.z -= this_feet_aabb.collision_vector_with_aabb(other_aabb).z;
+                        vel.0.z = vel.0.z.max(0.0);
+                    }
+                }
             }
         }
     }
diff --git a/voxygen/src/scene/camera.rs b/voxygen/src/scene/camera.rs
index 40d5193a1e..6a520b36bf 100644
--- a/voxygen/src/scene/camera.rs
+++ b/voxygen/src/scene/camera.rs
@@ -6,7 +6,7 @@ use vek::*;
 const NEAR_PLANE: f32 = 0.1;
 const FAR_PLANE: f32 = 10000.0;
 
-const INTERP_TIME: f32 = 0.05;
+const INTERP_TIME: f32 = 0.025;
 
 pub struct Camera {
     tgt_focus: Vec3<f32>,

From 7a1359961cd4a2fc60f0712e5f2e3e8aee0dc685 Mon Sep 17 00:00:00 2001
From: Joshua Barretto <joshua.s.barretto@gmail.com>
Date: Tue, 25 Jun 2019 19:57:44 +0100
Subject: [PATCH 02/16] Removed block-hopping, fixed collisions

---
 common/src/sys/phys.rs | 81 ++++++++++++++++++++++++++----------------
 1 file changed, 50 insertions(+), 31 deletions(-)

diff --git a/common/src/sys/phys.rs b/common/src/sys/phys.rs
index 8744899ab4..87fdbfbb02 100644
--- a/common/src/sys/phys.rs
+++ b/common/src/sys/phys.rs
@@ -145,18 +145,6 @@ impl<'a> System<'a> for Sys {
             // Movement
             pos.0 += vel.0 * dt.0;
 
-            // Update OnGround component
-            if terrain
-                .get((pos.0 - Vec3::unit_z() * 0.1).map(|e| e.floor() as i32))
-                .map(|vox| !vox.is_empty())
-                .unwrap_or(false)
-                && vel.0.z <= 0.0
-            {
-                on_grounds.insert(entity, OnGround);
-            } else {
-                on_grounds.remove(entity);
-            }
-
             // Integrate forces
             // Friction is assumed to be a constant dependent on location
             let friction = 50.0
@@ -170,14 +158,37 @@ impl<'a> System<'a> for Sys {
             // Basic collision with terrain
 
             // Iterate through nearby blocks, prioritise closer ones
-            let near_iter = [0, -1, 1].into_iter()
-                .map(move |i| [0, -1, 1].into_iter()
-                    .map(move |j| [0, 1, -1, 2].into_iter()
-                        .map(move |k| (*i, *j, *k))))
+            let near_iter = [0, -1, 1, -2, 2, 3].into_iter()
+                .map(move |k| [0, -1, 1, -2, 2].into_iter()
+                    .map(move |j| [0, -1, 1, -2, 2].into_iter()
+                        .map(move |i| (*i, *j, *k))))
                 .flatten()
                 .flatten();
 
+                /*
+            let collision_with = |pos: Vec3<f32>, near_iter| {
+                for (i, j, k) in near_iter {
+                    let block_pos = pos.map(|e| e.floor() as i32) + Vec3::new(i, j, k);
+
+                    let this_aabb = Aabb { min: pos + Vec3::new(-0.3, -0.3, 0.0), max: pos + Vec3::new(0.3, 0.3, 1.7) };
+                    let block_aabb = Aabb { min: block_pos.map(|e| e as f32), max: block_pos.map(|e| e as f32) + 1.0 };
+
+                    if this_aabb.collides_with_aabb(block_aabb) {
+                        return true;
+                    }
+                }
+                false
+            };
+            */
+
+            //let collision_above = collision_with(pos.0 + Vec3::unit_z() * 1.1, near_iter.clone());
+            //let collision_below = collision_with(pos.0 - Vec3::unit_z() * 1.01, near_iter.clone());
+
+            on_grounds.remove(entity);
+            pos.0.z -= 0.0001; // To force collision with the floor
+
             // For every nearby block...
+            let mut on_ground = false;
             for (i, j, k) in near_iter {
                 let block_pos = pos.0.map(|e| e.floor() as i32) + Vec3::new(i, j, k);
 
@@ -188,30 +199,38 @@ impl<'a> System<'a> for Sys {
                     .unwrap_or(false)
                 {
                     // ...and calculate bounding boxes for both the player's body and the block.
-                    let this_body_aabb = Aabb { min: pos.0 + Vec3::new(-0.4, -0.4, 1.0), max: pos.0 + Vec3::new(0.4, 0.4, 2.0) };
-                    let other_aabb = Aabb { min: block_pos.map(|e| e as f32), max: block_pos.map(|e| e as f32) + 1.0 };
+                    let this_aabb = Aabb { min: pos.0 + Vec3::new(-0.3, -0.3, 0.0), max: pos.0 + Vec3::new(0.3, 0.3, 1.7) };
+                    let block_aabb = Aabb { min: block_pos.map(|e| e as f32), max: block_pos.map(|e| e as f32) + 1.0 };
 
                     // If the bounding boxes collide, resolve the collision
-                    if this_body_aabb.collides_with_aabb(other_aabb) {
-                        let dir = this_body_aabb.collision_vector_with_aabb(other_aabb);
+                    if this_aabb.collides_with_aabb(block_aabb) {
+                        let dir = this_aabb.collision_vector_with_aabb(block_aabb);
 
                         let max_axis = dir.map(|e| e.abs()).reduce_partial_min();
-                        let resolve_dir = dir.map(|e| if e.abs() == max_axis { e } else { 0.0 });
+                        let resolve_dir = -dir.map(|e| if e.abs() == max_axis { e } else { 0.0 });
 
-                        pos.0 -= resolve_dir;
-                        vel.0 = vel.0.map2(resolve_dir, |e, d| if d == 0.0 { e } else { 0.0 });
-                    }
+                        // When the resolution direction is pointing upwards, we must be on the ground
+                        if resolve_dir.z > 0.0 {
+                            on_ground = true;
+                        }
 
-                    // Now, calculate a binding box for the player's feet...
-                    let this_feet_aabb = Aabb { min: pos.0 + Vec3::new(-0.3, -0.3, 0.0), max: pos.0 + Vec3::new(0.3, 0.3, 1.0) };
-
-                    // ...if it collides with the block, snap the player to the top of it...
-                    if this_feet_aabb.collides_with_aabb(other_aabb) {
-                        pos.0.z -= this_feet_aabb.collision_vector_with_aabb(other_aabb).z;
-                        vel.0.z = vel.0.z.max(0.0);
+                        //if resolve_dir.z == 0.0 && !collision_above {
+                        //    pos.0.z += 1.01;
+                        //    break;
+                        //} else {
+                            pos.0 += resolve_dir;
+                            vel.0 = vel.0.map2(resolve_dir, |e, d| if d == 0.0 { e } else { 0.0 });
+                        //}
                     }
                 }
             }
+
+
+            if on_ground {
+                on_grounds.insert(entity, OnGround);
+            }// else if collision_below && vel.0.z < 0.0 {
+            //    pos.0.z -= 0.5;
+            //}
         }
     }
 }

From 2c24ba777606575148407df5ed24664c00861c37 Mon Sep 17 00:00:00 2001
From: Joshua Barretto <joshua.s.barretto@gmail.com>
Date: Tue, 25 Jun 2019 21:26:04 +0100
Subject: [PATCH 03/16] Fixed block-hopping, block-snapping, added
 interpolation to figures

---
 common/src/sys/phys.rs      | 39 +++++++++++++++++++------------------
 voxygen/src/scene/camera.rs |  2 +-
 voxygen/src/scene/figure.rs | 10 +++++++++-
 3 files changed, 30 insertions(+), 21 deletions(-)

diff --git a/common/src/sys/phys.rs b/common/src/sys/phys.rs
index 87fdbfbb02..803480753d 100644
--- a/common/src/sys/phys.rs
+++ b/common/src/sys/phys.rs
@@ -165,31 +165,32 @@ impl<'a> System<'a> for Sys {
                 .flatten()
                 .flatten();
 
-                /*
             let collision_with = |pos: Vec3<f32>, near_iter| {
                 for (i, j, k) in near_iter {
                     let block_pos = pos.map(|e| e.floor() as i32) + Vec3::new(i, j, k);
 
-                    let this_aabb = Aabb { min: pos + Vec3::new(-0.3, -0.3, 0.0), max: pos + Vec3::new(0.3, 0.3, 1.7) };
-                    let block_aabb = Aabb { min: block_pos.map(|e| e as f32), max: block_pos.map(|e| e as f32) + 1.0 };
+                    if terrain
+                        .get(block_pos)
+                        .map(|vox| !vox.is_empty())
+                        .unwrap_or(false)
+                    {
+                        let this_aabb = Aabb { min: pos + Vec3::new(-0.3, -0.3, 0.0), max: pos + Vec3::new(0.3, 0.3, 1.7) };
+                        let block_aabb = Aabb { min: block_pos.map(|e| e as f32), max: block_pos.map(|e| e as f32) + 1.0 };
 
-                    if this_aabb.collides_with_aabb(block_aabb) {
-                        return true;
+                        if this_aabb.collides_with_aabb(block_aabb) {
+                            return true;
+                        }
                     }
                 }
                 false
             };
-            */
-
-            //let collision_above = collision_with(pos.0 + Vec3::unit_z() * 1.1, near_iter.clone());
-            //let collision_below = collision_with(pos.0 - Vec3::unit_z() * 1.01, near_iter.clone());
 
             on_grounds.remove(entity);
             pos.0.z -= 0.0001; // To force collision with the floor
 
             // For every nearby block...
             let mut on_ground = false;
-            for (i, j, k) in near_iter {
+            for (i, j, k) in near_iter.clone() {
                 let block_pos = pos.0.map(|e| e.floor() as i32) + Vec3::new(i, j, k);
 
                 // ...check to see whether it is solid...
@@ -214,23 +215,23 @@ impl<'a> System<'a> for Sys {
                             on_ground = true;
                         }
 
-                        //if resolve_dir.z == 0.0 && !collision_above {
-                        //    pos.0.z += 1.01;
-                        //    break;
-                        //} else {
+                        if resolve_dir.z == 0.0 && !collision_with(pos.0 + Vec3::unit_z() * 1.0, near_iter.clone()) {
+                            pos.0.z += 1.0;
+                            break;
+                        } else {
                             pos.0 += resolve_dir;
                             vel.0 = vel.0.map2(resolve_dir, |e, d| if d == 0.0 { e } else { 0.0 });
-                        //}
+                        }
                     }
                 }
             }
 
-
             if on_ground {
                 on_grounds.insert(entity, OnGround);
-            }// else if collision_below && vel.0.z < 0.0 {
-            //    pos.0.z -= 0.5;
-            //}
+            } else if collision_with(pos.0 - Vec3::unit_z() * 1.0, near_iter.clone()) && vel.0.z < 0.0 && vel.0.z > -1.0 {
+                pos.0.z = (pos.0.z - 0.05).floor();
+                on_grounds.insert(entity, OnGround);
+            }
         }
     }
 }
diff --git a/voxygen/src/scene/camera.rs b/voxygen/src/scene/camera.rs
index 6a520b36bf..40d5193a1e 100644
--- a/voxygen/src/scene/camera.rs
+++ b/voxygen/src/scene/camera.rs
@@ -6,7 +6,7 @@ use vek::*;
 const NEAR_PLANE: f32 = 0.1;
 const FAR_PLANE: f32 = 10000.0;
 
-const INTERP_TIME: f32 = 0.025;
+const INTERP_TIME: f32 = 0.05;
 
 pub struct Camera {
     tgt_focus: Vec3<f32>,
diff --git a/voxygen/src/scene/figure.rs b/voxygen/src/scene/figure.rs
index 000c38233c..46dee347ef 100644
--- a/voxygen/src/scene/figure.rs
+++ b/voxygen/src/scene/figure.rs
@@ -741,6 +741,8 @@ pub struct FigureState<S: Skeleton> {
     bone_consts: Consts<FigureBoneData>,
     locals: Consts<FigureLocals>,
     skeleton: S,
+    pos: Vec3<f32>,
+    ori: Vec3<f32>,
 }
 
 impl<S: Skeleton> FigureState<S> {
@@ -751,6 +753,8 @@ impl<S: Skeleton> FigureState<S> {
                 .unwrap(),
             locals: renderer.create_consts(&[FigureLocals::default()]).unwrap(),
             skeleton,
+            pos: Vec3::zero(),
+            ori: Vec3::zero(),
         }
     }
 
@@ -761,8 +765,12 @@ impl<S: Skeleton> FigureState<S> {
         ori: Vec3<f32>,
         col: Rgba<f32>,
     ) {
+        // Update interpolate pos
+        self.pos = Lerp::lerp(self.pos, pos, 0.4);
+        self.ori = Slerp::slerp(self.ori, ori, 0.2);
+
         let mat = Mat4::<f32>::identity()
-            * Mat4::translation_3d(pos)
+            * Mat4::translation_3d(self.pos)
             * Mat4::rotation_z(-ori.x.atan2(ori.y))
             * Mat4::scaling_3d(Vec3::from(0.8));
 

From af432ec510504579b104e2e2c030fbcae74316eb Mon Sep 17 00:00:00 2001
From: Joshua Barretto <joshua.s.barretto@gmail.com>
Date: Tue, 25 Jun 2019 22:00:26 +0100
Subject: [PATCH 04/16] Calculate delta time properly, fix low fps collision
 issues by decreasing max dt

---
 common/src/state.rs                      |  7 ++++++-
 voxygen/src/menu/char_selection/scene.rs |  1 +
 voxygen/src/scene/figure.rs              | 16 ++++++++--------
 voxygen/src/session.rs                   |  2 +-
 4 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/common/src/state.rs b/common/src/state.rs
index 974c841258..56d476b4f4 100644
--- a/common/src/state.rs
+++ b/common/src/state.rs
@@ -38,7 +38,7 @@ pub struct DeltaTime(pub f32);
 /// too fast, we'd skip important physics events like collisions. This constant determines the
 /// upper limit. If delta time exceeds this value, the game's physics will begin to produce time
 /// lag. Ideally, we'd avoid such a situation.
-const MAX_DELTA_TIME: f32 = 0.15;
+const MAX_DELTA_TIME: f32 = 0.03;
 
 pub struct Changes {
     pub new_chunks: HashSet<Vec2<i32>>,
@@ -188,6 +188,11 @@ impl State {
         self.ecs.read_resource::<Time>().0
     }
 
+    /// Get the current delta time.
+    pub fn get_delta_time(&self) -> f32 {
+        self.ecs.read_resource::<DeltaTime>().0
+    }
+
     /// Get a reference to this state's terrain.
     pub fn terrain(&self) -> Fetch<TerrainMap> {
         self.ecs.read_resource::<TerrainMap>()
diff --git a/voxygen/src/menu/char_selection/scene.rs b/voxygen/src/menu/char_selection/scene.rs
index cee590eaa0..9ea9a24756 100644
--- a/voxygen/src/menu/char_selection/scene.rs
+++ b/voxygen/src/menu/char_selection/scene.rs
@@ -118,6 +118,7 @@ impl Scene {
             Vec3::zero(),
             -Vec3::unit_y(),
             Rgba::broadcast(1.0),
+            1.0 / 60.0, // TODO: Use actual deltatime here?
         );
     }
 
diff --git a/voxygen/src/scene/figure.rs b/voxygen/src/scene/figure.rs
index 46dee347ef..c7ea2878c9 100644
--- a/voxygen/src/scene/figure.rs
+++ b/voxygen/src/scene/figure.rs
@@ -474,10 +474,9 @@ impl FigureMgr {
         let time = client.state().get_time();
         let ecs = client.state().ecs();
         let view_distance = client.view_distance().unwrap_or(1);
+        let dt = client.state().get_delta_time();
         // Get player position.
-        let player_pos = client
-            .state()
-            .ecs()
+        let player_pos = ecs
             .read_storage::<comp::Pos>()
             .get(client.entity())
             .map_or(Vec3::zero(), |pos| pos.0);
@@ -584,7 +583,7 @@ impl FigureMgr {
                             &target_skeleton,
                             client.state().ecs().read_resource::<DeltaTime>().0,
                         );
-                        state.update(renderer, pos.0, ori.0, col);
+                        state.update(renderer, pos.0, ori.0, col, dt);
                     }
                     Body::Quadruped(_) => {
                         let state = self.quadruped_states.entry(entity).or_insert_with(|| {
@@ -616,7 +615,7 @@ impl FigureMgr {
                             &target_skeleton,
                             client.state().ecs().read_resource::<DeltaTime>().0,
                         );
-                        state.update(renderer, pos.0, ori.0, col);
+                        state.update(renderer, pos.0, ori.0, col, dt);
                     }
                     Body::QuadrupedMedium(_) => {
                         let state =
@@ -655,7 +654,7 @@ impl FigureMgr {
                             &target_skeleton,
                             client.state().ecs().read_resource::<DeltaTime>().0,
                         );
-                        state.update(renderer, pos.0, ori.0, col);
+                        state.update(renderer, pos.0, ori.0, col, dt);
                     }
                 },
                 // TODO: Non-character actors
@@ -764,10 +763,11 @@ impl<S: Skeleton> FigureState<S> {
         pos: Vec3<f32>,
         ori: Vec3<f32>,
         col: Rgba<f32>,
+        dt: f32,
     ) {
         // Update interpolate pos
-        self.pos = Lerp::lerp(self.pos, pos, 0.4);
-        self.ori = Slerp::slerp(self.ori, ori, 0.2);
+        self.pos = Lerp::lerp(self.pos, pos, (0.4f32).powf(60.0).powf(dt));
+        self.ori = Slerp::slerp(self.ori, ori, (0.2f32).powf(60.0).powf(dt));
 
         let mat = Mat4::<f32>::identity()
             * Mat4::translation_3d(self.pos)
diff --git a/voxygen/src/session.rs b/voxygen/src/session.rs
index 3bf9504d51..1c46ddd2a1 100644
--- a/voxygen/src/session.rs
+++ b/voxygen/src/session.rs
@@ -151,7 +151,7 @@ impl PlayState for SessionState {
             self.controller.move_dir = unit_vecs.0 * dir_vec[0] + unit_vecs.1 * dir_vec[1];
 
             // Perform an in-game tick.
-            if let Err(err) = self.tick(clock.get_last_delta()) {
+            if let Err(err) = self.tick(clock.get_avg_delta()) {
                 error!("Failed to tick the scene: {:?}", err);
                 return PlayStateResult::Pop;
             }

From c2c5b9f5e773ef16b4dc5337f785cb00e2f5863a Mon Sep 17 00:00:00 2001
From: Joshua Barretto <joshua.s.barretto@gmail.com>
Date: Tue, 25 Jun 2019 22:26:18 +0100
Subject: [PATCH 05/16] Better camera interpolation

---
 voxygen/src/scene/camera.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/voxygen/src/scene/camera.rs b/voxygen/src/scene/camera.rs
index 40d5193a1e..f8c76e5f3c 100644
--- a/voxygen/src/scene/camera.rs
+++ b/voxygen/src/scene/camera.rs
@@ -6,7 +6,7 @@ use vek::*;
 const NEAR_PLANE: f32 = 0.1;
 const FAR_PLANE: f32 = 10000.0;
 
-const INTERP_TIME: f32 = 0.05;
+const INTERP_TIME: f32 = 0.1;
 
 pub struct Camera {
     tgt_focus: Vec3<f32>,

From 0d984a567134a2d5955bfdbb2ef42b6352c5cce7 Mon Sep 17 00:00:00 2001
From: Joshua Barretto <joshua.s.barretto@gmail.com>
Date: Wed, 26 Jun 2019 00:09:41 +0100
Subject: [PATCH 06/16] Fixed collision bugs

---
 common/src/sys/phys.rs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/common/src/sys/phys.rs b/common/src/sys/phys.rs
index 803480753d..e6d64dea73 100644
--- a/common/src/sys/phys.rs
+++ b/common/src/sys/phys.rs
@@ -158,10 +158,14 @@ impl<'a> System<'a> for Sys {
             // Basic collision with terrain
 
             // Iterate through nearby blocks, prioritise closer ones
-            let near_iter = [0, -1, 1, -2, 2, 3].into_iter()
-                .map(move |k| [0, -1, 1, -2, 2].into_iter()
-                    .map(move |j| [0, -1, 1, -2, 2].into_iter()
-                        .map(move |i| (*i, *j, *k))))
+            let near_iter = (0..5)
+                .map(move |dist| (-dist..=dist)
+                    .map(move |x| (-dist..=dist)
+                        .map(move |y| (-dist..=dist)
+                            .map(move |z| Vec3::new(x, y, z))
+                            .filter(move |p| p.map(|e: i32| e.abs()).reduce_max() == dist)
+                            .map(|p| p.into_tuple()))))
+                .flatten()
                 .flatten()
                 .flatten();
 

From ae168711d7154cc4bd7d65358a03e4ae29ef51a7 Mon Sep 17 00:00:00 2001
From: Joshua Barretto <joshua.s.barretto@gmail.com>
Date: Wed, 26 Jun 2019 01:28:30 +0100
Subject: [PATCH 07/16] Added configurable details

---
 common/src/sys/phys.rs | 52 +++++++++++++++++++++++++++++++-----------
 1 file changed, 39 insertions(+), 13 deletions(-)

diff --git a/common/src/sys/phys.rs b/common/src/sys/phys.rs
index e6d64dea73..7ac4b0c470 100644
--- a/common/src/sys/phys.rs
+++ b/common/src/sys/phys.rs
@@ -156,19 +156,26 @@ impl<'a> System<'a> for Sys {
             vel.0 = integrate_forces(dt.0, vel.0, friction);
 
             // Basic collision with terrain
+            let player_rad = 0.3; // half-width of the player's AABB
+            let player_height = 1.7;
 
             // Iterate through nearby blocks, prioritise closer ones
             let near_iter = (0..5)
-                .map(move |dist| (-dist..=dist)
-                    .map(move |x| (-dist..=dist)
-                        .map(move |y| (-dist..=dist)
-                            .map(move |z| Vec3::new(x, y, z))
-                            .filter(move |p| p.map(|e: i32| e.abs()).reduce_max() == dist)
-                            .map(|p| p.into_tuple()))))
+                .map(move |dist| {
+                    (-dist..=dist).map(move |x| {
+                        (-dist..=dist).map(move |y| {
+                            (-dist..=dist)
+                                .map(move |z| Vec3::new(x, y, z))
+                                .filter(move |p| p.map(|e: i32| e.abs()).reduce_max() == dist)
+                                .map(|p| p.into_tuple())
+                        })
+                    })
+                })
                 .flatten()
                 .flatten()
                 .flatten();
 
+            // Function for determining whether the player at a specific position collides with the ground
             let collision_with = |pos: Vec3<f32>, near_iter| {
                 for (i, j, k) in near_iter {
                     let block_pos = pos.map(|e| e.floor() as i32) + Vec3::new(i, j, k);
@@ -178,8 +185,14 @@ impl<'a> System<'a> for Sys {
                         .map(|vox| !vox.is_empty())
                         .unwrap_or(false)
                     {
-                        let this_aabb = Aabb { min: pos + Vec3::new(-0.3, -0.3, 0.0), max: pos + Vec3::new(0.3, 0.3, 1.7) };
-                        let block_aabb = Aabb { min: block_pos.map(|e| e as f32), max: block_pos.map(|e| e as f32) + 1.0 };
+                        let this_aabb = Aabb {
+                            min: pos + Vec3::new(-player_rad, -player_rad, 0.0),
+                            max: pos + Vec3::new(player_rad, player_rad, player_height),
+                        };
+                        let block_aabb = Aabb {
+                            min: block_pos.map(|e| e as f32),
+                            max: block_pos.map(|e| e as f32) + 1.0,
+                        };
 
                         if this_aabb.collides_with_aabb(block_aabb) {
                             return true;
@@ -204,8 +217,14 @@ impl<'a> System<'a> for Sys {
                     .unwrap_or(false)
                 {
                     // ...and calculate bounding boxes for both the player's body and the block.
-                    let this_aabb = Aabb { min: pos.0 + Vec3::new(-0.3, -0.3, 0.0), max: pos.0 + Vec3::new(0.3, 0.3, 1.7) };
-                    let block_aabb = Aabb { min: block_pos.map(|e| e as f32), max: block_pos.map(|e| e as f32) + 1.0 };
+                    let this_aabb = Aabb {
+                        min: pos.0 + Vec3::new(-player_rad, -player_rad, 0.0),
+                        max: pos.0 + Vec3::new(player_rad, player_rad, player_height),
+                    };
+                    let block_aabb = Aabb {
+                        min: block_pos.map(|e| e as f32),
+                        max: block_pos.map(|e| e as f32) + 1.0,
+                    };
 
                     // If the bounding boxes collide, resolve the collision
                     if this_aabb.collides_with_aabb(block_aabb) {
@@ -219,12 +238,16 @@ impl<'a> System<'a> for Sys {
                             on_ground = true;
                         }
 
-                        if resolve_dir.z == 0.0 && !collision_with(pos.0 + Vec3::unit_z() * 1.0, near_iter.clone()) {
+                        if resolve_dir.z == 0.0
+                            && !collision_with(pos.0 + Vec3::unit_z() * 1.0, near_iter.clone())
+                        {
                             pos.0.z += 1.0;
                             break;
                         } else {
                             pos.0 += resolve_dir;
-                            vel.0 = vel.0.map2(resolve_dir, |e, d| if d == 0.0 { e } else { 0.0 });
+                            vel.0 = vel
+                                .0
+                                .map2(resolve_dir, |e, d| if d == 0.0 { e } else { 0.0 });
                         }
                     }
                 }
@@ -232,7 +255,10 @@ impl<'a> System<'a> for Sys {
 
             if on_ground {
                 on_grounds.insert(entity, OnGround);
-            } else if collision_with(pos.0 - Vec3::unit_z() * 1.0, near_iter.clone()) && vel.0.z < 0.0 && vel.0.z > -1.0 {
+            } else if collision_with(pos.0 - Vec3::unit_z() * 1.0, near_iter.clone())
+                && vel.0.z < 0.0
+                && vel.0.z > -1.0
+            {
                 pos.0.z = (pos.0.z - 0.05).floor();
                 on_grounds.insert(entity, OnGround);
             }

From 44f4031e58f0ad6383e46f2f5a4f5718d21a4a4a Mon Sep 17 00:00:00 2001
From: Joshua Barretto <joshua.s.barretto@gmail.com>
Date: Wed, 26 Jun 2019 10:40:07 +0100
Subject: [PATCH 08/16] Resolved collision bugs with prioritised collision
 system

---
 common/src/lib.rs      |   1 +
 common/src/sys/phys.rs | 108 +++++++++++++++++++----------------------
 2 files changed, 52 insertions(+), 57 deletions(-)

diff --git a/common/src/lib.rs b/common/src/lib.rs
index f9014bed0b..a774a9efe2 100644
--- a/common/src/lib.rs
+++ b/common/src/lib.rs
@@ -1,3 +1,4 @@
+#![type_length_limit="1615607"]
 #![feature(
     euclidean_division,
     duration_float,
diff --git a/common/src/sys/phys.rs b/common/src/sys/phys.rs
index 7ac4b0c470..6c641217fd 100644
--- a/common/src/sys/phys.rs
+++ b/common/src/sys/phys.rs
@@ -159,19 +159,11 @@ impl<'a> System<'a> for Sys {
             let player_rad = 0.3; // half-width of the player's AABB
             let player_height = 1.7;
 
-            // Iterate through nearby blocks, prioritise closer ones
-            let near_iter = (0..5)
-                .map(move |dist| {
-                    (-dist..=dist).map(move |x| {
-                        (-dist..=dist).map(move |y| {
-                            (-dist..=dist)
-                                .map(move |z| Vec3::new(x, y, z))
-                                .filter(move |p| p.map(|e: i32| e.abs()).reduce_max() == dist)
-                                .map(|p| p.into_tuple())
-                        })
-                    })
-                })
-                .flatten()
+            let dist = 2;
+            let near_iter = (-dist..=dist)
+                .map(move |i| (-dist..=dist)
+                    .map(move |j| (-dist..=dist)
+                        .map(move |k| (i, j, k))))
                 .flatten()
                 .flatten();
 
@@ -185,7 +177,7 @@ impl<'a> System<'a> for Sys {
                         .map(|vox| !vox.is_empty())
                         .unwrap_or(false)
                     {
-                        let this_aabb = Aabb {
+                        let player_aabb = Aabb {
                             min: pos + Vec3::new(-player_rad, -player_rad, 0.0),
                             max: pos + Vec3::new(player_rad, player_rad, player_height),
                         };
@@ -194,7 +186,7 @@ impl<'a> System<'a> for Sys {
                             max: block_pos.map(|e| e as f32) + 1.0,
                         };
 
-                        if this_aabb.collides_with_aabb(block_aabb) {
+                        if player_aabb.collides_with_aabb(block_aabb) {
                             return true;
                         }
                     }
@@ -205,51 +197,53 @@ impl<'a> System<'a> for Sys {
             on_grounds.remove(entity);
             pos.0.z -= 0.0001; // To force collision with the floor
 
-            // For every nearby block...
             let mut on_ground = false;
-            for (i, j, k) in near_iter.clone() {
-                let block_pos = pos.0.map(|e| e.floor() as i32) + Vec3::new(i, j, k);
+            while collision_with(pos.0, near_iter.clone()) {
+                let player_aabb = Aabb {
+                    min: pos.0 + Vec3::new(-player_rad, -player_rad, 0.0),
+                    max: pos.0 + Vec3::new(player_rad, player_rad, player_height),
+                };
 
-                // ...check to see whether it is solid...
-                if terrain
-                    .get(block_pos)
-                    .map(|vox| !vox.is_empty())
-                    .unwrap_or(false)
+                let (block_pos, block_aabb) = near_iter
+                    .clone()
+                    .map(|(i, j, k)| pos.0.map(|e| e.floor() as i32) + Vec3::new(i, j, k))
+                    .map(|block_pos| {
+                        let block_aabb = Aabb {
+                            min: block_pos.map(|e| e as f32),
+                            max: block_pos.map(|e| e as f32) + 1.0,
+                        };
+
+                        (block_pos, block_aabb)
+                    })
+                    .filter(|(_, block_aabb)| block_aabb.collides_with_aabb(player_aabb))
+                    .filter(|(block_pos, _)| terrain
+                        .get(*block_pos)
+                        .map(|vox| !vox.is_empty())
+                        .unwrap_or(false))
+                    .max_by_key(|(_, block_aabb)| ((player_aabb.collision_vector_with_aabb(*block_aabb) * Vec3::new(1.0, 1.0, 10.0)).map(|e| e.abs()).reduce_partial_min() * 200.0) as i32)
+                    .expect("Collision detected, but no colliding blocks found!");
+
+                let dir = player_aabb.collision_vector_with_aabb(block_aabb);
+
+                let max_axis = dir.map(|e| e.abs()).reduce_partial_min();
+                let resolve_dir = -dir.map(|e| if e.abs() == max_axis { e } else { 0.0 });
+
+                // When the resolution direction is pointing upwards, we must be on the ground
+                if resolve_dir.z > 0.0 {
+                    on_ground = true;
+                }
+
+                if resolve_dir.z == 0.0
+                    && !collision_with(pos.0 + Vec3::unit_z() * 1.1, near_iter.clone())
                 {
-                    // ...and calculate bounding boxes for both the player's body and the block.
-                    let this_aabb = Aabb {
-                        min: pos.0 + Vec3::new(-player_rad, -player_rad, 0.0),
-                        max: pos.0 + Vec3::new(player_rad, player_rad, player_height),
-                    };
-                    let block_aabb = Aabb {
-                        min: block_pos.map(|e| e as f32),
-                        max: block_pos.map(|e| e as f32) + 1.0,
-                    };
-
-                    // If the bounding boxes collide, resolve the collision
-                    if this_aabb.collides_with_aabb(block_aabb) {
-                        let dir = this_aabb.collision_vector_with_aabb(block_aabb);
-
-                        let max_axis = dir.map(|e| e.abs()).reduce_partial_min();
-                        let resolve_dir = -dir.map(|e| if e.abs() == max_axis { e } else { 0.0 });
-
-                        // When the resolution direction is pointing upwards, we must be on the ground
-                        if resolve_dir.z > 0.0 {
-                            on_ground = true;
-                        }
-
-                        if resolve_dir.z == 0.0
-                            && !collision_with(pos.0 + Vec3::unit_z() * 1.0, near_iter.clone())
-                        {
-                            pos.0.z += 1.0;
-                            break;
-                        } else {
-                            pos.0 += resolve_dir;
-                            vel.0 = vel
-                                .0
-                                .map2(resolve_dir, |e, d| if d == 0.0 { e } else { 0.0 });
-                        }
-                    }
+                    pos.0.z += 1.0;
+                    on_ground = true;
+                    break;
+                } else {
+                    pos.0 += resolve_dir;
+                    vel.0 = vel
+                        .0
+                        .map2(resolve_dir, |e, d| if d == 0.0 { e } else { 0.0 });
                 }
             }
 

From 6258035a4d3f7fdfb35f794785399cb50d5d91db Mon Sep 17 00:00:00 2001
From: Joshua Barretto <joshua.s.barretto@gmail.com>
Date: Wed, 26 Jun 2019 10:43:03 +0100
Subject: [PATCH 09/16] Added attempts counter to prevent infinite collision
 loops

---
 common/src/sys/phys.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/common/src/sys/phys.rs b/common/src/sys/phys.rs
index 6c641217fd..b3cd700318 100644
--- a/common/src/sys/phys.rs
+++ b/common/src/sys/phys.rs
@@ -198,7 +198,8 @@ impl<'a> System<'a> for Sys {
             pos.0.z -= 0.0001; // To force collision with the floor
 
             let mut on_ground = false;
-            while collision_with(pos.0, near_iter.clone()) {
+            let mut attempts = 0;
+            while collision_with(pos.0, near_iter.clone()) && attempts < 32 {
                 let player_aabb = Aabb {
                     min: pos.0 + Vec3::new(-player_rad, -player_rad, 0.0),
                     max: pos.0 + Vec3::new(player_rad, player_rad, player_height),
@@ -245,6 +246,8 @@ impl<'a> System<'a> for Sys {
                         .0
                         .map2(resolve_dir, |e, d| if d == 0.0 { e } else { 0.0 });
                 }
+
+                attempts += 1;
             }
 
             if on_ground {

From 5decd48db68d22ee69910bbda30c7a5853b52eee Mon Sep 17 00:00:00 2001
From: Joshua Barretto <joshua.s.barretto@gmail.com>
Date: Wed, 26 Jun 2019 10:55:08 +0100
Subject: [PATCH 10/16] Used velocity bias for collision correction

---
 common/src/lib.rs      | 2 +-
 common/src/sys/phys.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/common/src/lib.rs b/common/src/lib.rs
index a774a9efe2..75d1064937 100644
--- a/common/src/lib.rs
+++ b/common/src/lib.rs
@@ -1,4 +1,4 @@
-#![type_length_limit="1615607"]
+#![type_length_limit="1652471"]
 #![feature(
     euclidean_division,
     duration_float,
diff --git a/common/src/sys/phys.rs b/common/src/sys/phys.rs
index b3cd700318..9cb2504663 100644
--- a/common/src/sys/phys.rs
+++ b/common/src/sys/phys.rs
@@ -221,7 +221,7 @@ impl<'a> System<'a> for Sys {
                         .get(*block_pos)
                         .map(|vox| !vox.is_empty())
                         .unwrap_or(false))
-                    .max_by_key(|(_, block_aabb)| ((player_aabb.collision_vector_with_aabb(*block_aabb) * Vec3::new(1.0, 1.0, 10.0)).map(|e| e.abs()).reduce_partial_min() * 200.0) as i32)
+                    .max_by_key(|(_, block_aabb)| ((player_aabb.collision_vector_with_aabb(*block_aabb) / vel.0).map(|e| e.abs()).reduce_partial_min() * 1000.0) as i32)
                     .expect("Collision detected, but no colliding blocks found!");
 
                 let dir = player_aabb.collision_vector_with_aabb(block_aabb);

From d2b8f592df203dc694cc81ec6e2fced231403cf8 Mon Sep 17 00:00:00 2001
From: Joshua Barretto <joshua.s.barretto@gmail.com>
Date: Wed, 26 Jun 2019 11:08:28 +0100
Subject: [PATCH 11/16] Fixed dt figure interpolation scaling

---
 voxygen/src/scene/figure.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/voxygen/src/scene/figure.rs b/voxygen/src/scene/figure.rs
index c7ea2878c9..49eb0cbb7b 100644
--- a/voxygen/src/scene/figure.rs
+++ b/voxygen/src/scene/figure.rs
@@ -766,8 +766,8 @@ impl<S: Skeleton> FigureState<S> {
         dt: f32,
     ) {
         // Update interpolate pos
-        self.pos = Lerp::lerp(self.pos, pos, (0.4f32).powf(60.0).powf(dt));
-        self.ori = Slerp::slerp(self.ori, ori, (0.2f32).powf(60.0).powf(dt));
+        self.pos = Lerp::lerp(self.pos, pos, (0.4f32).powf(1.0 / 60.0).powf(1.0 / dt));
+        self.ori = Slerp::slerp(self.ori, ori, (0.2f32).powf(1.0 / 60.0).powf(1.0 / dt));
 
         let mat = Mat4::<f32>::identity()
             * Mat4::translation_3d(self.pos)

From 692fa3f28d0356bd1ada612640623e82077b8860 Mon Sep 17 00:00:00 2001
From: Joshua Barretto <joshua.s.barretto@gmail.com>
Date: Wed, 26 Jun 2019 11:18:45 +0100
Subject: [PATCH 12/16] Above-ground spawn point, better figure dt scaling

---
 server/src/lib.rs           | 2 +-
 voxygen/src/scene/figure.rs | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/server/src/lib.rs b/server/src/lib.rs
index 747ef7f272..aa331e103b 100644
--- a/server/src/lib.rs
+++ b/server/src/lib.rs
@@ -83,7 +83,7 @@ impl Server {
         let mut state = State::new();
         state
             .ecs_mut()
-            .add_resource(SpawnPoint(Vec3::new(16_384.0, 16_384.0, 280.0)));
+            .add_resource(SpawnPoint(Vec3::new(16_384.0, 16_384.0, 305.0)));
 
         let this = Self {
             state,
diff --git a/voxygen/src/scene/figure.rs b/voxygen/src/scene/figure.rs
index 49eb0cbb7b..c2784a0673 100644
--- a/voxygen/src/scene/figure.rs
+++ b/voxygen/src/scene/figure.rs
@@ -766,8 +766,8 @@ impl<S: Skeleton> FigureState<S> {
         dt: f32,
     ) {
         // Update interpolate pos
-        self.pos = Lerp::lerp(self.pos, pos, (0.4f32).powf(1.0 / 60.0).powf(1.0 / dt));
-        self.ori = Slerp::slerp(self.ori, ori, (0.2f32).powf(1.0 / 60.0).powf(1.0 / dt));
+        self.pos = Lerp::lerp(self.pos, pos, (0.3f32).powf(1.0 / 60.0).powf(1.0 / dt));
+        self.ori = Slerp::slerp(self.ori, ori, (0.15f32).powf(1.0 / 60.0).powf(1.0 / dt));
 
         let mat = Mat4::<f32>::identity()
             * Mat4::translation_3d(self.pos)

From 4a340f69b50fdc9b8716f664b59833cb52ad57ab Mon Sep 17 00:00:00 2001
From: Joshua Barretto <joshua.s.barretto@gmail.com>
Date: Wed, 26 Jun 2019 11:24:53 +0100
Subject: [PATCH 13/16] Camera clipping and block-hop fix

---
 common/src/sys/phys.rs   | 2 +-
 voxygen/src/scene/mod.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/common/src/sys/phys.rs b/common/src/sys/phys.rs
index 9cb2504663..7e6b72a5eb 100644
--- a/common/src/sys/phys.rs
+++ b/common/src/sys/phys.rs
@@ -237,7 +237,7 @@ impl<'a> System<'a> for Sys {
                 if resolve_dir.z == 0.0
                     && !collision_with(pos.0 + Vec3::unit_z() * 1.1, near_iter.clone())
                 {
-                    pos.0.z += 1.0;
+                    pos.0.z = (pos.0.z + 1.0).ceil();
                     on_ground = true;
                     break;
                 } else {
diff --git a/voxygen/src/scene/mod.rs b/voxygen/src/scene/mod.rs
index 55fe9c7498..2a511d3a58 100644
--- a/voxygen/src/scene/mod.rs
+++ b/voxygen/src/scene/mod.rs
@@ -118,7 +118,7 @@ impl Scene {
         let tilt = self.camera.get_orientation().y;
         let dist = self.camera.get_distance();
         self.camera
-            .set_focus_pos(player_pos + Vec3::unit_z() * (2.1 - tilt.min(0.0) * dist * 0.75));
+            .set_focus_pos(player_pos + Vec3::unit_z() * (1.95 - tilt.min(0.0) * dist * 0.75));
 
         // Tick camera for interpolation.
         self.camera.update(client.state().get_time());

From 7b7d843d0ffff70ea04341d6bf33b52998d3a92c Mon Sep 17 00:00:00 2001
From: Joshua Barretto <joshua.s.barretto@gmail.com>
Date: Wed, 26 Jun 2019 11:50:55 +0100
Subject: [PATCH 14/16] Comments and fmt

---
 common/src/lib.rs           |  2 +-
 common/src/sys/phys.rs      | 56 ++++++++++++++++++++++++++-----------
 voxygen/src/scene/camera.rs |  9 +++---
 3 files changed, 45 insertions(+), 22 deletions(-)

diff --git a/common/src/lib.rs b/common/src/lib.rs
index 75d1064937..28d881aefa 100644
--- a/common/src/lib.rs
+++ b/common/src/lib.rs
@@ -1,4 +1,4 @@
-#![type_length_limit="1652471"]
+#![type_length_limit = "1652471"]
 #![feature(
     euclidean_division,
     duration_float,
diff --git a/common/src/sys/phys.rs b/common/src/sys/phys.rs
index 7e6b72a5eb..9cd91f716e 100644
--- a/common/src/sys/phys.rs
+++ b/common/src/sys/phys.rs
@@ -159,11 +159,9 @@ impl<'a> System<'a> for Sys {
             let player_rad = 0.3; // half-width of the player's AABB
             let player_height = 1.7;
 
-            let dist = 2;
+            let dist = 2; // distance to probe the terrain for collisions
             let near_iter = (-dist..=dist)
-                .map(move |i| (-dist..=dist)
-                    .map(move |j| (-dist..=dist)
-                        .map(move |k| (i, j, k))))
+                .map(move |i| (-dist..=dist).map(move |j| (-dist..=dist).map(move |k| (i, j, k))))
                 .flatten()
                 .flatten();
 
@@ -194,38 +192,57 @@ impl<'a> System<'a> for Sys {
                 false
             };
 
-            on_grounds.remove(entity);
+            on_grounds.remove(entity); // Assume we're in the air - unless we can prove otherwise
             pos.0.z -= 0.0001; // To force collision with the floor
 
             let mut on_ground = false;
-            let mut attempts = 0;
+            let mut attempts = 0; // Don't loop infinitely here
+
+            // While the player is colliding with the terrain...
             while collision_with(pos.0, near_iter.clone()) && attempts < 32 {
+                // Calculate the player's AABB
                 let player_aabb = Aabb {
                     min: pos.0 + Vec3::new(-player_rad, -player_rad, 0.0),
                     max: pos.0 + Vec3::new(player_rad, player_rad, player_height),
                 };
 
+                // Determine the block that we are colliding with most (based on minimum collision axis)
                 let (block_pos, block_aabb) = near_iter
                     .clone()
+                    // Calculate the block's position in world space
                     .map(|(i, j, k)| pos.0.map(|e| e.floor() as i32) + Vec3::new(i, j, k))
+                    // Calculate the AABB of the block
                     .map(|block_pos| {
-                        let block_aabb = Aabb {
-                            min: block_pos.map(|e| e as f32),
-                            max: block_pos.map(|e| e as f32) + 1.0,
-                        };
-
-                        (block_pos, block_aabb)
+                        (
+                            block_pos,
+                            Aabb {
+                                min: block_pos.map(|e| e as f32),
+                                max: block_pos.map(|e| e as f32) + 1.0,
+                            },
+                        )
                     })
+                    // Determine whether the block's AABB collides with the player's AABB
                     .filter(|(_, block_aabb)| block_aabb.collides_with_aabb(player_aabb))
-                    .filter(|(block_pos, _)| terrain
-                        .get(*block_pos)
-                        .map(|vox| !vox.is_empty())
-                        .unwrap_or(false))
-                    .max_by_key(|(_, block_aabb)| ((player_aabb.collision_vector_with_aabb(*block_aabb) / vel.0).map(|e| e.abs()).reduce_partial_min() * 1000.0) as i32)
+                    // Make sure the block is actually solid
+                    .filter(|(block_pos, _)| {
+                        terrain
+                            .get(*block_pos)
+                            .map(|vox| !vox.is_empty())
+                            .unwrap_or(false)
+                    })
+                    // Find the maximum of the minimum collision axes (this bit is weird, trust me that it works)
+                    .max_by_key(|(_, block_aabb)| {
+                        ((player_aabb.collision_vector_with_aabb(*block_aabb) / vel.0)
+                            .map(|e| e.abs())
+                            .reduce_partial_min()
+                            * 1000.0) as i32
+                    })
                     .expect("Collision detected, but no colliding blocks found!");
 
+                // Find the intrusion vector of the collision
                 let dir = player_aabb.collision_vector_with_aabb(block_aabb);
 
+                // Determine an appropriate resolution vector (i.e: the minimum distance needed to push out of the block)
                 let max_axis = dir.map(|e| e.abs()).reduce_partial_min();
                 let resolve_dir = -dir.map(|e| if e.abs() == max_axis { e } else { 0.0 });
 
@@ -234,13 +251,17 @@ impl<'a> System<'a> for Sys {
                     on_ground = true;
                 }
 
+                // When the resolution direction is non-vertical, we must be colliding with a wall
+                // If the space above is free...
                 if resolve_dir.z == 0.0
                     && !collision_with(pos.0 + Vec3::unit_z() * 1.1, near_iter.clone())
                 {
+                    // ...block-hop!
                     pos.0.z = (pos.0.z + 1.0).ceil();
                     on_ground = true;
                     break;
                 } else {
+                    // Resolve the collision normally
                     pos.0 += resolve_dir;
                     vel.0 = vel
                         .0
@@ -252,6 +273,7 @@ impl<'a> System<'a> for Sys {
 
             if on_ground {
                 on_grounds.insert(entity, OnGround);
+            // If we're not on the ground but the space below us is free, then "snap" to the ground
             } else if collision_with(pos.0 - Vec3::unit_z() * 1.0, near_iter.clone())
                 && vel.0.z < 0.0
                 && vel.0.z > -1.0
diff --git a/voxygen/src/scene/camera.rs b/voxygen/src/scene/camera.rs
index f8c76e5f3c..9e372dde9b 100644
--- a/voxygen/src/scene/camera.rs
+++ b/voxygen/src/scene/camera.rs
@@ -1,9 +1,9 @@
 use client::Client;
-use common::vol::ReadVol;
+use common::vol::{ReadVol, Vox};
 use std::f32::consts::PI;
 use vek::*;
 
-const NEAR_PLANE: f32 = 0.1;
+const NEAR_PLANE: f32 = 0.01;
 const FAR_PLANE: f32 = 10000.0;
 
 const INTERP_TIME: f32 = 0.1;
@@ -40,13 +40,13 @@ impl Camera {
     pub fn compute_dependents(&self, client: &Client) -> (Mat4<f32>, Mat4<f32>, Vec3<f32>) {
         let dist = {
             let (start, end) = (
-                self.focus,
                 self.focus
                     + (Vec3::new(
                         -f32::sin(self.ori.x) * f32::cos(self.ori.y),
                         -f32::cos(self.ori.x) * f32::cos(self.ori.y),
                         f32::sin(self.ori.y),
                     ) * self.dist),
+                self.focus,
             );
 
             match client
@@ -55,9 +55,10 @@ impl Camera {
                 .ray(start, end)
                 .ignore_error()
                 .max_iter(500)
+                .until(|b| b.is_empty())
                 .cast()
             {
-                (d, Ok(Some(_))) => f32::min(d - 1.0, self.dist),
+                (d, Ok(Some(_))) => f32::min(self.dist - d - 0.03, self.dist),
                 (_, Ok(None)) => self.dist,
                 (_, Err(_)) => self.dist,
             }

From 6c83edfc27d9f8f4ceae50e759c16c0a8abc8b74 Mon Sep 17 00:00:00 2001
From: Joshua Barretto <joshua.s.barretto@gmail.com>
Date: Wed, 26 Jun 2019 11:55:31 +0100
Subject: [PATCH 15/16] Don't fetch dt in figure.rs

---
 voxygen/src/scene/figure.rs | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

diff --git a/voxygen/src/scene/figure.rs b/voxygen/src/scene/figure.rs
index c2784a0673..fb35f50999 100644
--- a/voxygen/src/scene/figure.rs
+++ b/voxygen/src/scene/figure.rs
@@ -579,10 +579,7 @@ impl FigureMgr {
                             }
                         };
 
-                        state.skeleton.interpolate(
-                            &target_skeleton,
-                            client.state().ecs().read_resource::<DeltaTime>().0,
-                        );
+                        state.skeleton.interpolate(&target_skeleton, dt);
                         state.update(renderer, pos.0, ori.0, col, dt);
                     }
                     Body::Quadruped(_) => {
@@ -611,10 +608,7 @@ impl FigureMgr {
                             _ => state.skeleton_mut().clone(),
                         };
 
-                        state.skeleton.interpolate(
-                            &target_skeleton,
-                            client.state().ecs().read_resource::<DeltaTime>().0,
-                        );
+                        state.skeleton.interpolate(&target_skeleton, dt);
                         state.update(renderer, pos.0, ori.0, col, dt);
                     }
                     Body::QuadrupedMedium(_) => {
@@ -650,10 +644,7 @@ impl FigureMgr {
                             _ => state.skeleton_mut().clone(),
                         };
 
-                        state.skeleton.interpolate(
-                            &target_skeleton,
-                            client.state().ecs().read_resource::<DeltaTime>().0,
-                        );
+                        state.skeleton.interpolate(&target_skeleton, dt);
                         state.update(renderer, pos.0, ori.0, col, dt);
                     }
                 },

From 25b48b9cf678d9f345b84271e1f89e11d3718713 Mon Sep 17 00:00:00 2001
From: Joshua Barretto <joshua.s.barretto@gmail.com>
Date: Wed, 26 Jun 2019 17:22:28 +0100
Subject: [PATCH 16/16] Removed dt debugging in animation code

---
 voxygen/src/anim/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/voxygen/src/anim/mod.rs b/voxygen/src/anim/mod.rs
index a7b2e5e630..ab6618399f 100644
--- a/voxygen/src/anim/mod.rs
+++ b/voxygen/src/anim/mod.rs
@@ -31,7 +31,7 @@ impl Bone {
     /// Change the current bone to be more like `target`.
     fn interpolate(&mut self, target: &Bone, dt: f32) {
         // TODO: Make configurable.
-        let factor = dbg!((15.0 * dt).min(1.0));
+        let factor = (15.0 * dt).min(1.0);
         self.offset += (target.offset - self.offset) * factor;
         self.ori = vek::ops::Slerp::slerp(self.ori, target.ori, factor);
         self.scale += (target.scale - self.scale) * factor;