quake-rb 0.1.0 → 0.2.0

data/lib/quake/physics/player.rb

@@ -5,20 +5,41 @@ module Quake
     # Full Quake player physics: gravity, friction, acceleration, jumping,
     # ground detection, stair stepping, and swimming.
     class Player
-      attr_accessor :position, :velocity, :on_ground, :water_level, :noclip
+      attr_accessor :position, :velocity, :on_ground, :water_level, :water_type, :noclip, :gravity
+      attr_accessor :water_jump, :water_jump_movedir, :water_jump_time
+      attr_reader :jump_held
       attr_reader :yaw, :pitch
 
       # Quake constants
       GRAVITY       = 800.0    # units/sec^2
+      STOP_EPSILON  = 0.1
       FRICTION      = 4.0
+      EDGE_FRICTION = 2.0
       STOP_SPEED    = 100.0
       MAX_SPEED     = 320.0
+      MAX_VELOCITY  = 2000.0
+      FORWARD_SPEED = 200.0
+      BACK_SPEED    = 200.0
+      SIDE_SPEED    = 350.0
+      UP_SPEED      = 200.0
       ACCELERATE    = 10.0
-      AIR_ACCELERATE = 0.7
+      AIR_ACCELERATE = 10.0
       JUMP_SPEED    = 270.0
       STEP_SIZE     = 18.0
-      WATER_FRICTION = 1.0
+      WATER_FRICTION = 4.0
       WATER_ACCELERATE = 10.0
+      UNSTICK_DISTANCE = 2.0
+      MIN_UNSTICK_PROGRESS = 4.0
+      UNSTICK_DIRECTIONS = [
+        Math::Vec3.new(UNSTICK_DISTANCE, 0.0, 0.0),
+        Math::Vec3.new(0.0, UNSTICK_DISTANCE, 0.0),
+        Math::Vec3.new(-UNSTICK_DISTANCE, 0.0, 0.0),
+        Math::Vec3.new(0.0, -UNSTICK_DISTANCE, 0.0),
+        Math::Vec3.new(UNSTICK_DISTANCE, UNSTICK_DISTANCE, 0.0),
+        Math::Vec3.new(-UNSTICK_DISTANCE, UNSTICK_DISTANCE, 0.0),
+        Math::Vec3.new(UNSTICK_DISTANCE, -UNSTICK_DISTANCE, 0.0),
+        Math::Vec3.new(-UNSTICK_DISTANCE, -UNSTICK_DISTANCE, 0.0)
+      ].freeze
 
       # Camera
       SENSITIVITY   = 0.15
@@ -28,6 +49,16 @@ module Quake
       # Ground: surface normal Z must be > 0.7 (roughly < 45 degrees from horizontal)
       MIN_GROUND_NORMAL_Z = 0.7
 
+      # SV_FlyMove (sv_phys.c)
+      MAX_CLIP_PLANES = 5
+      CLIP_FLOOR = 1 << 0
+      CLIP_WALL  = 1 << 1
+      CLIP_STOP  = 1 << 2
+
+      # CheckWaterJump (client.qc)
+      WATER_JUMP_SPEED = 225.0
+      WATER_JUMP_TIME  = 2.0 # teleport_time safety net: time + 2
+
       def initialize(position:, yaw: 0.0)
         @position = position
         @velocity = Math::Vec3::ORIGIN
@@ -35,9 +66,14 @@ module Quake
         @pitch = 0.0
         @on_ground = false
         @water_level = 0 # 0=dry, 1=feet, 2=waist, 3=head
+        @water_type = CONTENTS_EMPTY
         @jump_held = false
         @noclip = false
+        @gravity = GRAVITY
         @ignore_mouse = 2
+        @water_jump = false
+        @water_jump_movedir = Math::Vec3::ORIGIN
+        @water_jump_time = 0.0
       end
 
       # Camera eye position (origin + view height)
@@ -64,23 +100,33 @@ module Quake
         end
 
         @brush_entities = brush_entities
