doom 0.8.0 → 0.11.0

data/lib/doom/game/player_physics.rb

@@ -0,0 +1,384 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # Player movement and vertical physics, extracted from the Gosu window
+    # so it can be unit-tested without a graphics stack.
+    #
+    # Tracks the player's feet position (floor_z) and vertical velocity (momz)
+    # in DOOM map units, matching Chocolate Doom's P_ZMovement semantics:
+    # GRAVITY=1 unit/tic^2, falls clamp to floor, viewheight squat on landing.
+    class PlayerPhysics
+      PLAYER_RADIUS = 16.0
+
+      MAX_STEP_UP = 24
+      MIN_HEADROOM = 56
+
+      GRAVITY = 1.0
+      INITIAL_FALL_MOMZ = -2.0       # First-tic kick when momz==0 (P_ZMovement uses -GRAVITY*2)
+      FALL_IMPACT_THRESHOLD = -8.0   # momz < -GRAVITY*8 triggers viewheight squat
+
+      TICRATE = 35.0
+
+      # Horizontal movement runs per-tic, not per-frame. A frame-rate-dependent
+      # integration can never be deterministic, and lockstep needs every peer to
+      # get the same result from the same ticcmd.
+      #
+      # FRICTION is DOOM's exact per-tic value (ORIG_FRICTION 0xE800/65536).
+      # Momentum is carried in units/sec, so THRUST_PER_TIC is chosen to hold
+      # the same terminal speed the old continuous model had:
+      #   v_terminal = thrust * FRICTION / (1 - FRICTION)
+      FRICTION = 0.90625
+      TERMINAL_SPEED = 264.0                                            # units/sec
+      THRUST_PER_TIC = TERMINAL_SPEED * (1.0 - FRICTION) / FRICTION     # ~27.3
+      SIDE_THRUST_SCALE = 0.8      # DOOM strafes slower than it walks
+      STOPSPEED = 0.5              # Snap-to-zero threshold (units/sec)
+
+      # Solid thing types with their collision radii (from mobjinfo[] MF_SOLID).
+      SOLID_THING_RADIUS = {
+        9 => 20, 65 => 20, 66 => 20, 67 => 20, 68 => 20, # Shotgun Guy variants
+        3004 => 20, 84 => 20,                            # Zombieman
+        3001 => 20,                                       # Imp
+        3002 => 30, 58 => 30,                             # Demon, Spectre
+        3003 => 24, 69 => 24,                             # Baron, Hell Knight
+        3006 => 16,                                       # Lost Soul
+        3005 => 31,                                       # Cacodemon
+        16 => 40,                                         # Cyberdemon
+        7 => 128,                                         # Spider Mastermind
+        64 => 20,                                         # Archvile
+        71 => 31,                                         # Pain Elemental
+        2035 => 10,                                       # Barrel
+        2028 => 16,                                       # Tall lamp
+        48 => 16, 30 => 16, 32 => 16,                     # Tech column, green/red pillars
+        31 => 16, 33 => 16, 36 => 16,                     # Short pillars
+        41 => 16, 43 => 16,                               # Evil eye, burnt tree
+        54 => 32,                                         # Brown tree
+        44 => 16, 45 => 16, 46 => 16,                     # Tall torches
+        55 => 16, 56 => 16, 57 => 16,                     # Short torches
+        47 => 16, 70 => 16,                               # Stubs
+        85 => 16, 86 => 16,                               # Tall tech lamps
+        2046 => 16 # Burning barrel
+      }.freeze
+
+      attr_reader :floor_z, :momz
+      attr_writer :skill_hidden, :item_pickup, :combat
+
+      def initialize(map, player_state)
+        @map = map
+        @player_state = player_state
+        @floor_z = nil
+        @momz = 0.0
+        @skill_hidden = {}
+        @item_pickup = nil
+        @combat = nil
+      end
+
+      def reset
+        @floor_z = nil
+        @momz = 0.0
+      end
+
+      # Eye position used by the renderer: feet + viewheight + view-bob.
+      # Returns nil before the first settle_at.
+      def eye_z
+        return nil unless @floor_z
+
+        if @player_state
+          @floor_z + @player_state.viewheight + @player_state.view_bob_offset
+        else
+          @floor_z + PlayerState::VIEWHEIGHT
+        end
+      end
+
+      # Bring the player onto the floor at (x, y) after a horizontal move.
+      # Snaps up for step-up (gated to <= MAX_STEP_UP by valid_move?), leaves
+      # @floor_z alone for step-down so per-tic gravity can drop the player.
+      def settle_at(x, y)
+        sector = @map.sector_at(x, y)
+        return unless sector
+
+        new_floor = sector.floor_height
+
+        if @player_state
+          @floor_z ||= new_floor
+          if new_floor > @floor_z
+            step = new_floor - @floor_z
+            @player_state.notify_step(step) if step.abs <= MAX_STEP_UP
+            @floor_z = new_floor
+            @momz = 0.0
+          end
+        else
+          @floor_z = new_floor
+        end
+      end
+
+      # Per-tic vertical movement. Mutates @floor_z and @momz; calls
+      # player_state.notify_step / apply_fall_impact as needed.
+      def step(x, y)
+        return unless @player_state && @floor_z
+
+        sector = @map.sector_at(x, y)
+        return unless sector
+
+        ground = sector.floor_height
+
+        if @floor_z > ground
+          @momz = (@momz == 0.0 ? INITIAL_FALL_MOMZ : @momz - GRAVITY)
+          @floor_z += @momz
+          if @floor_z <= ground
+            impact_momz = @momz
+            @floor_z = ground
+            @momz = 0.0
+            @player_state.apply_fall_impact(impact_momz) if impact_momz < FALL_IMPACT_THRESHOLD
+          end
+        elsif @floor_z < ground
+          # Floor rose under player (lift, raising sector)
+          step_amount = ground - @floor_z
+          @player_state.notify_step(step_amount) if step_amount.abs <= MAX_STEP_UP
+          @floor_z = ground
+          @momz = 0.0
+        end
+      end
+
+      # Advance one player by one tic from its ticcmd: turn, thrust, friction,
+      # then move with wall sliding. This is the whole horizontal simulation,
+      # and it is a pure function of (player, cmd, map) -- no wall clock, no
+      # frame rate, no Kernel#rand. That is what makes lockstep possible.
+      def run_tic(player, cmd)
+        player.turn(cmd.angleturn) if cmd.angleturn != 0.0
+
+        if cmd.forwardmove != 0.0
+          thrust = cmd.forwardmove * THRUST_PER_TIC
+          player.momx += player.cos_angle * thrust
+          player.momy += player.sin_angle * thrust
+        end
+
+        if cmd.sidemove != 0.0
+          thrust = cmd.sidemove * THRUST_PER_TIC * SIDE_THRUST_SCALE
+          # Strafe right is 90 degrees clockwise from facing.
+          player.momx += player.sin_angle * thrust
+          player.momy -= player.cos_angle * thrust
+        end
+
+        if !cmd.moving? && player.momx.abs < STOPSPEED && player.momy.abs < STOPSPEED
+          player.momx = 0.0
+          player.momy = 0.0
+        else
+          player.momx *= FRICTION
+          player.momy *= FRICTION
+        end
+
+        return unless player.momx.abs > STOPSPEED || player.momy.abs > STOPSPEED
+
+        move(player, player.momx / TICRATE, player.momy / TICRATE)
+      end
+
+      # Move a player by (dx, dy) with collision and wall sliding, settling it
+      # onto the floor wherever it ends up.
+      def move(player, dx, dy)
+        old_x = player.x
+        old_y = player.y
+        new_x = old_x + dx
+        new_y = old_y + dy
+
+        if valid_move?(old_x, old_y, new_x, new_y)
+          player.move_to(new_x, new_y)
+          settle(player, new_x, new_y)
+          return
+        end
+
+        # Wall sliding: project movement along the blocking wall
+        slide_x, slide_y = compute_slide(old_x, old_y, dx, dy)
+        if slide_x && (slide_x != 0.0 || slide_y != 0.0)
+          sx = old_x + slide_x
+          sy = old_y + slide_y
+          if valid_move?(old_x, old_y, sx, sy)
+            player.move_to(sx, sy)
+            settle(player, sx, sy)
+            scale = [dx.abs, dy.abs].max.nonzero? || 1
+            player.momx = slide_x / scale * player.momx.abs
+            player.momy = slide_y / scale * player.momy.abs
+            return
+          end
+        end
+
+        # Fallback: try axis-aligned sliding
+        if dx != 0.0 && valid_move?(old_x, old_y, new_x, old_y)
+          player.move_to(new_x, old_y)
+          settle(player, new_x, old_y)
+          player.momy = 0.0
+        elsif dy != 0.0 && valid_move?(old_x, old_y, old_x, new_y)
+          player.move_to(old_x, new_y)
+          settle(player, old_x, new_y)
+          player.momx = 0.0
+        else
+          player.momx = 0.0
+          player.momy = 0.0
+        end
+      end
+
+      # Settle onto the floor and push the resulting eye height to the player.
+      def settle(player, x, y)
+        settle_at(x, y)
+        z = eye_z
+        player.z = z if z
+      end
+
+      # When valid_move? fails, find the nearest blocking wall and return a
+      # slide vector projected along it. Returns nil if no wall blocks.
+      def compute_slide(px, py, dx, dy)
+        best_wall = nil
+        best_dist = Float::INFINITY
+
+        each_nearby_linedef(px, py, px + dx, py + dy) do |linedef|
+          v1 = @map.vertices[linedef.v1]
+          v2 = @map.vertices[linedef.v2]
+
+          next unless Geometry.line_circle_intersect?(v1.x, v1.y, v2.x, v2.y, px + dx, py + dy, PLAYER_RADIUS)
+          next unless linedef_blocks?(linedef, px, py, px + dx, py + dy) ||
+                      crosses_blocking_linedef?(px, py, px + dx, py + dy, linedef)
+
+          dist = Geometry.point_to_segment_distance(px, py, v1.x, v1.y, v2.x, v2.y)
+          if dist < best_dist
+            best_dist = dist
+            best_wall = linedef
+          end
+        end
+
+        return nil unless best_wall
+
+        v1 = @map.vertices[best_wall.v1]
+        v2 = @map.vertices[best_wall.v2]
+        wall_dx = (v2.x - v1.x).to_f
+        wall_dy = (v2.y - v1.y).to_f
+        wall_len = Math.sqrt((wall_dx * wall_dx) + (wall_dy * wall_dy))
+        return nil if wall_len == 0
+
+        wall_dx /= wall_len
+        wall_dy /= wall_len
+        dot = (dx * wall_dx) + (dy * wall_dy)
+        [dot * wall_dx, dot * wall_dy]
+      end
+
+      # True if the player can occupy (new_x, new_y). Step-up is capped at
+      # MAX_STEP_UP from the player's current floor; step-down is unlimited.
+      def valid_move?(old_x, old_y, new_x, new_y)
+        sector = @map.sector_at(new_x, new_y)
+        return false unless sector
+
+        current_floor = @floor_z || sector.floor_height
+        return false if sector.floor_height - current_floor > MAX_STEP_UP
+
+        each_nearby_linedef(old_x, old_y, new_x, new_y) do |linedef|
+          return false if linedef_blocks?(linedef, old_x, old_y, new_x, new_y)
+          return false if crosses_blocking_linedef?(old_x, old_y, new_x, new_y, linedef)
+        end
+
+        return false if collides_with_solid_thing?(new_x, new_y)
+
+        true
+      end
+
+      private
+
+      # Iterate linedefs that may interact with the player moving from
+      # (x1, y1) to (x2, y2). Uses BLOCKMAP when available; otherwise falls
+      # back to scanning all linedefs.
+      def each_nearby_linedef(x1, y1, x2, y2, &)
+        unless @map.respond_to?(:blockmap_loaded?) && @map.blockmap_loaded?
+          @map.linedefs.each(&)
+          return
+        end
+
+        # Pad the bbox by player radius so walls just outside still register.
+        min_x = [x1, x2].min - PLAYER_RADIUS
+        max_x = [x1, x2].max + PLAYER_RADIUS
+        min_y = [y1, y2].min - PLAYER_RADIUS
+        max_y = [y1, y2].max + PLAYER_RADIUS
+        @map.each_linedef_near(min_x, min_y, max_x, max_y, &)
+      end
+
+      def crosses_blocking_linedef?(x1, y1, x2, y2, linedef)
+        v1 = @map.vertices[linedef.v1]
+        v2 = @map.vertices[linedef.v2]
+
+        return Geometry.segments_intersect?(x1, y1, x2, y2, v1.x, v1.y, v2.x, v2.y) if linedef.sidedef_left == 0xFFFF
+
+        if (linedef.flags & 0x0001) != 0 # ML_BLOCKING
+          return Geometry.segments_intersect?(x1, y1, x2, y2, v1.x, v1.y, v2.x, v2.y)
+        end
+
+        front_sector = sector_for_side(linedef.sidedef_right)
+        back_sector = sector_for_side(linedef.sidedef_left)
+
+        min_ceiling = [front_sector.ceiling_height, back_sector.ceiling_height].min
+        max_floor = [front_sector.floor_height, back_sector.floor_height].max
+        current_floor = @floor_z || front_sector.floor_height
+        step_up = max_floor - current_floor
+
+        return false if step_up <= MAX_STEP_UP && (min_ceiling - max_floor) >= MIN_HEADROOM
+
+        Geometry.segments_intersect?(x1, y1, x2, y2, v1.x, v1.y, v2.x, v2.y)
+      end
+
+      def linedef_blocks?(linedef, old_x, old_y, new_x, new_y)
+        v1 = @map.vertices[linedef.v1]
+        v2 = @map.vertices[linedef.v2]
+
+        return false unless Geometry.line_circle_intersect?(v1.x, v1.y, v2.x, v2.y, new_x, new_y, PLAYER_RADIUS)
+
+        impassable =
+          if linedef.sidedef_left == 0xFFFF
+            true
+          else
+            # ML_BLOCKING on two-sided lines is handled by crosses_blocking_linedef?
+            # (a proximity check would block the player when standing near, not
+            # just crossing).
+            front_sector = sector_for_side(linedef.sidedef_right)
+            back_sector = sector_for_side(linedef.sidedef_left)
+
+            min_ceiling = [front_sector.ceiling_height, back_sector.ceiling_height].min
+            max_floor = [front_sector.floor_height, back_sector.floor_height].max
+            current_floor = @floor_z || front_sector.floor_height
+            step_up = max_floor - current_floor
+
+            step_up > MAX_STEP_UP || (min_ceiling - max_floor) < MIN_HEADROOM
+          end
+        return false unless impassable
+
+        # The circle overlaps an impassable wall at the destination. Block the
+        # move only if it does not increase the distance to that wall, so a body
+        # that is already overlapping one -- e.g. after landing from a fall at
+        # the base of a tall step, where the airborne slide let the radius graze
+        # the ledge -- can still move away and unstick, but can never push
+        # further in or climb the step. A normal head-on approach still stops at
+        # radius; sliding parallel (equal distance) is still allowed.
+        d_new = Geometry.point_to_segment_distance(new_x, new_y, v1.x, v1.y, v2.x, v2.y)
+        d_old = Geometry.point_to_segment_distance(old_x, old_y, v1.x, v1.y, v2.x, v2.y)
+        d_new < d_old
+      end
+
+      def collides_with_solid_thing?(x, y)
+        picked = @item_pickup&.picked_up
+        @map.things.each_with_index do |thing, idx|
+          next if @skill_hidden[idx]
+          next if picked && picked[idx]
+          next if @combat && @combat.dead?(idx)
+
+          thing_radius = SOLID_THING_RADIUS[thing.type]
+          next unless thing_radius
+
+          dx = x - thing.x
+          dy = y - thing.y
+          min_dist = PLAYER_RADIUS + thing_radius
+          return true if (dx * dx) + (dy * dy) < min_dist * min_dist
+        end
+        false
+      end
+
+      def sector_for_side(side_idx)
+        @map.sectors[@map.sidedefs[side_idx].sector]
+      end
+    end
+  end
+end

