doom 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb48bcb7558c2e4f4ab959b16dbd857d2a1b6a3b9a9cc76c19a08ec91bdeb93e
-  data.tar.gz: 610f42cf954c60048a0c4030d96a8e8ceb2872aba90e90a141b2179329867c05
+  metadata.gz: c4672b03d393f17c1cd9ece97869d7239a7af3e91d3ffa47b911b0ba3058f673
+  data.tar.gz: 56772f44ced59386c92f5319c0d25dc8612e96263d68ae7e9a240d26508571cf
 SHA512:
-  metadata.gz: 1ff09fd05c29a5c49b7d41285424d58b8b46dbf995e1f18106d571f18866762e8b20ecb47d472dc2cb2be8f2fc8cdea5eb0b3a2dedae55d5b1881bbcb796088b
-  data.tar.gz: 41d4fcb793f3b25fb57f2d50c02f5eee1a56cb40a40baf2a9f7e0831634f43aa4777abf80968130c44593055dbaea23bd3257e7d4b509a068af2c92e1e16698d
+  metadata.gz: b11b52ed631217b002aae05a4f87b7ff5fcb208485b75dd9077ebcc222c3823c6ca74167e9bc6b7c3605c0481472abbc818e6445c8fa130c744fe8c54da53099
+  data.tar.gz: 808176138162ef4e21796dd995a6bd794eee89e4c631032134349746afd468d446b610a0939daf19c26a2706abac22635306d6e3fb1c1c93e9a70282a2114f7d

data/README.md

@@ -2,7 +2,7 @@
 
 A faithful ruby port of the DOOM (1993) rendering engine to Ruby.
 
-![DOOM Ruby Screenshot](screenshot.png)
+![DOOM Ruby](demo.gif)
 
 ## Features
 

data/lib/doom/game/animations.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # Animated texture/flat cycling, matching Chocolate Doom's P_InitPicAnims
+    # and P_UpdateSpecials from p_spec.c.
+    #
+    # All animations run at 8 tics per frame (8/35 sec ≈ 0.23s).
+    # Frames must be consecutive entries in the WAD; the engine uses
+    # start/end names to find the range.
+    class Animations
+      TICS_PER_FRAME = 8
+
+      # [is_texture, start_name, end_name]
+      # From Chocolate Doom animdefs[] in p_spec.c
+      ANIMDEFS = [
+        # Animated flats
+        [false, 'NUKAGE1',  'NUKAGE3'],
+        [false, 'FWATER1',  'FWATER4'],
+        [false, 'SWATER1',  'SWATER4'],
+        [false, 'LAVA1',    'LAVA4'],
+        [false, 'BLOOD1',   'BLOOD3'],
+        [false, 'RROCK05',  'RROCK08'],
+        [false, 'SLIME01',  'SLIME04'],
+        [false, 'SLIME05',  'SLIME08'],
+        [false, 'SLIME09',  'SLIME12'],
+        # Animated wall textures
+        [true, 'BLODGR1',  'BLODGR4'],
+        [true, 'SLADRIP1', 'SLADRIP3'],
+        [true, 'BLODRIP1', 'BLODRIP4'],
+        [true, 'FIREWALA', 'FIREWALL'],
+        [true, 'GSTFONT1', 'GSTFONT3'],
+        [true, 'FIRELAV3', 'FIRELAVA'],
+        [true, 'FIREMAG1', 'FIREMAG3'],
+        [true, 'FIREBLU1', 'FIREBLU2'],
+        [true, 'ROCKRED1', 'ROCKRED3'],
+        [true, 'BFALL1',   'BFALL4'],
+        [true, 'SFALL1',   'SFALL4'],
+        [true, 'WFALL1',   'WFALL4'],
+        [true, 'DBRAIN1',  'DBRAIN4'],
+      ].freeze
+
+      attr_reader :flat_translation, :texture_translation
+
+      def initialize(texture_names, flat_names)
+        @flat_translation = {}      # flat_name -> current_frame_name
+        @texture_translation = {}   # texture_name -> current_frame_name
+        @anims = []
+
+        ANIMDEFS.each do |is_texture, start_name, end_name|
+          names = is_texture ? texture_names : flat_names
+
+          start_idx = names.index(start_name)
+          end_idx = names.index(end_name)
+          next unless start_idx && end_idx
+          next if end_idx <= start_idx
+
+          frames = names[start_idx..end_idx]
+          next if frames.size < 2
+
+          @anims << {
+            is_texture: is_texture,
+            frames: frames,
+            speed: TICS_PER_FRAME,
+          }
+        end
+      end
+
+      # Call every game tic (or approximate with leveltime).
+      # Matches Chocolate Doom P_UpdateSpecials:
+      #   pic = basepic + ((leveltime / speed + i) % numpics)
+      def update(leveltime)
+        @anims.each do |anim|
+          frames = anim[:frames]
+          numpics = frames.size
+          phase = leveltime / anim[:speed]
+          translation = anim[:is_texture] ? @texture_translation : @flat_translation
+
+          numpics.times do |i|
+            current_frame = frames[(phase + i) % numpics]
+            translation[frames[i]] = current_frame
+          end
+        end
+      end
+
+      # Translate a flat name to its current animation frame
+      def translate_flat(name)
+        @flat_translation[name] || name
+      end
+
+      # Translate a texture name to its current animation frame
+      def translate_texture(name)
+        @texture_translation[name] || name
+      end
+    end
+  end
+end