+        check_velocity
         categorize_position(level)
 
         # Calculate wish direction from input
         wish_dir, wish_speed = compute_wish_velocity(keys)
 
-        if @water_level >= 2
+        # QuakeC PlayerPreThink: probe for a jump-out-of-water while swimming
+        check_water_jump(level) if @water_level == 2 && !@water_jump
+
+        if @water_jump
+          # SV_ClientThink short-circuits friction/accel while FL_WATERJUMP
+          # is set (sv_user.c:357-360); SV_Physics_Client skips gravity.
+          @water_jump_time -= dt
+          water_jump_move
+        elsif @water_level >= 2
           water_move(dt, wish_dir, wish_speed, keys, level)
         else
           # Apply gravity if not on ground and not in water
           unless @on_ground
             @velocity = Math::Vec3.new(@velocity.x, @velocity.y,
-                                       @velocity.z - GRAVITY * dt)
+                                       @velocity.z - @gravity * dt)
           end
 
-          # Handle jumping (SET vz, don't add - matches Quake's PM_AirMove)
+          # Handle jumping (QuakeC PlayerJump: velocity_z = velocity_z + 270)
           if @on_ground && keys[SDL::SCANCODE_SPACE] && !@jump_held
-            @velocity = Math::Vec3.new(@velocity.x, @velocity.y, JUMP_SPEED)
+            @velocity = Math::Vec3.new(@velocity.x, @velocity.y,
+                                       @velocity.z + JUMP_SPEED)
             @on_ground = false
             @jump_held = true
           end
@@ -122,6 +168,16 @@ module Quake
         Math::Vec3.new(::Math.cos(ry), ::Math.sin(ry), 0.0)
       end
 
+      def up
+        ry = deg2rad(@yaw)
+        rp = deg2rad(@pitch)
+        Math::Vec3.new(
+          ::Math.cos(ry) * ::Math.sin(rp),
+          ::Math.sin(ry) * ::Math.sin(rp),
+          ::Math.cos(rp)
+        )
+      end
+
       private
 
       def deg2rad(deg)
@@ -129,30 +185,72 @@ module Quake
       end
 
       def compute_wish_velocity(keys)
+        # SV_AirMove (sv_user.c): AngleVectors uses angles[PITCH] =
+        # -v_angle[PITCH] / 3, then wishvel[2] is forced to 0 for
+        # MOVETYPE_WALK.  Net effect: the forward contribution's horizontal
+        # magnitude scales by cos(pitch / 3); right stays flat (roll is 0).
+        fwd = forward_flat * ::Math.cos(deg2rad(@pitch / 3.0))
+
         wish = Math::Vec3::ORIGIN
-        wish = wish + forward_flat if keys[SDL::SCANCODE_W]
-        wish = wish - forward_flat if keys[SDL::SCANCODE_S]
-        wish = wish + right_flat if keys[SDL::SCANCODE_D]
-        wish = wish - right_flat if keys[SDL::SCANCODE_A]
+        wish = wish + fwd * FORWARD_SPEED if keys[SDL::SCANCODE_W]
+        wish = wish - fwd * BACK_SPEED if keys[SDL::SCANCODE_S]
+        wish = wish + right_flat * SIDE_SPEED if keys[SDL::SCANCODE_D]
+        wish = wish - right_flat * SIDE_SPEED if keys[SDL::SCANCODE_A]
 
         len = wish.length
         return [Math::Vec3::ORIGIN, 0.0] if len < 0.001
 
-        [wish.normalize, MAX_SPEED]
+        wish_speed = [len, MAX_SPEED].min
+        [wish.normalize, wish_speed]
+      end
+
+      def check_velocity
+        @position = Math::Vec3.new(
+          quake_checked_position_component(@position.x),
+          quake_checked_position_component(@position.y),
+          quake_checked_position_component(@position.z)
+        )
+        @velocity = Math::Vec3.new(
+          quake_checked_velocity_component(@velocity.x),
+          quake_checked_velocity_component(@velocity.y),
+          quake_checked_velocity_component(@velocity.z)
+        )
+      end
+
+      def quake_checked_position_component(value)
+        value.nan? ? 0.0 : value
+      end
+
+      def quake_checked_velocity_component(value)
+        return 0.0 if value.nan?
+
+        value.clamp(-MAX_VELOCITY, MAX_VELOCITY)
       end
 
       def apply_friction(dt, level)
         speed = ::Math.sqrt(@velocity.x**2 + @velocity.y**2)
