doom 0.3.0 → 0.5.0

data/lib/doom/game/player_state.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # Tracks player state for HUD display and weapon rendering
+    class PlayerState
+      # Weapons
+      WEAPON_FIST = 0
+      WEAPON_PISTOL = 1
+      WEAPON_SHOTGUN = 2
+      WEAPON_CHAINGUN = 3
+      WEAPON_ROCKET = 4
+      WEAPON_PLASMA = 5
+      WEAPON_BFG = 6
+      WEAPON_CHAINSAW = 7
+
+      # Weapon symbols for graphics lookup
+      WEAPON_NAMES = {
+        WEAPON_FIST => :fist,
+        WEAPON_PISTOL => :pistol,
+        WEAPON_SHOTGUN => :shotgun,
+        WEAPON_CHAINGUN => :chaingun,
+        WEAPON_ROCKET => :rocket,
+        WEAPON_PLASMA => :plasma,
+        WEAPON_BFG => :bfg,
+        WEAPON_CHAINSAW => :chainsaw
+      }.freeze
+
+      # Attack durations in tics (at 35fps), matching DOOM's weapon state sequences
+      ATTACK_DURATIONS = {
+        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
+      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
+
+      # 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
+
+      def reset
+        @health = 100
+        @armor = 0
+        @max_health = 100
+        @max_armor = 200
+
+        # Ammo
+        @ammo_bullets = 50
+        @ammo_shells = 0
+        @ammo_rockets = 0
+        @ammo_cells = 0
+
+        @max_bullets = 200
+        @max_shells = 50
+        @max_rockets = 50
+        @max_cells = 300
+
+        # Start with fist and pistol
+        @weapon = WEAPON_PISTOL
+        @has_weapons = [true, true, false, false, false, false, false, false]
+
+        # No keys
+        @keys = {
+          blue_card: false,
+          yellow_card: false,
+          red_card: false,
+          blue_skull: false,
+          yellow_skull: false,
+          red_skull: false
+        }
+
+        # Attack state
+        @attacking = false
+        @attack_frame = 0
+        @attack_tics = 0
+
+        # Weapon bob
+        @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
+        WEAPON_NAMES[@weapon]
+      end
+
+      def current_ammo
+        case @weapon
+        when WEAPON_PISTOL, WEAPON_CHAINGUN
+          @ammo_bullets
+        when WEAPON_SHOTGUN
+          @ammo_shells
+        when WEAPON_ROCKET
+          @ammo_rockets
+        when WEAPON_PLASMA, WEAPON_BFG
+          @ammo_cells
+        else
+          nil # Fist/chainsaw don't use ammo
+        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
+
+        ammo = current_ammo
+        ammo && ammo > 0
+      end
+
+      def start_attack
+        return unless can_attack?
+        return if @attacking
+
+        @attacking = true
+        @attack_frame = 0
+        @attack_tics = 0
+
+        # Consume ammo
+        case @weapon
+        when WEAPON_PISTOL
+          @ammo_bullets -= 1 if @ammo_bullets > 0
+        when WEAPON_SHOTGUN
+          @ammo_shells -= 1 if @ammo_shells > 0
+        when WEAPON_CHAINGUN
+          @ammo_bullets -= 1 if @ammo_bullets > 0
+        when WEAPON_ROCKET
+          @ammo_rockets -= 1 if @ammo_rockets > 0
+        when WEAPON_PLASMA
+          @ammo_cells -= 1 if @ammo_cells > 0
+        when WEAPON_BFG
+          @ammo_cells -= 40 if @ammo_cells >= 40
+        end
+      end
+
+      def update_attack
+        return unless @attacking
+
+        @attack_tics += 1
+
+        # Calculate which frame we're on based on tics
+        duration = ATTACK_DURATIONS[@weapon] || 8
+        frame_count = @weapon == WEAPON_FIST ? 3 : 4
+
+        tics_per_frame = duration / frame_count
+        @attack_frame = (@attack_tics / tics_per_frame).to_i
+
+        # Attack finished?
+        if @attack_tics >= duration
+          @attacking = false
+          @attack_frame = 0
+          @attack_tics = 0
+        end
+      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
+        else
+          # Decay bob when stopped
+          @bob_amount = [@bob_amount - delta_time * 12.0, 0.0].max
+        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
+
+      def weapon_bob_y
+        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]
+        return if @attacking
+
+        @weapon = weapon_num
+      end
+    end
+  end
+end