data/lib/doom/game/combat.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # Hitscan weapon firing and monster state tracking.
+    # Matches Chocolate Doom's P_LineAttack / P_AimLineAttack from p_map.c.
+    class Combat
+      # Monster starting HP (from mobjinfo[] in info.c)
+      MONSTER_HP = {
+        3004 => 20,   # Zombieman
+        9    => 30,   # Shotgun Guy
+        3001 => 60,   # Imp
+        3002 => 150,  # Demon
+        58   => 150,  # Spectre
+        3003 => 1000, # Baron of Hell
+        69   => 500,  # Hell Knight
+        3005 => 400,  # Cacodemon
+        3006 => 100,  # Lost Soul
+        16   => 4000, # Cyberdemon
+        7    => 3000, # Spider Mastermind
+        65   => 70,   # Heavy Weapon Dude
+        64   => 700,  # Archvile
+        71   => 400,  # Pain Elemental
+        84   => 20,   # Wolfenstein SS
+      }.freeze
+
+      MONSTER_RADIUS = {
+        3004 => 20, 9 => 20, 3001 => 20, 3002 => 30, 58 => 30,
+        3003 => 24, 69 => 24, 3005 => 31, 3006 => 16, 16 => 40,
+        7 => 128, 65 => 20, 64 => 20, 71 => 31, 84 => 20,
+      }.freeze
+
+      # Normal death frame sequences per sprite prefix (rotation 0 only)
+      # Identified by sprite heights: frames go from standing height to flat on ground
+      DEATH_FRAMES = {
+        'POSS' => %w[H I J K L],       # Zombieman: 55→46→34→27→17
+        'SPOS' => %w[H I J K L],       # Shotgun Guy: 60→50→35→27→17
+        'TROO' => %w[I J K L M],       # Imp: 62→59→54→46→22
+        'SARG' => %w[I J K L M N],     # Demon/Spectre: 56→56→53→57→46→32
+        'BOSS' => %w[H I J K L M N],   # Baron
+        'BOS2' => %w[H I J K L M N],   # Hell Knight
+        'HEAD' => %w[G H I J K L],     # Cacodemon
+        'SKUL' => %w[G H I J K],       # Lost Soul
+        'CYBR' => %w[I J],             # Cyberdemon
+        'SPID' => %w[I J K],           # Spider Mastermind
+        'CPOS' => %w[H I J K L M N],   # Heavy Weapon Dude
+        'PAIN' => %w[H I J K L M],     # Pain Elemental
+        'SSWV' => %w[I J K L M],       # Wolfenstein SS
+      }.freeze
+
+      DEATH_ANIM_TICS = 6  # Tics per death frame
+
+      # Weapon damage: DOOM does (P_Random()%3 + 1) * multiplier
+      # Pistol/chaingun: 1*5..3*5 = 5-15 per bullet
+      # Shotgun: 7 pellets, each 1*5..3*5 = 5-15
+      # Fist/chainsaw: 1*2..3*2 = 2-10
+
+      def initialize(map, player_state, sprites)
+        @map = map
+        @player = player_state
+        @sprites = sprites
+        @monster_hp = {}     # thing_idx => current HP
+        @dead_things = {}    # thing_idx => { tic: death_start_tic, prefix: sprite_prefix }
+        @tic = 0
+      end
+
+      attr_reader :dead_things
+
+      def dead?(thing_idx)
+        @dead_things.key?(thing_idx)
+      end
+
+      # Get the current death frame sprite for a dead monster
+      def death_sprite(thing_idx, thing_type, viewer_angle, thing_angle)
+        info = @dead_things[thing_idx]
+        return nil unless info
+
+        frames = DEATH_FRAMES[info[:prefix]]
+        return nil unless frames
+
+        elapsed = @tic - info[:tic]
+        frame_idx = (elapsed / DEATH_ANIM_TICS).clamp(0, frames.size - 1)
+        frame_letter = frames[frame_idx]
+
+        @sprites.get_frame(thing_type, frame_letter, viewer_angle, thing_angle)
+      end
+
+      # Called each game tic
+      def update
+        @tic += 1
+      end
+
+      # Fire the current weapon
+      def fire(px, py, pz, cos_a, sin_a, weapon)
+        case weapon
+        when PlayerState::WEAPON_PISTOL, PlayerState::WEAPON_CHAINGUN
+          hitscan(px, py, cos_a, sin_a, 1, 0.0, 5)
+        when PlayerState::WEAPON_SHOTGUN
+          hitscan(px, py, cos_a, sin_a, 7, Math::PI / 32, 5)
+        when PlayerState::WEAPON_FIST
+          melee(px, py, cos_a, sin_a, 2, 64)
+        when PlayerState::WEAPON_CHAINSAW
+          melee(px, py, cos_a, sin_a, 2, 64)
+        end
+      end
+
+      private
+
+      def hitscan(px, py, cos_a, sin_a, pellets, spread, multiplier)
+        pellets.times do
+          # Add random spread
+          if spread > 0
+            angle = Math.atan2(sin_a, cos_a) + (rand - 0.5) * spread * 2
+            ca = Math.cos(angle)
+            sa = Math.sin(angle)
+          else
+            # Slight pistol/chaingun spread
+            angle = Math.atan2(sin_a, cos_a) + (rand - 0.5) * 0.04
+            ca = Math.cos(angle)
+            sa = Math.sin(angle)
+          end
+
+          wall_dist = trace_wall(px, py, ca, sa)
+
+          best_idx = nil
+          best_dist = wall_dist
+
+          @map.things.each_with_index do |thing, idx|
+            next unless MONSTER_HP[thing.type]
+            next if @dead_things[idx]
+
+            radius = MONSTER_RADIUS[thing.type] || 20
+            hit_dist = ray_circle_hit(px, py, ca, sa, thing.x, thing.y, radius)
+            if hit_dist && hit_dist > 0 && hit_dist < best_dist
+              best_dist = hit_dist
+              best_idx = idx
+            end
+          end
+
+          if best_idx
+            damage = (rand(3) + 1) * multiplier
+            apply_damage(best_idx, damage)
+          end
+        end
+      end
+
+      def melee(px, py, cos_a, sin_a, multiplier, range)
+        best_idx = nil
+        best_dist = range.to_f
+
+        @map.things.each_with_index do |thing, idx|
+          next unless MONSTER_HP[thing.type]
+          next if @dead_things[idx]
+
+          dx = thing.x - px
+          dy = thing.y - py
+          dist = Math.sqrt(dx * dx + dy * dy)
+          next if dist > range + (MONSTER_RADIUS[thing.type] || 20)
+
+          # Check if roughly facing the monster
+          dot = dx * cos_a + dy * sin_a
+          next if dot < 0
+
+          if dist < best_dist
+            best_dist = dist
+            best_idx = idx
+          end
+        end
+
+        if best_idx
+          damage = (rand(3) + 1) * multiplier
+          apply_damage(best_idx, damage)
+        end
+      end
+
+      def apply_damage(thing_idx, damage)
+        thing = @map.things[thing_idx]
+        @monster_hp[thing_idx] ||= MONSTER_HP[thing.type] || 20
+
+        @monster_hp[thing_idx] -= damage
+
+        if @monster_hp[thing_idx] <= 0
+          prefix = @sprites.prefix_for(thing.type)
+          @dead_things[thing_idx] = { tic: @tic, prefix: prefix } if prefix
+        end
+      end
+
+      def trace_wall(px, py, cos_a, sin_a)
+        best_t = 4096.0  # Max hitscan range
+
+        @map.linedefs.each do |ld|
+          v1 = @map.vertices[ld.v1]
+          v2 = @map.vertices[ld.v2]
+
+          # One-sided always blocks; two-sided only if impassable
+          blocks = (ld.sidedef_left == 0xFFFF) || (ld.flags & 0x0001 != 0)
+          unless blocks
+            next unless ld.sidedef_left < 0xFFFF
+            front = @map.sidedefs[ld.sidedef_right]
+            back = @map.sidedefs[ld.sidedef_left]
+            fs = @map.sectors[front.sector]
+            bs = @map.sectors[back.sector]
+            # Blocks if opening is too small (step or low ceiling)
+            max_floor = [fs.floor_height, bs.floor_height].max
+            min_ceil = [fs.ceiling_height, bs.ceiling_height].min
+            blocks = (min_ceil - max_floor) < 56
+          end
+          next unless blocks
+
+          t = ray_segment_intersect(px, py, cos_a, sin_a,
+                                     v1.x, v1.y, v2.x, v2.y)
+          best_t = t if t && t > 0 && t < best_t
+        end
+
+        best_t
+      end
+
+      def ray_segment_intersect(px, py, dx, dy, x1, y1, x2, y2)
+        sx = x2 - x1
+        sy = y2 - y1
+        denom = dx * sy - dy * sx
+        return nil if denom.abs < 0.001
+
+        t = ((x1 - px) * sy - (y1 - py) * sx) / denom
+        u = ((x1 - px) * dy - (y1 - py) * dx) / denom
+
+        (t > 0 && u >= 0.0 && u <= 1.0) ? t : nil
+      end
+
+      def ray_circle_hit(px, py, cos_a, sin_a, cx, cy, radius)
+        dx = cx - px
+        dy = cy - py
+        proj = dx * cos_a + dy * sin_a
+        return nil if proj < 0
+
+        perp_sq = dx * dx + dy * dy - proj * proj
+        return nil if perp_sq > radius * radius
+
+        chord_half = Math.sqrt([radius * radius - perp_sq, 0].max)
+        proj - chord_half
+      end
+    end
+  end
+end