-        return if speed < 1.0
+        return if speed.zero?
+
+        friction = FRICTION
+        if level
+          probe_x = @position.x + @velocity.x / speed * 16.0
+          probe_y = @position.y + @velocity.y / speed * 16.0
+          start = Math::Vec3.new(probe_x, probe_y, @position.z - 24.0)
+          stop = Math::Vec3.new(probe_x, probe_y, start.z - 34.0)
+          # SV_UserFriction uses SV_TraceLine (point trace, MOVE_NOMONSTERS):
+          # hull 0 against world + SOLID_BSP brush entities, not the box hull.
+          trace = trace_line(level, start, stop)
+          friction *= EDGE_FRICTION if trace.fraction == 1.0
+        end
 
         control = [speed, STOP_SPEED].max
-        drop = control * FRICTION * dt
+        drop = control * friction * dt
 
         new_speed = [speed - drop, 0.0].max / speed
         @velocity = Math::Vec3.new(
           @velocity.x * new_speed,
           @velocity.y * new_speed,
-          @velocity.z
+          @velocity.z * new_speed
         )
       end
 
@@ -176,75 +274,74 @@ module Quake
       end
 
       def water_move(dt, wish_dir, wish_speed, keys, level)
-        # Water friction
-        speed = @velocity.length
-        if speed > 0
-          new_speed = [speed - dt * speed * WATER_FRICTION * @water_level, 0.0].max
-          @velocity = @velocity * (new_speed / speed)
-        end
-
-        # Build wish velocity from horizontal input + vertical keys
-        has_horizontal = wish_speed > 0.001
-        has_up = keys[SDL::SCANCODE_SPACE]
-        has_down = keys[SDL::SCANCODE_C]
-
-        # Use forward direction including pitch when swimming
+        # WinQuake SV_WaterMove builds a full wish velocity first, then
+        # applies water friction and accelerates toward that wish velocity.
         swim_wish = Math::Vec3::ORIGIN
         if keys[SDL::SCANCODE_W]
-          swim_wish = swim_wish + forward
+          swim_wish = swim_wish + forward * FORWARD_SPEED
         end
         if keys[SDL::SCANCODE_S]
-          swim_wish = swim_wish - forward
+          swim_wish = swim_wish - forward * BACK_SPEED
         end
         if keys[SDL::SCANCODE_D]
-          swim_wish = swim_wish + right
+          swim_wish = swim_wish + right * SIDE_SPEED
         end
         if keys[SDL::SCANCODE_A]
-          swim_wish = swim_wish - right
+          swim_wish = swim_wish - right * SIDE_SPEED
+        end
+
+        if swim_wish == Math::Vec3::ORIGIN && !keys[SDL::SCANCODE_SPACE] && !keys[SDL::SCANCODE_C]
+          swim_wish = Math::Vec3.new(0.0, 0.0, -60.0)
+        else
+          swim_wish = Math::Vec3.new(swim_wish.x, swim_wish.y, swim_wish.z + UP_SPEED) if keys[SDL::SCANCODE_SPACE]
+          swim_wish = Math::Vec3.new(swim_wish.x, swim_wish.y, swim_wish.z - UP_SPEED) if keys[SDL::SCANCODE_C]
         end
 
-        # Vertical movement
-        if has_up
-          swim_wish = Math::Vec3.new(swim_wish.x, swim_wish.y, swim_wish.z + 1.0)
-        elsif has_down
-          swim_wish = Math::Vec3.new(swim_wish.x, swim_wish.y, swim_wish.z - 1.0)
+        wish_len = swim_wish.length
+        if wish_len > MAX_SPEED
+          swim_wish = swim_wish * (MAX_SPEED / wish_len)
+          wish_len = MAX_SPEED
         end
