doom 0.6.0 → 0.8.0

data/lib/doom/game/player_state.rb

@@ -48,6 +48,7 @@ module Doom
       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
 
       # Smooth step-up/down (matching Chocolate Doom's P_CalcHeight / P_ZMovement)
       VIEWHEIGHT = 41.0
@@ -114,6 +115,10 @@ module Doom
         @death_tic = 0
         @damage_count = 0
 
+        # Cheats
+        @god_mode = false
+        @infinite_ammo = false
+
         # Weapon bob
         @bob_angle = 0.0
         @bob_amount = 0.0
@@ -168,6 +173,7 @@ module Doom
 
       def can_attack?
         return true if @weapon == WEAPON_FIST || @weapon == WEAPON_CHAINSAW
+        return true if @infinite_ammo
 
         ammo = current_ammo
         ammo && ammo > 0
@@ -181,7 +187,9 @@ module Doom
         @attack_frame = 0
         @attack_tics = 0
 
-        # Consume ammo
+        # Consume ammo (skipped with infinite ammo)
+        return if @infinite_ammo
+
         case @weapon
         when WEAPON_PISTOL
           @ammo_bullets -= 1 if @ammo_bullets > 0
@@ -319,6 +327,7 @@ module Doom
       # Apply damage (from environment or enemies). Armor absorbs some.
       def take_damage(amount)
         return if @dead
+        return if @god_mode
 
         absorbed = 0
         if @armor > 0

data/lib/doom/game/sector_actions.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'set'
+
 module Doom
   module Game
     # Manages animated sector actions (doors, lifts, etc.)
@@ -13,13 +15,30 @@ module Doom
       # 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
+      PLAYER_HEIGHT = 56
+
+      # Lift constants
+      LIFT_SPEED = 4
+      LIFT_WAIT = 105  # ~3 seconds
+
+      attr_reader :exit_triggered, :secrets_found
 
-      def initialize(map)
+      def pop_teleport
+        dest = @teleport_dest
+        @teleport_dest = nil
+        dest
+      end
+
+      def initialize(map, sound_engine = nil)
         @map = map
-        @active_doors = {}  # sector_index => door_state
+        @sound = sound_engine
+        @active_doors = {}   # sector_index => door_state
+        @active_lifts = {}   # sector_index => lift_state
         @player_x = 0
         @player_y = 0
+        @exit_triggered = nil
+        @secrets_found = {}  # sector_index => true
+        @crossed_linedefs = {}
       end
 
       def update_player_position(x, y)
@@ -29,6 +48,9 @@ module Doom
 
       def update
         update_doors
+        update_lifts
+        check_walk_triggers
+        check_secrets
       end
 
       # Try to use a linedef (called when player presses use key)
@@ -36,28 +58,156 @@ module Doom
         return false if linedef.special == 0
 
         case linedef.special
-        when 1  # DR Door Open Wait Close
+        # --- Doors ---
+        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
+        when 26   # DR Blue Door
           activate_door(linedef, key: :blue_card)
-          true
-        when 27  # DR Yellow Door
+        when 27   # DR Yellow Door
           activate_door(linedef, key: :yellow_card)
-          true
-        when 28  # DR Red Door
+        when 28   # DR Red Door
           activate_door(linedef, key: :red_card)