data/lib/doom/game/item_pickup.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # Handles item pickup when player touches things.
+    # Matches Chocolate Doom's P_TouchSpecialThing from p_inter.c.
+    class ItemPickup
+      PLAYER_RADIUS = 16.0
+      THING_RADIUS = 20.0
+      PICKUP_DIST = PLAYER_RADIUS + THING_RADIUS  # 36 units (bounding box overlap)
+
+      # Item definitions: type => { category, value, ... }
+      ITEMS = {
+        # Weapons (give weapon + some ammo)
+        2001 => { cat: :weapon, weapon: 2, ammo: :shells, amount: 8 },    # Shotgun
+        2002 => { cat: :weapon, weapon: 3, ammo: :bullets, amount: 20 },  # Chaingun
+        2003 => { cat: :weapon, weapon: 4, ammo: :rockets, amount: 2 },   # Rocket launcher
+        2004 => { cat: :weapon, weapon: 5, ammo: :cells, amount: 40 },    # Plasma rifle
+        2006 => { cat: :weapon, weapon: 6, ammo: :cells, amount: 40 },    # BFG9000
+        2005 => { cat: :weapon, weapon: 7, ammo: :bullets, amount: 0 },   # Chainsaw
+
+        # Ammo
+        2007 => { cat: :ammo, ammo: :bullets, amount: 10 },   # Clip
+        2048 => { cat: :ammo, ammo: :bullets, amount: 50 },   # Box of bullets
+        2008 => { cat: :ammo, ammo: :shells, amount: 4 },     # 4 shells
+        2049 => { cat: :ammo, ammo: :shells, amount: 20 },    # Box of shells
+        2010 => { cat: :ammo, ammo: :rockets, amount: 1 },    # Rocket
+        2046 => { cat: :ammo, ammo: :rockets, amount: 5 },    # Box of rockets
+        17   => { cat: :ammo, ammo: :cells, amount: 20 },     # Cell charge
+        2047 => { cat: :ammo, ammo: :cells, amount: 100 },    # Cell pack
+        8    => { cat: :backpack },                             # Backpack (doubles max ammo + some ammo)
+
+        # Health
+        2014 => { cat: :health, amount: 1, max: 200 },        # Health bonus (+1, up to 200)
+        2011 => { cat: :health, amount: 10, max: 100 },       # Stimpack
+        2012 => { cat: :health, amount: 25, max: 100 },       # Medikit
+        2013 => { cat: :health, amount: 100, max: 200 },      # Soul sphere
+
+        # Armor
+        2015 => { cat: :armor, amount: 1, max: 200 },         # Armor bonus (+1, up to 200)
+        2018 => { cat: :armor, amount: 100, armor_type: 1 },   # Green armor (100%, absorbs 1/3)
+        2019 => { cat: :armor, amount: 200, armor_type: 2 },   # Blue armor (200%, absorbs 1/2)
+
+        # Keys
+        5  => { cat: :key, key: :blue_card },
+        6  => { cat: :key, key: :yellow_card },
+        13 => { cat: :key, key: :red_card },
+        40 => { cat: :key, key: :blue_skull },
+        39 => { cat: :key, key: :yellow_skull },
+        38 => { cat: :key, key: :red_skull },
+      }.freeze
+
+      attr_reader :picked_up
+
+      def initialize(map, player_state)
+        @map = map
+        @player = player_state
+        @picked_up = {}  # thing index => true (to avoid re-picking)
+      end
+
+      def update(player_x, player_y)
+        @map.things.each_with_index do |thing, idx|
+          next if @picked_up[idx]
+          item = ITEMS[thing.type]
+          next unless item
+
+          # DOOM uses bounding box overlap: abs(dx) < sum_of_radii
+          dx = (player_x - thing.x).abs
+          dy = (player_y - thing.y).abs
+          next if dx >= PICKUP_DIST || dy >= PICKUP_DIST
+
+          if try_pickup(item)
+            @picked_up[idx] = true
+          end
+        end
+      end
+
+      private
+
+      def try_pickup(item)
+        case item[:cat]
+        when :weapon
+          give_weapon(item)
+        when :ammo
+          give_ammo(item[:ammo], item[:amount])
+        when :backpack
+          give_backpack
+        when :health
+          give_health(item[:amount], item[:max])
+        when :armor
+          give_armor(item)
+        when :key
+          give_key(item[:key])
+        else
+          false
+        end
+      end
+
+      def give_weapon(item)
+        weapon_idx = item[:weapon]
+        had_weapon = @player.has_weapons[weapon_idx]
+
+        @player.has_weapons[weapon_idx] = true
+        ammo_given = item[:ammo] ? give_ammo(item[:ammo], item[:amount]) : false
+
+        unless had_weapon
+          @player.switch_weapon(weapon_idx) unless @player.attacking
+          return true
+        end
+
+        ammo_given
+      end
+
+      def give_ammo(type, amount)
+        case type
+        when :bullets
+          return false if @player.ammo_bullets >= @player.max_bullets
+          @player.ammo_bullets = [@player.ammo_bullets + amount, @player.max_bullets].min
+        when :shells
+          return false if @player.ammo_shells >= @player.max_shells
+          @player.ammo_shells = [@player.ammo_shells + amount, @player.max_shells].min
+        when :rockets
+          return false if @player.ammo_rockets >= @player.max_rockets
+          @player.ammo_rockets = [@player.ammo_rockets + amount, @player.max_rockets].min
+        when :cells
+          return false if @player.ammo_cells >= @player.max_cells
+          @player.ammo_cells = [@player.ammo_cells + amount, @player.max_cells].min
+        end
+        true
+      end
+
+      def give_backpack
+        @player.max_bullets = 400
+        @player.max_shells = 100
+        @player.max_rockets = 100
+        @player.max_cells = 600
+        give_ammo(:bullets, 10)
+        give_ammo(:shells, 4)
+        give_ammo(:rockets, 1)
+        give_ammo(:cells, 20)
+        true
+      end
+
+      def give_health(amount, max)
+        return false if @player.health >= max
+        @player.health = [@player.health + amount, max].min
+        true
+      end
+
+      def give_armor(item)
+        if item[:armor_type]
+          # Green/blue armor: only pick up if better than current
+          return false if @player.armor >= item[:amount]
+          @player.armor = item[:amount]
+        else
+          # Armor bonus: +1, up to max
+          return false if @player.armor >= item[:max]
+          @player.armor = [@player.armor + item[:amount], item[:max]].min
+        end
+        true
+      end
+
+      def give_key(key)
+        return false if @player.keys[key]
+        @player.keys[key] = true
+        true
+      end
+    end
+  end
+end