data/lib/doom/game/player_state.rb

@@ -36,25 +36,14 @@ module Doom
         WEAPON_PLASMA => 8,      # Fast energy weapon
         WEAPON_BFG => 60,        # Long charge + fire
         WEAPON_CHAINSAW => 6     # Fast melee
-      }.freeze
-
-      attr_accessor :health, :armor, :max_health, :max_armor
-      attr_accessor :ammo_bullets, :ammo_shells, :ammo_rockets, :ammo_cells
-      attr_accessor :max_bullets, :max_shells, :max_rockets, :max_cells
-      attr_accessor :weapon, :has_weapons
-      attr_accessor :keys
-      attr_accessor :attacking, :attack_frame, :attack_tics
-      attr_accessor :bob_angle, :bob_amount
-      attr_accessor :is_moving
-      attr_accessor :dead, :death_tic
-      attr_accessor :damage_count  # Red flash intensity (0-8), decays each tic
-      attr_accessor :god_mode, :infinite_ammo
+      }.freeze # Red flash intensity (0-8), decays each tic
+      attr_accessor :health, :armor, :max_health, :max_armor, :ammo_bullets, :ammo_shells, :ammo_rockets, :ammo_cells,
+                    :max_bullets, :max_shells, :max_rockets, :max_cells, :weapon, :has_weapons, :keys, :attacking, :attack_frame, :attack_tics, :bob_angle, :bob_amount, :is_moving, :dead, :death_tic, :damage_count, :god_mode, :infinite_ammo
 
       # Smooth step-up/down (matching Chocolate Doom's P_CalcHeight / P_ZMovement)
       VIEWHEIGHT = 41.0
       VIEWHEIGHT_HALF = VIEWHEIGHT / 2.0