-          true
+        when 31   # D1 Door Open Stay
+          activate_door(linedef, stay_open: true)
+        when 32   # D1 Blue Door Open Stay
+          activate_door(linedef, key: :blue_card, stay_open: true)
+        when 33   # D1 Red Door Open Stay
+          activate_door(linedef, key: :red_card, stay_open: true)
+        when 34   # D1 Yellow Door Open Stay
+          activate_door(linedef, key: :yellow_card, stay_open: true)
+        when 103  # S1 Door Open Wait Close (tagged)
+          activate_tagged_door(linedef)
+
+        # --- Lifts ---
+        when 62   # SR Lift Lower Wait Raise (repeatable)
+          activate_lift(linedef)
+
+        # --- Floor changes ---
+        when 18   # S1 Raise Floor to Next Higher
+          raise_floor_to_next(linedef)
+        when 20   # S1 Raise Floor to Next Higher (platform)
+          raise_floor_to_next(linedef)
+        when 22   # W1 Raise Floor to Next Higher
+          raise_floor_to_next(linedef)
+        when 23   # S1 Lower Floor to Lowest
+          lower_floor_to_lowest(linedef)
+        when 36   # S1 Lower Floor to Highest Adjacent - 8
+          lower_floor_to_highest(linedef)
+        when 70   # SR Lower Floor to Highest Adjacent - 8
+          lower_floor_to_highest(linedef)
+
+        # --- Exits ---
+        when 11   # S1 Exit
+          @exit_triggered = :normal
+        when 51   # S1 Secret Exit
+          @exit_triggered = :secret
+
         else
-          false
+          return false
         end
+        true
       end
 
       private
 
+      # Walk-over trigger types:
+      # W1 = once, WR = repeatable
+      WALK_TRIGGERS = {
+        2  => :door_open_stay,    # W1 Door Open Stay
+        5  => :raise_floor,       # W1 Raise Floor to Lowest Ceiling
+        7  => :stairs,            # S1 Build Stairs
+        8  => :stairs,            # W1 Build Stairs
+        52 => :exit,              # W1 Exit
+        82 => :lower_floor,       # WR Lower Floor to Lowest
+        86 => :door_open_stay,    # WR Door Open Stay
+        88 => :lift,              # WR Lift Lower Wait Raise
+        90 => :door,              # WR Door Open Wait Close
+        91 => :raise_floor,       # WR Raise Floor to Lowest Ceiling
+        97 => :teleport,          # WR Teleport
+        98 => :lower_floor,       # WR Lower Floor to Highest - 8
+        124 => :secret_exit,      # W1 Secret Exit
+      }.freeze
+
+      # W1 types that only trigger once
+      W1_TYPES = [2, 5, 7, 8, 52, 124].freeze
+
+      def check_walk_triggers
+        @near_linedefs ||= {}
+
+        @map.linedefs.each_with_index do |ld, idx|
+          next if ld.special == 0
+          action = WALK_TRIGGERS[ld.special]
+          next unless action
+
+          # W1 types only trigger once
+          if W1_TYPES.include?(ld.special)
+            next if @crossed_linedefs[idx]
+          end
+
+          v1 = @map.vertices[ld.v1]
+          v2 = @map.vertices[ld.v2]
+
+          # Determine which side of the linedef the player is on
+          # DOOM's P_CrossSpecialLine fires when the player transitions sides
+          side = line_side(@player_x, @player_y, v1.x, v1.y, v2.x, v2.y)
+          dist = point_line_dist(@player_x, @player_y, v1.x, v1.y, v2.x, v2.y)
+
+          near = dist < 32  # Detection range
+          prev_side = @near_linedefs[idx]
+
+          if near && prev_side && prev_side != side
+            # Player crossed the line - trigger!
+            @near_linedefs[idx] = side
+          elsif near && prev_side.nil?
+            # First time near - record side but don't trigger yet
+            @near_linedefs[idx] = side
+            next
+          elsif !near
+            @near_linedefs[idx] = nil
+            next
+          else
+            next  # Same side, no crossing
+          end
+
+          @crossed_linedefs[idx] = true
+
+          case action
+          when :exit
+            @exit_triggered = :normal
+          when :secret_exit
+            @exit_triggered = :secret
+          when :door_open_stay
+            activate_tagged_door(ld, stay_open: true)
+          when :door
+            activate_tagged_door(ld)
+          when :lift
+            activate_lift(ld)
+          when :raise_floor
+            raise_floor_to_next(ld)
+          when :lower_floor
+            lower_floor_to_highest(ld)
+          when :teleport
+            teleport_player(ld)
+          end
+        end
+      end
+
+      # Returns which side of a line a point is on (:front or :back)
+      def line_side(px, py, x1, y1, x2, y2)
+        cross = (x2 - x1) * (py - y1) - (y2 - y1) * (px - x1)
+        cross >= 0 ? :front : :back
+      end
+
+      def point_line_dist(px, py, x1, y1, x2, y2)
+        dx = x2 - x1; dy = y2 - y1
+        len_sq = dx * dx + dy * dy
+        return Math.sqrt((px - x1) ** 2 + (py - y1) ** 2) if len_sq == 0
+        t = ((px - x1) * dx + (py - y1) * dy).to_f / len_sq
+        t = [[t, 0.0].max, 1.0].min
+        cx = x1 + t * dx; cy = y1 + t * dy
+        Math.sqrt((px - cx) ** 2 + (py - cy) ** 2)
+      end
+
       def activate_door(linedef, stay_open: false, key: nil)
         # Find the sector on the back side of the linedef
         return unless linedef.two_sided?