data/lib/doom/game/player_state.rb

@@ -26,16 +26,16 @@ module Doom
         WEAPON_CHAINSAW => :chainsaw
       }.freeze
 
-      # Attack durations (in frames at 35fps)
+      # Attack durations in tics (at 35fps), matching DOOM's weapon state sequences
       ATTACK_DURATIONS = {
-        WEAPON_FIST => 12,
-        WEAPON_PISTOL => 8,
-        WEAPON_SHOTGUN => 20,
-        WEAPON_CHAINGUN => 4,
-        WEAPON_ROCKET => 16,
-        WEAPON_PLASMA => 6,
-        WEAPON_BFG => 40,
-        WEAPON_CHAINSAW => 4
+        WEAPON_FIST => 14,       # Punch windup + swing
+        WEAPON_PISTOL => 16,     # S_PISTOL: 6+4+5+1 tics
+        WEAPON_SHOTGUN => 40,    # Pump action cycle
+        WEAPON_CHAINGUN => 8,    # Rapid fire (2 shots per cycle)
+        WEAPON_ROCKET => 20,     # Rocket launch + recovery
+        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
@@ -47,6 +47,26 @@ module Doom
       attr_accessor :bob_angle, :bob_amount
       attr_accessor :is_moving
 
+      # 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
+
+      # View bob (camera bounce when walking, matching Chocolate Doom's
+      # P_CalcHeight + P_XYMovement + P_Thrust from p_user.c / p_mobj.c)
+      MAXBOB = 16.0           # Maximum bob amplitude (0x100000 in fixed-point = 16 map units)
+      STOPSPEED = 0.0625      # Snap-to-zero threshold (0x1000 in fixed-point)
+      # Continuous-time equivalents of DOOM's per-tic constants (35 fps tic rate):
+      #   FRICTION = 0xE800/0x10000 = 0.90625 per tic
+      #   decay_rate = -ln(0.90625) * 35 = 3.44/sec
+      #   walk thrust = forwardmove(25) * 2048 / 65536 = 0.78 map units/tic = 27.3/sec
+      #   terminal velocity = 27.3 / 3.44 = 7.56 -> bob = 7.56^2/4 = 14.3 (89% of MAXBOB)
+      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
+
       def initialize
         reset
       end
@@ -91,6 +111,18 @@ module Doom
         @bob_angle = 0.0
         @bob_amount = 0.0
         @is_moving = false
+
+        # Smooth step height (P_CalcHeight viewheight/deltaviewheight)
+        @viewheight = VIEWHEIGHT
+        @deltaviewheight = 0.0
+
+        # View bob (camera bounce) - simulated momentum for P_CalcHeight
+        @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)
+        @thrust_y = 0.0
+        @view_bob_angle = 0.0
       end
 
       def weapon_name