+        wish_speed2 = wish_len * 0.7
 
-        swim_len = swim_wish.length
-        if swim_len < 0.001
-          # No input at all: drift down slowly
-          @velocity = Math::Vec3.new(@velocity.x, @velocity.y, @velocity.z - 60.0 * dt)
-          return
+        speed = @velocity.length
+        new_speed = 0.0
+        if speed.positive?
+          new_speed = [speed - dt * speed * WATER_FRICTION, 0.0].max
+          @velocity = @velocity * (new_speed / speed)
         end
 
+        return if wish_speed2.zero?
+
+        add_speed = wish_speed2 - new_speed
+        return if add_speed <= 0
+
         wish_dir2 = swim_wish.normalize
-        wish_spd = MAX_SPEED * 0.7 # water reduces max speed to 70%
-        accelerate(wish_dir2, wish_spd, WATER_ACCELERATE, dt)
+        accel_speed = [WATER_ACCELERATE * wish_speed2 * dt, add_speed].min
+        @velocity = @velocity + wish_dir2 * accel_speed
       end
 
       def categorize_position(level)
-        # Check ground: trace 1 unit down against world + brush entities
-        if @velocity.z > 180
-          @on_ground = false
-        else
-          trace_start = @position
-          trace_end = Math::Vec3.new(@position.x, @position.y, @position.z - 1.0)
-          result = HullTrace.trace_world_and_entities(
-            level, trace_start, trace_end, @brush_entities
-          )
-
-          if result.fraction < 1.0 && result.plane_normal &&
-             result.plane_normal.z >= MIN_GROUND_NORMAL_Z
-            @on_ground = true
-            @position = result.end_pos if !result.start_solid && !result.all_solid
-            # Zero out negative z velocity when grounded (matches Quake's
-            # PM_CategorizePosition: pmove.velocity[2] = 0)
-            if @velocity.z < 0
-              @velocity = Math::Vec3.new(@velocity.x, @velocity.y, 0.0)
-            end
-          else
-            @on_ground = false
+        # Check ground: trace 1 unit down against world + brush entities.
+        # NQ has no "vz > 180 means airborne" rule (that is QuakeWorld
+        # prediction); ground state comes from the down trace alone.
+        trace_start = @position
+        trace_end = Math::Vec3.new(@position.x, @position.y, @position.z - 1.0)
+        result = HullTrace.trace_world_and_entities(
+          level, trace_start, trace_end, @brush_entities
+        )
+
+        if result.fraction < 1.0 && result.plane_normal &&
+           result.plane_normal.z > MIN_GROUND_NORMAL_Z
+          @on_ground = true
+          @position = result.end_pos if !result.start_solid && !result.all_solid
+          # Zero out negative z velocity when grounded (matches Quake's
+          # PM_CategorizePosition: pmove.velocity[2] = 0)
+          if @velocity.z < 0
+            @velocity = Math::Vec3.new(@velocity.x, @velocity.y, 0.0)
           end
+        else
+          @on_ground = false
         end
 
         # Check water level using BSP leaf contents (not clipnodes).
@@ -278,79 +375,279 @@ module Quake
         leaf ? leaf.contents : CONTENTS_EMPTY
       end
 
+      # SV_WalkMove (sv_phys.c:887-990)
       def walk_move(dt, level)