@@ -92,6 +242,7 @@ module Doom
           wait_tics: 0,
           stay_open: stay_open
         }
+        @sound&.door_open
       end
 
       def update_doors
@@ -113,6 +264,7 @@ module Doom
             door[:wait_tics] -= 1
             if door[:wait_tics] <= 0
               door[:state] = DOOR_CLOSING
+              @sound&.door_close
             end
 
           when DOOR_CLOSING
@@ -157,6 +309,215 @@ module Doom
 
         lowest == Float::INFINITY ? 128 : lowest
       end
+
+      # Door activated by tag (for S1/W1/WR tagged doors)
+      def activate_tagged_door(linedef, stay_open: false)
+        tag = linedef.tag
+        return if tag == 0
+
+        @map.sectors.each_with_index do |sector, idx|
+          next unless sector_has_tag?(idx, tag)
+          next if @active_doors[idx]
+
+          target = find_lowest_ceiling_around(idx) - 4
+          @active_doors[idx] = {
+            sector: sector,
+            state: DOOR_OPENING,
+            target_height: target,
+            original_height: sector.ceiling_height,
+            wait_tics: 0,
+            stay_open: stay_open,
+          }
+        end
+        @sound&.door_open
+      end
+
+      # Lift: lower floor to lowest adjacent, wait, raise back
+      def activate_lift(linedef)
+        tag = linedef.tag
+        return if tag == 0
+
+        activated = false
+        @map.sectors.each_with_index do |sector, idx|
+          next unless sector_has_tag?(idx, tag)
+          next if @active_lifts[idx]  # Already moving
+
+          lowest = find_lowest_floor_around(idx)
+          @active_lifts[idx] = {
+            sector: sector,
+            state: :lowering,
+            target_low: lowest,
+            original_height: sector.floor_height,
+            wait_tics: 0,
+          }
+          activated = true
+        end
+        @sound&.platform_start if activated
+      end
+
+      def update_lifts
+        @active_lifts.each do |idx, lift|
+          case lift[:state]
+          when :lowering
+            lift[:sector].floor_height -= LIFT_SPEED
+            if lift[:sector].floor_height <= lift[:target_low]
+              lift[:sector].floor_height = lift[:target_low]
+              lift[:state] = :waiting
+              lift[:wait_tics] = LIFT_WAIT
+              @sound&.platform_stop
+            end
+          when :waiting
+            lift[:wait_tics] -= 1
+            if lift[:wait_tics] <= 0
+              lift[:state] = :raising
+              @sound&.platform_start
+            end
+          when :raising
+            lift[:sector].floor_height += LIFT_SPEED
+            if lift[:sector].floor_height >= lift[:original_height]
+              lift[:sector].floor_height = lift[:original_height]
+              @active_lifts.delete(idx)
+              @sound&.platform_stop
+            end
+          end
+        end
+      end
+
+      def raise_floor_to_next(linedef)
+        tag = linedef.tag
+        return if tag == 0
+
+        @map.sectors.each_with_index do |sector, idx|
+          next unless sector_has_tag?(idx, tag)
+          target = find_next_higher_floor(idx)
+          next if target <= sector.floor_height
+
+          @active_lifts[idx] = {
+            sector: sector,
+            state: :raising,
+            target_low: sector.floor_height,
+            original_height: target,
+            wait_tics: 0,
+          }
+        end
+      end
+
+      def lower_floor_to_lowest(linedef)
+        tag = linedef.tag
+        return if tag == 0
+
+        @map.sectors.each_with_index do |sector, idx|
+          next unless sector_has_tag?(idx, tag)
+          target = find_lowest_floor_around(idx)
+          sector.floor_height = target
+        end
+      end
+
+      def lower_floor_to_highest(linedef)
+        tag = linedef.tag
+        return if tag == 0
+
+        @map.sectors.each_with_index do |sector, idx|
+          next unless sector_has_tag?(idx, tag)
+          target = find_highest_floor_around(idx) - 8
+          sector.floor_height = target if target < sector.floor_height
+        end
+      end
+
+      def teleport_player(linedef)
+        tag = linedef.tag
+        return if tag == 0
+
+        # Find teleport destination thing (type 14) in tagged sector
+        @map.things.each do |thing|
+          next unless thing.type == 14  # Teleport destination
+          sector = @map.sector_at(thing.x, thing.y)
+          next unless sector
+          sector_idx = @map.sectors.index(sector)
+          next unless sector_has_tag?(sector_idx, tag)
+
+          @teleport_dest = { x: thing.x, y: thing.y, angle: thing.angle }
+          return
+        end
+      end
+
+
+      def check_secrets
+        # Build set of secret sector indices on first call
+        @secret_sectors ||= Set.new(
+          @map.sectors.each_with_index.filter_map { |s, i| i if s.special == 9 }
+        )
+        return if @secret_sectors.empty?
+
+        # Find which sector the player is in via BSP subsector lookup
+        subsector = @map.subsector_at(@player_x, @player_y)
+        return unless subsector
+
+        seg = @map.segs[subsector.first_seg]
+        return unless seg
+
+        ld = @map.linedefs[seg.linedef]
+        return unless ld
+
+        sd_idx = seg.direction == 0 ? ld.sidedef_right : ld.sidedef_left
+        return if sd_idx == 0xFFFF
+
+        sector_idx = @map.sidedefs[sd_idx].sector
+        return if @secrets_found[sector_idx]
+
+        if @secret_sectors.include?(sector_idx)
+          @secrets_found[sector_idx] = true
+          # Clear the special so it doesn't retrigger (matching Chocolate Doom)
+          @map.sectors[sector_idx].special = 0
+          @secret_sectors.delete(sector_idx)
+        end
+      end
+
+      def sector_has_tag?(sector_idx, tag)
+        @map.sectors[sector_idx].tag == tag
+      end
+
+      def find_lowest_floor_around(sector_idx)
+        lowest = @map.sectors[sector_idx].floor_height
+        each_adjacent_sector(sector_idx) do |adj|
+          lowest = adj.floor_height if adj.floor_height < lowest
+        end
+        lowest
+      end
+
+      def find_highest_floor_around(sector_idx)
+        highest = -32768
+        each_adjacent_sector(sector_idx) do |adj|
+          highest = adj.floor_height if adj.floor_height > highest
+        end
+        highest == -32768 ? @map.sectors[sector_idx].floor_height : highest
+      end
+
+      def find_next_higher_floor(sector_idx)
+        current = @map.sectors[sector_idx].floor_height
+        best = Float::INFINITY
+        each_adjacent_sector(sector_idx) do |adj|
+          if adj.floor_height > current && adj.floor_height < best
+            best = adj.floor_height
+          end
+        end
+        best == Float::INFINITY ? current : best
+      end
+
+      def each_adjacent_sector(sector_idx)
+        @map.linedefs.each do |ld|
+          next unless ld.two_sided?
+          right = @map.sidedefs[ld.sidedef_right]
+          left = @map.sidedefs[ld.sidedef_left] if ld.sidedef_left != 0xFFFF
+          next unless left
+
+          if right.sector == sector_idx
+            yield @map.sectors[left.sector]
+          elsif left.sector == sector_idx
+            yield @map.sectors[right.sector]
+          end
+        end
+      end
     end
   end
 end