-      DELTA_ACCEL = 0.25        # deltaviewheight += FRACUNIT/4 per tic
-      attr_reader :viewheight, :deltaviewheight
+      DELTA_ACCEL = 0.25 # deltaviewheight += FRACUNIT/4 per tic
 
       # View bob (camera bounce when walking, matching Chocolate Doom's
       # P_CalcHeight + P_XYMovement + P_Thrust from p_user.c / p_mobj.c)
@@ -68,7 +57,7 @@ module Doom
       BOB_DECAY_RATE = 3.44   # Friction as continuous decay rate (1/sec)
       BOB_THRUST = 26.0       # Walk thrust (map units/sec), gives terminal ~7.5
       BOB_FREQUENCY = 11.0    # Bob cycle frequency (rad/sec): FINEANGLES/20 * 35 / 8192 * 2*PI
-      attr_reader :view_bob_offset
+      attr_reader :viewheight, :deltaviewheight, :view_bob_offset
 
       def initialize
         reset
@@ -132,7 +121,10 @@ module Doom
         @view_bob_offset = 0.0
         @momx = 0.0        # Simulated X momentum (map units/sec, not actual movement)
         @momy = 0.0        # Simulated Y momentum
-        @thrust_x = 0.0    # Per-frame thrust input (raw, before normalization)
+        # Held at zero and never read by game logic, but part of the snapshot
+        # wire format and state fingerprint (PLAYER_STATE_FLOATS), so removing
+        # them would need a snapshot version bump. Left in place deliberately.
+        @thrust_x = 0.0
         @thrust_y = 0.0
         @view_bob_angle = 0.0
       end