data/lib/doom/game/sector_actions.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # Manages animated sector actions (doors, lifts, etc.)
+    class SectorActions
+      # Door states
+      DOOR_CLOSED = 0
+      DOOR_OPENING = 1
+      DOOR_OPEN = 2
+      DOOR_CLOSING = 3
+
+      # Door speeds (units per tic, 35 tics/sec)
+      DOOR_SPEED = 2
+      DOOR_WAIT = 150  # Tics to wait when open (~4 seconds)
+      PLAYER_HEIGHT = 56  # Player height for door collision
+
+      def initialize(map)
+        @map = map
+        @active_doors = {}  # sector_index => door_state
+        @player_x = 0
+        @player_y = 0
+      end
+
+      def update_player_position(x, y)
+        @player_x = x
+        @player_y = y
+      end
+
+      def update
+        update_doors
+      end
+
+      # Try to use a linedef (called when player presses use key)
+      def use_linedef(linedef, linedef_idx)
+        return false if linedef.special == 0
+
+        case linedef.special
+        when 1  # DR Door Open Wait Close
+          activate_door(linedef)
+          true
+        when 31  # D1 Door Open Stay
+          activate_door(linedef, stay_open: true)
+          true
+        when 26  # DR Blue Door
+          activate_door(linedef, key: :blue_card)
+          true
+        when 27  # DR Yellow Door
+          activate_door(linedef, key: :yellow_card)
+          true
+        when 28  # DR Red Door
+          activate_door(linedef, key: :red_card)
+          true
+        else
+          false
+        end
+      end
+
+      private
+
+      def activate_door(linedef, stay_open: false, key: nil)
+        # Find the sector on the back side of the linedef
+        return unless linedef.two_sided?
+
+        back_sidedef_idx = linedef.sidedef_left
+        return if back_sidedef_idx == 0xFFFF || back_sidedef_idx < 0
+
+        back_sidedef = @map.sidedefs[back_sidedef_idx]
+        sector_idx = back_sidedef.sector
+        sector = @map.sectors[sector_idx]
+        return unless sector
+
+        # Check if door is already active
+        if @active_doors[sector_idx]
+          door = @active_doors[sector_idx]
+          # If closing, reverse direction
+          if door[:state] == DOOR_CLOSING
+            door[:state] = DOOR_OPENING
+          end
+          return
+        end
+
+        # Calculate target height (find lowest adjacent ceiling)
+        target_height = find_lowest_ceiling_around(sector_idx) - 4
+
+        # Start the door
+        @active_doors[sector_idx] = {
+          sector: sector,
+          state: DOOR_OPENING,
+          target_height: target_height,
+          original_height: sector.ceiling_height,
+          wait_tics: 0,
+          stay_open: stay_open
+        }
+      end
+
+      def update_doors
+        @active_doors.each do |sector_idx, door|
+          case door[:state]
+          when DOOR_OPENING
+            door[:sector].ceiling_height += DOOR_SPEED
+            if door[:sector].ceiling_height >= door[:target_height]
+              door[:sector].ceiling_height = door[:target_height]
+              if door[:stay_open]
+                @active_doors.delete(sector_idx)
+              else
+                door[:state] = DOOR_OPEN
+                door[:wait_tics] = DOOR_WAIT
+              end
+            end
+
+          when DOOR_OPEN
+            door[:wait_tics] -= 1
+            if door[:wait_tics] <= 0
+              door[:state] = DOOR_CLOSING
+            end
+
+          when DOOR_CLOSING
+            # Check if player is in the door sector
+            player_sector = @map.sector_at(@player_x, @player_y)
+            if player_sector == door[:sector]
+              # Player is in door - reopen it
+              door[:state] = DOOR_OPENING
+              next
+            end
+
+            door[:sector].ceiling_height -= DOOR_SPEED
+            if door[:sector].ceiling_height <= door[:original_height]
+              door[:sector].ceiling_height = door[:original_height]
+              @active_doors.delete(sector_idx)
+            end
+          end
+        end
+      end
+
+      def find_lowest_ceiling_around(sector_idx)
+        lowest = Float::INFINITY
+
+        @map.linedefs.each do |linedef|
+          next unless linedef.two_sided?
+
+          # Check if this linedef touches our sector
+          right_sidedef = @map.sidedefs[linedef.sidedef_right]
+          left_sidedef = @map.sidedefs[linedef.sidedef_left] if linedef.sidedef_left != 0xFFFF
+
+          adjacent_sector = nil
+          if right_sidedef&.sector == sector_idx && left_sidedef
+            adjacent_sector = @map.sectors[left_sidedef.sector]
+          elsif left_sidedef&.sector == sector_idx
+            adjacent_sector = @map.sectors[right_sidedef.sector]
+          end
+
+          if adjacent_sector
+            lowest = [lowest, adjacent_sector.ceiling_height].min
+          end
+        end
+
+        lowest == Float::INFINITY ? 128 : lowest
+      end
+    end
+  end
+end