-        # Desired new position
-        desired = @position + @velocity * dt
+        # Do a regular slide move unless it looks like you ran into a step.
+        # C clears FL_ONGROUND here and relies on the always-applied gravity
+        # to press the player into the floor so SV_FlyMove re-sets it every
+        # frame.  This port skips gravity while grounded, so ground state is
+        # re-derived by categorize_position instead of cleared here.
+        old_on_ground = @on_ground
+
+        old_position = @position
+        old_velocity = @velocity
+
+        clip = fly_move(dt, level)
+        return if (clip & CLIP_WALL).zero?
+
+        # Don't stair up while jumping
+        return if !old_on_ground && @water_level.zero?
+        # Don't stair up while water jumping
+        return if @water_jump
+
+        no_step_position = @position
+        no_step_velocity = @velocity
+
+        # Try moving up and forward to go up a step
+        @position = old_position
+        up_trace = trace_move(level, @position,
+                              Math::Vec3.new(@position.x, @position.y, @position.z + STEP_SIZE))
+        @position = up_trace.end_pos
+
+        # Move forward (full fly move, sv_phys.c:944)
+        @velocity = Math::Vec3.new(old_velocity.x, old_velocity.y, 0.0)
+        clip = fly_move(dt, level)
+        step_trace = @step_trace
+
+        # Check for stuckness, possibly due to the limited precision of
+        # floats in the clipping hulls
+        if clip != 0 &&
+           (old_position.y - @position.y).abs < DIST_EPSILON &&
+           (old_position.x - @position.x).abs < DIST_EPSILON
+          # Stepping up didn't make any progress
+          clip = try_unstick(level, old_velocity)
+        end
 
-        # Trace against world + brush entities
-        result = trace_move(level, @position, desired)
+        # Extra friction based on view angle
+        if (clip & CLIP_WALL) != 0 && step_trace&.plane_normal
+          apply_wall_friction(step_trace.plane_normal)
+        end
 
-        return if result.all_solid # stuck
+        # Move down
+        step_down = Math::Vec3.new(@position.x, @position.y,
+                                   @position.z - STEP_SIZE + old_velocity.z * dt)
+        down_trace = trace_move(level, @position, step_down)
+        @position = down_trace.end_pos
 
-        if result.fraction == 1.0
-          @position = desired
+        if down_trace.fraction < 1.0 && down_trace.plane_normal &&
+           down_trace.plane_normal.z > MIN_GROUND_NORMAL_Z
+          @on_ground = true
           return
         end
 
-        # Hit something. Try stair stepping.
-        contact = result.end_pos
+        # If the push down didn't end up on good ground, use the move
+        # without the step up
+        @position = no_step_position
+        @velocity = no_step_velocity
+      end
 
-        # Step up
-        step_up = Math::Vec3.new(contact.x, contact.y, contact.z + STEP_SIZE)
-        up_trace = trace_move(level, contact, step_up)
-        raised = up_trace.end_pos
+      # SV_FlyMove (sv_phys.c:266-394): the basic solid body movement clip
+      # that slides along multiple planes.  Returns CLIP_* blocked flags,
+      # sets @on_ground on floor hits, and stores the last wall hit in
+      # @step_trace for SV_WallFriction.
+      def fly_move(dt, level)
+        blocked = 0
+        original_velocity = @velocity
+        primal_velocity = @velocity
+        planes = []
+        time_left = dt
+        @step_trace = nil
+
+        4.times do
+          break if @velocity == Math::Vec3::ORIGIN
+
+          desired = @position + @velocity * time_left
+          trace = trace_move(level, @position, desired)
+
+          if trace.all_solid
+            # Entity is trapped in another solid
+            @velocity = Math::Vec3::ORIGIN
+            return CLIP_FLOOR | CLIP_WALL
+          end
 
-        # Move forward from raised position
-        step_forward = Math::Vec3.new(desired.x, desired.y, raised.z)
-        forward_trace = trace_move(level, raised, step_forward)
-        forward_pos = forward_trace.end_pos
+          if trace.fraction.positive?
+            # Actually covered some distance
+            @position = trace.end_pos
+            original_velocity = @velocity
+            planes.clear
+          end
 
-        # Step back down
-        step_down = Math::Vec3.new(forward_pos.x, forward_pos.y, forward_pos.z - STEP_SIZE)
-        down_trace = trace_move(level, forward_pos, step_down)
+          # Moved the entire distance
+          break if trace.fraction == 1.0
 