@@ -156,21 +148,6 @@ module Doom
         end
       end
 
-      def max_ammo_for_weapon
-        case @weapon
-        when WEAPON_PISTOL, WEAPON_CHAINGUN
-          @max_bullets
-        when WEAPON_SHOTGUN
-          @max_shells
-        when WEAPON_ROCKET
-          @max_rockets
-        when WEAPON_PLASMA, WEAPON_BFG
-          @max_cells
-        else
-          nil
-        end
-      end
-
       def can_attack?
         return true if @weapon == WEAPON_FIST || @weapon == WEAPON_CHAINSAW
         return true if @infinite_ammo
@@ -219,21 +196,21 @@ module Doom
         @attack_frame = (@attack_tics / tics_per_frame).to_i
 
         # Attack finished?
-        if @attack_tics >= duration
-          @attacking = false
-          @attack_frame = 0
-          @attack_tics = 0
-        end
+        return unless @attack_tics >= duration
+
+        @attacking = false
+        @attack_frame = 0
+        @attack_tics = 0
       end
 
       def update_bob(delta_time)
         if @is_moving
           # Increase bob while moving
           @bob_angle += delta_time * 10.0
-          @bob_amount = [@bob_amount + delta_time * 16.0, 6.0].min
+          @bob_amount = [@bob_amount + (delta_time * 16.0), 6.0].min
         else
           # Decay bob when stopped