@@ -190,6 +222,66 @@ module Doom
         end
       end
 
+      # Called when player moves onto a different floor height.
+      # Matches Chocolate Doom P_ZMovement: reduce viewheight by the step amount
+      # 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
+
+      # 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.
+      # For step-down: viewheight > 41, delta < 0, decelerates then recovers.
+      def update_viewheight
+        @viewheight += @deltaviewheight
+
+        if @viewheight > VIEWHEIGHT && @deltaviewheight >= 0
+          @viewheight = VIEWHEIGHT
+          @deltaviewheight = 0.0
+        end
+
+        if @viewheight < VIEWHEIGHT_HALF
+          @viewheight = VIEWHEIGHT_HALF
+          @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
+      end
+
+      # Set movement momentum directly (called from GosuWindow with actual
+      # movement momentum, which already has thrust + friction applied).
+      def set_movement_momentum(momx, momy)
+        @momx = momx
+        @momy = momy
+      end
+
+      # Compute view bob from actual movement momentum.
+      # Matches Chocolate Doom P_CalcHeight:
+      #   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
+
+      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 = MAXBOB if bob > MAXBOB
+
+        # Advance bob sine wave (FINEANGLES/20 per tic = ~11 rad/sec)
+        @view_bob_angle += BOB_FREQUENCY * dt
+
+        # viewz offset: sin(angle) * bob/2
+        @view_bob_offset = Math.sin(@view_bob_angle) * bob / 2.0
+      end
+
       def weapon_bob_x
         Math.cos(@bob_angle) * @bob_amount
       end