-        if down_trace.fraction < 1.0 && down_trace.plane_normal &&
-           down_trace.plane_normal.z >= MIN_GROUND_NORMAL_Z
-          @position = down_trace.end_pos
-          return
+          normal = trace.plane_normal
+          break unless normal
+
+          if normal.z > MIN_GROUND_NORMAL_Z
+            blocked |= CLIP_FLOOR
+            @on_ground = true
+          end
+          if normal.z.zero?
+            blocked |= CLIP_WALL
+            # Save for player extrafriction
+            @step_trace = trace
+          end
+
+          time_left -= time_left * trace.fraction
+
+          # Clipped to another plane
+          if planes.size >= MAX_CLIP_PLANES
+            # This shouldn't really happen...
+            @velocity = Math::Vec3::ORIGIN
+            return CLIP_FLOOR | CLIP_WALL
+          end
+          planes << normal
+
+          # Modify original_velocity so it parallels all of the clip planes
+          new_velocity = nil
+          index = planes.size
+          planes.each_with_index do |plane, i|
+            new_velocity = clip_velocity(original_velocity, plane)
+            ok = planes.each_with_index.all? do |other, j|
+              j == i || new_velocity.dot(other) >= 0
+            end
+            if ok
+              index = i
+              break
+            end
+          end
+
+          if index < planes.size
+            # Go along this plane
+            @velocity = new_velocity
+          else
+            # Go along the crease
+            if planes.size != 2
+              @velocity = Math::Vec3::ORIGIN
+              return CLIP_FLOOR | CLIP_WALL | CLIP_STOP
+            end
+            dir = planes[0].cross(planes[1])
+            @velocity = dir * dir.dot(@velocity)
+          end
+
+          # If velocity is against the original velocity, stop dead to
+          # avoid tiny oscillations in sloping corners
+          if @velocity.dot(primal_velocity) <= 0
+            @velocity = Math::Vec3::ORIGIN
+            return blocked
+          end
         end
 
-        # Step didn't work - slide along the wall
-        @position = contact
-        slide_along_wall(result, dt, level)
+        blocked
+      end
+
+      # SV_TryUnstick (sv_phys.c:795-874): push one pixel in each direction
+      # and retry the move; hack around limited float precision in the hulls.
+      def try_unstick(level, old_velocity)
+        old_position = @position
+
+        UNSTICK_DIRECTIONS.each do |dir|
+          push_trace = trace_move(level, @position, @position + dir)
+          @position = push_trace.end_pos
+
+          # Retry the original move
+          @velocity = Math::Vec3.new(old_velocity.x, old_velocity.y, 0.0)
+          clip = fly_move(0.1, level)
+
+          if (old_position.y - @position.y).abs > MIN_UNSTICK_PROGRESS ||
+             (old_position.x - @position.x).abs > MIN_UNSTICK_PROGRESS
+            return clip
+          end
+
+          # Go back to the original pos and try again
+          @position = old_position
+        end
+
+        # Still can't move
+        @velocity = Math::Vec3::ORIGIN
+        CLIP_FLOOR | CLIP_WALL | CLIP_STOP
       end
 
       def trace_move(level, from, to)
         HullTrace.trace_world_and_entities(level, from, to, @brush_entities)
       end
 
-      def slide_along_wall(trace_result, dt, level)
-        normal = trace_result.plane_normal
-        return unless normal
+      # SV_TraceLine with MOVE_NOMONSTERS: point (hull 0) trace against the
+      # world and SOLID_BSP brush entities only.
+      def trace_line(level, from, to)
+        HullTrace.trace_world_and_entities(level, from, to, @brush_entities, hull_num: 0)
+      end
 