-          @bob_amount = [@bob_amount - delta_time * 12.0, 0.0].max
+          @bob_amount = [@bob_amount - (delta_time * 12.0), 0.0].max
         end
       end
 
@@ -242,10 +219,18 @@ module Doom
       # so the camera doesn't snap, then let P_CalcHeight recover it smoothly.
       def notify_step(step_amount)
         return if step_amount == 0
+
         @viewheight -= step_amount
         @deltaviewheight = (VIEWHEIGHT - @viewheight) / 8.0
       end
 
+      # Called on landing after a fall. Matches Chocolate Doom P_ZMovement:
+      # deltaviewheight = momz >> 3, producing a squat that update_viewheight
+      # then recovers via DELTA_ACCEL.
+      def apply_fall_impact(momz)
+        @deltaviewheight = momz / 8.0
+      end
+
       # Gradually restore viewheight to VIEWHEIGHT (called each tic).
       # Matches Chocolate Doom P_CalcHeight viewheight recovery loop.
       # For step-up: viewheight < 41, delta > 0, accelerates upward.
@@ -263,10 +248,10 @@ module Doom
           @deltaviewheight = 1.0 if @deltaviewheight <= 0
         end
 
-        if @deltaviewheight != 0
-          @deltaviewheight += DELTA_ACCEL
-          @deltaviewheight = 0.0 if @deltaviewheight.abs < 0.01 && (@viewheight - VIEWHEIGHT).abs < 0.5
-        end
+        return unless @deltaviewheight != 0
+
+        @deltaviewheight += DELTA_ACCEL
+        @deltaviewheight = 0.0 if @deltaviewheight.abs < 0.01 && (@viewheight - VIEWHEIGHT).abs < 0.5
       end
 
       # Set movement momentum directly (called from GosuWindow with actual