data/lib/doom/game/sound_engine.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # Plays sound effects for game events.
+    class SoundEngine
+      # Weapon fire sounds
+      WEAPON_SOUNDS = {
+        PlayerState::WEAPON_FIST => 'DSPUNCH',
+        PlayerState::WEAPON_PISTOL => 'DSPISTOL',
+        PlayerState::WEAPON_SHOTGUN => 'DSSHOTGN',
+        PlayerState::WEAPON_CHAINGUN => 'DSPISTOL',
+        PlayerState::WEAPON_ROCKET => 'DSRLAUNC',
+        PlayerState::WEAPON_PLASMA => 'DSPLASMA',
+        PlayerState::WEAPON_BFG => 'DSBFG',
+        PlayerState::WEAPON_CHAINSAW => 'DSSAWIDL',
+      }.freeze
+
+      # Monster see/activation sounds (from mobjinfo seesound)
+      MONSTER_SEE = {
+        3004 => 'DSPOSIT1',  # Zombieman
+        9    => 'DSSGTSIT',  # Shotgun Guy
+        3001 => 'DSBGSIT1',  # Imp
+        3002 => 'DSSGTSIT',  # Demon
+        58   => 'DSSGTSIT',  # Spectre
+        3003 => 'DSBRSSIT',  # Baron
+        69   => 'DSBRSSIT',  # Hell Knight
+        3005 => 'DSCACSIT',  # Cacodemon
+        3006 => 'DSSKLATK',  # Lost Soul
+        65   => 'DSPOSIT2',  # Heavy Weapon Dude
+        16   => 'DSCYBSIT',  # Cyberdemon
+        7    => 'DSSPISIT',  # Spider Mastermind
+      }.freeze
+
+      # Monster death sounds (from mobjinfo deathsound)
+      MONSTER_DEATH = {
+        3004 => 'DSPODTH1',  # Zombieman
+        9    => 'DSSGTDTH',  # Shotgun Guy
+        3001 => 'DSBGDTH1',  # Imp
+        3002 => 'DSSGTDTH',  # Demon
+        58   => 'DSSGTDTH',  # Spectre
+        3003 => 'DSBRSDTH',  # Baron
+        69   => 'DSBRSDTH',  # Hell Knight
+        3005 => 'DSCACDTH',  # Cacodemon
+        3006 => 'DSFIRXPL',  # Lost Soul
+        65   => 'DSPODTH2',  # Heavy Weapon Dude
+        16   => 'DSCYBDTH',  # Cyberdemon
+        7    => 'DSSPIDTH',  # Spider Mastermind
+      }.freeze
+
+      # Monster pain sounds (from mobjinfo painsound)
+      MONSTER_PAIN = {
+        3004 => 'DSPOPAIN',  # Zombieman
+        9    => 'DSPOPAIN',  # Shotgun Guy
+        3001 => 'DSDMPAIN',  # Imp
+        3002 => 'DSDMPAIN',  # Demon
+        58   => 'DSDMPAIN',  # Spectre
+        3003 => 'DSDMPAIN',  # Baron
+        69   => 'DSDMPAIN',  # Hell Knight
+        3005 => 'DSDMPAIN',  # Cacodemon
+        3006 => 'DSDMPAIN',  # Lost Soul
+        65   => 'DSPOPAIN',  # Heavy Weapon Dude
+      }.freeze
+
+      # Monster attack sounds (from mobjinfo attacksound)
+      MONSTER_ATTACK = {
+        3004 => 'DSPISTOL',  # Zombieman: pistol
+        9    => 'DSSHOTGN',  # Shotgun Guy: shotgun
+        3001 => 'DSFIRSHT',  # Imp: fireball launch
+        3002 => 'DSSGTATK',  # Demon: bite
+        58   => 'DSSGTATK',  # Spectre: bite
+        3003 => 'DSFIRSHT',  # Baron: fireball
+        69   => 'DSFIRSHT',  # Hell Knight: fireball
+        3005 => 'DSFIRSHT',  # Cacodemon: fireball
+        65   => 'DSSHOTGN',  # Heavy Weapon Dude: chaingun burst
+      }.freeze
+
+      def initialize(sound_manager)
+        @sounds = sound_manager
+        @last_played = {}  # Throttle rapid repeats
+      end
+
+      def play(name, volume: 1.0, throttle: 0)
+        now = Time.now.to_f
+        if throttle > 0
+          return if @last_played[name] && (now - @last_played[name]) < throttle
+        end
+        sample = @sounds[name]
+        sample&.play(volume)
+        @last_played[name] = now
+      end
+
+      # --- Menu sounds ---
+      def menu_move
+        play('DSPSTOP', throttle: 0.05)
+      end
+
+      def menu_select
+        play('DSPISTOL')
+      end
+
+      def menu_back
+        play('DSSWTCHX')
+      end
+
+      # --- Weapon events ---
+      def weapon_fire(weapon)
+        sound = WEAPON_SOUNDS[weapon]
+        play(sound, throttle: 0.05) if sound
+      end
+
+      def shotgun_cock
+        play('DSSGCOCK', throttle: 0.3)
+      end
+
+      def chainsaw_hit
+        play('DSSAWFUL', throttle: 0.1)
+      end
+
+      # --- Player events ---
+      def player_pain
+        play('DSPLPAIN', throttle: 0.3)
+      end
+
+      def player_death
+        play('DSPLDETH')
+      end
+
+      def item_pickup
+        play('DSITEMUP', throttle: 0.1)
+      end
+
+      def weapon_pickup
+        play('DSWPNUP')
+      end
+
+      def oof
+        play('DSOOF', throttle: 0.3)
+      end
+
+      def noway
+        play('DSNOWAY', throttle: 0.3)
+      end
+
+      # --- Door/environment sounds ---
+      def door_open
+        play('DSDOROPN', throttle: 0.2)
+      end
+
+      def door_close
+        play('DSDORCLS', throttle: 0.2)
+      end
+
+      def switch_activate
+        play('DSSWTCHN')
+      end
+
+      def platform_start
+        play('DSPSTART', throttle: 0.2)
+      end
+
+      def platform_stop
+        play('DSPSTOP', throttle: 0.2)
+      end
+
+      # --- Monster sounds ---
+      def monster_see(type)
+        sound = MONSTER_SEE[type]
+        play(sound, throttle: 0.5) if sound
+      end
+
+      def monster_death(type)
+        sound = MONSTER_DEATH[type]
+        play(sound) if sound
+      end
+
+      def monster_pain(type)
+        sound = MONSTER_PAIN[type]
+        play(sound, throttle: 0.2) if sound
+      end
+
+      def monster_attack(type)
+        sound = MONSTER_ATTACK[type]
+        play(sound, throttle: 0.1) if sound
+      end
+
+      # --- Explosions / impacts ---
+      def explosion
+        play('DSBAREXP')
+      end
+
+      def rocket_explode
+        play('DSRXPLOD')
+      end
+
+      def fireball_hit
+        play('DSFIRXPL', throttle: 0.1)
+      end
+    end
+  end
+end