-        backoff = @velocity.dot(normal)
-        @velocity = Math::Vec3.new(
-          @velocity.x - normal.x * backoff,
-          @velocity.y - normal.y * backoff,
-          @velocity.z - normal.z * backoff
+      # QuakeC CheckWaterJump (client.qc): when swimming against a wall
+      # that is open at eye level, boost out of the water.
+      def check_water_jump(level)
+        return unless level
+
+        fwd = forward_flat
+
+        # Check for a jump-out-of-water: solid at waist?
+        start = Math::Vec3.new(@position.x, @position.y, @position.z + 8.0)
+        waist_trace = trace_line(level, start, start + fwd * 24.0)
+        return unless waist_trace.fraction < 1.0 && waist_trace.plane_normal
+
+        # self.movedir = trace_plane_normal * -50
+        @water_jump_movedir = waist_trace.plane_normal * -50.0
+
+        # Open at eye level? (start_z accumulates: origin + 8 + maxs_z - 8)
+        eye_start = Math::Vec3.new(@position.x, @position.y, @position.z + 32.0)
+        eye_trace = trace_line(level, eye_start, eye_start + fwd * 24.0)
+        return unless eye_trace.fraction == 1.0
+
+        @water_jump = true
+        @velocity = Math::Vec3.new(@velocity.x, @velocity.y, WATER_JUMP_SPEED)
+        @water_jump_time = WATER_JUMP_TIME
+      end
+
+      # SV_WaterJump (sv_user.c:264-273): while FL_WATERJUMP is set, force
+      # horizontal velocity from movedir every frame; clear the flag once
+      # out of water or past the safety-net time.
+      def water_jump_move
+        if @water_jump_time <= 0.0 || @water_level.zero?
+          @water_jump = false
+          @water_jump_time = 0.0
+        end
+        @velocity = Math::Vec3.new(@water_jump_movedir.x, @water_jump_movedir.y,
+                                   @velocity.z)
+      end
+
+      def clip_velocity(velocity, normal)
+        backoff = velocity.dot(normal)
+        Math::Vec3.new(
+          stop_epsilon_component(velocity.x - normal.x * backoff),
+          stop_epsilon_component(velocity.y - normal.y * backoff),
+          stop_epsilon_component(velocity.z - normal.z * backoff)
         )
+      end
+
+      def stop_epsilon_component(value)
+        value > -STOP_EPSILON && value < STOP_EPSILON ? 0.0 : value
+      end
 
-        remaining = @velocity * (dt * (1.0 - trace_result.fraction))
-        desired = @position + remaining
-        result = trace_move(level, @position, desired)
-        @position = result.end_pos
+      def apply_wall_friction(normal)
+        d = normal.dot(forward) + 0.5
+        return if d >= 0
+
+        into = normal * normal.dot(@velocity)
+        side = @velocity - into
+        @velocity = Math::Vec3.new(side.x * (1.0 + d), side.y * (1.0 + d), @velocity.z)
       end
 
       def noclip_move(dt, keys)
         wish = Math::Vec3::ORIGIN
-        wish = wish + forward if keys[SDL::SCANCODE_W]
-        wish = wish - forward if keys[SDL::SCANCODE_S]
-        wish = wish + right if keys[SDL::SCANCODE_D]
-        wish = wish - right if keys[SDL::SCANCODE_A]
-        wish = wish + Math::Vec3.new(0.0, 0.0, 1.0) if keys[SDL::SCANCODE_SPACE]
-        wish = wish - Math::Vec3.new(0.0, 0.0, 1.0) if keys[SDL::SCANCODE_C]
-
-        @position = @position + wish * (MAX_SPEED * dt)
+        wish = wish + forward_flat * FORWARD_SPEED if keys[SDL::SCANCODE_W]
+        wish = wish - forward_flat * BACK_SPEED if keys[SDL::SCANCODE_S]
+        wish = wish + right_flat * SIDE_SPEED if keys[SDL::SCANCODE_D]
+        wish = wish - right_flat * SIDE_SPEED if keys[SDL::SCANCODE_A]
+        wish = wish + Math::Vec3.new(0.0, 0.0, UP_SPEED) if keys[SDL::SCANCODE_SPACE]
+        wish = wish - Math::Vec3.new(0.0, 0.0, UP_SPEED) if keys[SDL::SCANCODE_C]
+
+        wish_len = wish.length
+        if wish_len > MAX_SPEED
+          wish = wish * (MAX_SPEED / wish_len)
+        end
+
+        @velocity = wish
+        @position = @position + @velocity * dt
       end
     end
   end