@@ -281,13 +266,13 @@ module Doom
       #   bob = (momx*momx + momy*momy) >> 2, capped at MAXBOB
       #   viewz += finesine[angle] * bob/2
       # Momentum is in units/sec; DOOM's bob uses units/tic (divide by 35).
-      BOB_MOM_SCALE = 1.0 / (35.0 * 35.0 * 4.0)  # (mom/35)^2 / 4
+      BOB_MOM_SCALE = 1.0 / (35.0 * 35.0 * 4.0) # (mom/35)^2 / 4
 
       def update_view_bob(delta_time)
         dt = delta_time.clamp(0.001, 0.05)
 
         # P_CalcHeight: bob = (momx_per_tic^2 + momy_per_tic^2) / 4, capped at MAXBOB
-        bob = (@momx * @momx + @momy * @momy) * BOB_MOM_SCALE
+        bob = ((@momx * @momx) + (@momy * @momy)) * BOB_MOM_SCALE
         bob = MAXBOB if bob > MAXBOB
 
         # Advance bob sine wave (FINEANGLES/20 per tic = ~11 rad/sec)
@@ -305,17 +290,6 @@ module Doom
         Math.sin(@bob_angle * 2) * @bob_amount * 0.5
       end
 
-      def health_level
-        # 0 = dying, 4 = full health
-        case @health
-        when 80..200 then 4
-        when 60..79 then 3
-        when 40..59 then 2
-        when 20..39 then 1
-        else 0
-        end
-      end
-
       def switch_weapon(weapon_num)
         return unless weapon_num >= 0 && weapon_num < 8
         return unless @has_weapons[weapon_num]
@@ -331,7 +305,7 @@ module Doom
 
         absorbed = 0
         if @armor > 0
-          absorbed = amount / 3  # Green armor absorbs 1/3
+          absorbed = amount / 3 # Green armor absorbs 1/3
           absorbed = @armor if absorbed > @armor
           @armor -= absorbed
         end
@@ -340,13 +314,13 @@ module Doom
         @health -= actual
 
         # Red flash proportional to damage (capped at palette 8)
-        @damage_count = [(@damage_count + actual / 2.0).ceil, 8].min
+        @damage_count = [(@damage_count + (actual / 2.0)).ceil, 8].min
 
-        if @health <= 0
-          @health = 0
-          @damage_count = 8
-          die
-        end
+        return unless @health <= 0
+
+        @health = 0
+        @damage_count = 8
+        die
       end
 
       # Decay damage flash each tic