data/lib/doom/game/sector_effects.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # Sector light specials and scrolling walls, matching Chocolate Doom's
+    # P_SpawnSpecials (p_spec.c) and p_lights.c.
+    class SectorEffects
+      GLOWSPEED    = 8   # Light units per tic for glow
+      STROBEBRIGHT = 5   # Bright duration for strobes (tics)
+      FASTDARK     = 15  # Dark duration for fast strobe (tics)
+      SLOWDARK     = 35  # Dark duration for slow strobe (tics)
+
+      def initialize(map)
+        @map = map
+        @effects = []
+        @scroll_sides = []
+        spawn_specials
+      end
+
+      # Called every game tic (35/sec)
+      def update
+        @effects.each(&:update)
+        @scroll_sides.each { |side| side.x_offset += 1 }
+      end
+
+      private
+
+      def spawn_specials
+        @map.sectors.each do |sector|
+          case sector.special
+          when 1      # Flickering lights
+            @effects << LightFlash.new(sector, find_min_light(sector))
+          when 2      # Fast strobe
+            @effects << StrobeFlash.new(sector, find_min_light(sector), FASTDARK, false)
+          when 3      # Slow strobe
+            @effects << StrobeFlash.new(sector, find_min_light(sector), SLOWDARK, false)
+          when 4      # Fast strobe + 20% damage
+            @effects << StrobeFlash.new(sector, find_min_light(sector), FASTDARK, false)
+          when 8      # Glowing light
+            @effects << Glow.new(sector, find_min_light(sector))
+          when 12     # Sync strobe slow
+            @effects << StrobeFlash.new(sector, find_min_light(sector), SLOWDARK, true)
+          when 13     # Sync strobe fast
+            @effects << StrobeFlash.new(sector, find_min_light(sector), FASTDARK, true)
+          when 17     # Fire flicker
+            @effects << FireFlicker.new(sector, find_min_light(sector))
+          end
+        end
+
+        # Linedef type 48: scrolling wall (front side scrolls +1 unit/tic)
+        @map.linedefs.each do |linedef|
+          next unless linedef.special == 48
+          side = @map.sidedefs[linedef.sidedef_right]
+          @scroll_sides << side if side
+        end
+      end
+
+      # P_FindMinSurroundingLight: find lowest light level among adjacent sectors
+      def find_min_light(sector)
+        min = sector.light_level
+        sector_idx = @map.sectors.index(sector)
+        return min unless sector_idx
+
+        @map.linedefs.each do |ld|
+          right = @map.sidedefs[ld.sidedef_right]
+          next unless right
+          left_idx = ld.sidedef_left
+          next if left_idx >= 0xFFFF
+          left = @map.sidedefs[left_idx]
+          next unless left
+
+          if right.sector == sector_idx && left.sector != sector_idx
+            other_light = @map.sectors[left.sector].light_level
+            min = other_light if other_light < min
+          elsif left.sector == sector_idx && right.sector != sector_idx
+            other_light = @map.sectors[right.sector].light_level
+            min = other_light if other_light < min
+          end
+        end
+        min
+      end
+
+      # T_LightFlash (type 1): mostly bright with brief random dark flickers
+      class LightFlash
+        def initialize(sector, minlight)
+          @sector = sector
+          @maxlight = sector.light_level
+          @minlight = minlight
+          @count = (rand(65)) + 1
+        end
+
+        def update
+          @count -= 1
+          return if @count > 0
+
+          if @sector.light_level == @maxlight
+            @sector.light_level = @minlight
+            @count = (rand(8)) + 1       # dark for 1-8 tics
+          else
+            @sector.light_level = @maxlight
+            @count = (rand(2) == 0 ? 1 : 65)  # bright for 1 or 65 tics (P_Random()&64)
+          end
+        end
+      end
+
+      # T_StrobeFlash (types 2, 3, 4, 12, 13): regular strobe blink
+      class StrobeFlash
+        def initialize(sector, minlight, darktime, in_sync)
+          @sector = sector
+          @maxlight = sector.light_level
+          @minlight = minlight
+          @minlight = 0 if @minlight == @maxlight
+          @darktime = darktime
+          @brighttime = STROBEBRIGHT
+          @count = in_sync ? 1 : (rand(8)) + 1
+        end
+
+        def update
+          @count -= 1
+          return if @count > 0
+
+          if @sector.light_level == @minlight
+            @sector.light_level = @maxlight
+            @count = @brighttime
+          else
+            @sector.light_level = @minlight
+            @count = @darktime
+          end
+        end
+      end
+
+      # T_Glow (type 8): smooth triangle-wave oscillation
+      class Glow
+        def initialize(sector, minlight)
+          @sector = sector
+          @maxlight = sector.light_level
+          @minlight = minlight
+          @direction = -1  # start dimming
+        end
+
+        def update
+          if @direction == -1
+            @sector.light_level -= GLOWSPEED
+            if @sector.light_level <= @minlight
+              @sector.light_level += GLOWSPEED
+              @direction = 1
+            end
+          else
+            @sector.light_level += GLOWSPEED
+            if @sector.light_level >= @maxlight
+              @sector.light_level -= GLOWSPEED
+              @direction = -1
+            end
+          end
+        end
+      end
+
+      # T_FireFlicker (type 17): random fire-like flickering
+      class FireFlicker
+        def initialize(sector, minlight)
+          @sector = sector
+          @maxlight = sector.light_level
+          @minlight = minlight + 16  # fire doesn't go as dark
+          @count = 4
+        end
+
+        def update
+          @count -= 1
+          return if @count > 0
+
+          amount = (rand(4)) * 16  # 0, 16, 32, or 48
+          level = @maxlight - amount
+          @sector.light_level = level < @minlight ? @minlight : level
+          @count = 4
+        end
+      end
+    end
+  end
+end