@@ -358,7 +332,7 @@ module Doom
         @dead = true
         @death_tic = 0
         @attacking = false
-        @deltaviewheight = -VIEWHEIGHT / 8.0  # View drops to ground
+        @deltaviewheight = -VIEWHEIGHT / 8.0 # View drops to ground
       end
     end
   end

data/lib/doom/game/random.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # DOOM's P_Random -- a fixed 256-entry table walked by an index, not a PRNG.
+    #
+    # The point is determinism: two peers running the same tics with the same
+    # starting index observe identical results, which is what lockstep
+    # networking requires. Kernel#rand cannot give us that.
+    #
+    # Matches m_random.c. Only the game-state RNG lives here; presentation-only
+    # randomness (screen melt) stays on Kernel#rand since it never feeds the
+    # simulation.
+    class Random
+      RNDTABLE = [
+        0,   8, 109, 220, 222, 241, 149, 107, 75, 248, 254, 140, 16, 66,
+        74,  21, 211, 47, 80, 242, 154, 27, 205, 128, 161,  89,  77, 36,
+        95, 110, 85,  48, 212, 140, 211, 249, 22, 79, 200, 50, 28, 188,
+        52, 140, 202, 120, 68, 145, 62, 70, 184, 190, 91, 197, 152, 224,
+        149, 104, 25, 178, 252, 182, 202, 182, 141, 197, 4, 81, 181, 242,
+        145, 42, 39, 227, 156, 198, 225, 193, 219, 93, 122, 175, 249, 0,
+        175, 143, 70, 239, 46, 246, 163, 53, 163, 109, 168, 135, 2, 235,
+        25,  92,  20, 145, 138, 77, 69, 166, 78, 176, 173, 212, 166, 113,
+        94, 161,  41, 50, 239, 49, 111, 164, 70, 60, 2, 37, 171, 75,
+        136, 156, 11, 56, 42, 146, 138, 229, 73, 146,  77, 61, 98, 196,
+        135, 106, 63, 197, 195, 86, 96, 203, 113, 101, 170, 247, 181, 113,
+        80, 250, 108, 7, 255, 237, 129, 226, 79, 107, 112, 166, 103, 241,
+        24, 223, 239, 120, 198, 58, 60, 82, 128, 3, 184,  66, 143, 224,
+        145, 224, 81, 206, 163, 45, 63, 90, 168, 114, 59, 33, 159, 95,
+        28, 139, 123,  98, 125, 196, 15, 70, 194, 253, 54, 14, 109, 226,
+        71,  17, 161,  93, 186, 87, 244, 138, 20, 52, 123, 251, 26, 36,
+        17,  46, 52, 231, 232, 76,  31, 221, 84, 37, 216, 165, 212, 106,
+        197, 242, 98, 43, 39, 175, 254, 145, 190, 84, 118, 222, 187, 136,
+        120, 163, 236, 249
+      ].freeze
+
+      # Index into RNDTABLE. Part of the game state -- include it in desync
+      # hashes, and save/restore it alongside player positions.
+      attr_accessor :index
+
+      def initialize(seed = 0)
+        reset(seed)
+      end
+
+      def reset(seed = 0)
+        @index = seed & 0xff
+      end
+
+      # P_Random(): next table entry, 0-255.
+      def byte
+        @index = (@index + 1) & 0xff
+        RNDTABLE[@index]
+      end
+
+      # Signed difference of two draws, -255..255. DOOM uses this shape a lot
+      # (P_Random() - P_Random()) for spread and jitter.
+      def diff
+        byte - byte
+      end
+
+      # Kernel#rand-compatible surface so call sites read the same as before.
+      #
+      #   rand       -> Float in [0, 1)
+      #   rand(n)    -> Integer in 0...n     (DOOM's P_Random()%n)
+      #   rand(a..b) -> Integer in a..b
+      def rand(arg = nil)
+        case arg
+        when nil
+          byte / 256.0
+        when ::Range
+          lo = arg.begin
+          hi = arg.exclude_end? ? arg.end - 1 : arg.end
+          span = hi - lo + 1
+          span <= 0 ? lo : lo + (byte % span)
+        else
+          n = arg.to_i
+          n <= 0 ? 0 : byte % n
+        end
+      end
+    end
+  end
+end