doom 0.6.0 → 0.11.0

data/lib/doom/game/sector_actions.rb

@@ -1,64 +1,251 @@
 # frozen_string_literal: true
 
+require 'set'
+
 module Doom
   module Game
     # Manages animated sector actions (doors, lifts, etc.)
     class SectorActions
-      # Door states
-      DOOR_CLOSED = 0
+      # Door states (doors start at DOOR_OPENING and are deleted once fully
+      # closed, so there is no resting DOOR_CLOSED state to model).
       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
+      DOOR_WAIT = 150 # Tics to wait when open (~4 seconds)
+
+      # Lift constants
+      LIFT_SPEED = 4
+      LIFT_WAIT = 105 # ~3 seconds
+
+      attr_reader :exit_triggered, :secrets_found
+
+      # Pending teleports, drained by the world once per tic: a map of
+      # player_id => destination. Each player teleports to its own destination,
+      # so a single shared slot (which only ever moved player 0) is not enough
+      # in a multiplayer world.
+      def pop_teleports
+        dests = @teleport_dests
+        @teleport_dests = {}
+        dests
+      end
 
-      def initialize(map)
+      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
+        @player_positions = [] # [[player_id, x, y], ...] in id order
+        @exit_triggered = nil
+        @secrets_found = {}  # sector_index => true
+        @crossed_linedefs = {}
+        @near_linedefs = {}  # player_id => { linedef_idx => side }
+        @teleport_dests = {} # player_id => { x:, y:, angle: }
       end
 
+      # Single-player convenience used by the unit specs and by the world's
+      # use-line ray cast: treat the given point as player 0's position.
       def update_player_position(x, y)
         @player_x = x
         @player_y = y
+        @player_positions = [[0, x, y]]
+      end
+
+      # Feed every player's position (ordered by id) so walk triggers fire for
+      # each player independently and reproducibly. The primary (first) position
+      # also drives the single-player-only checks (secrets, door reopen).
+      def update_players(positions)
+        @player_positions = positions
+        first = positions.first
+        return unless first
+
+        @player_x = first[1]
+        @player_y = first[2]
       end
 
       def update
         update_doors
+        update_lifts
+        check_walk_triggers
+        check_secrets
       end
 
-      # Try to use a linedef (called when player presses use key)
-      def use_linedef(linedef, linedef_idx)
+      # Try to use a linedef (called when player presses use key). `keys` is the
+      # acting player's key ring (a hash like {blue_card: true}); locked doors
+      # consult it and refuse to open without the matching card.
+      def use_linedef(linedef, _linedef_idx, keys = {})
         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
+        when 26   # DR Blue Door
+          activate_door(linedef, key: :blue_card, keys: keys)
+        when 27   # DR Yellow Door
+          activate_door(linedef, key: :yellow_card, keys: keys)
+        when 28   # DR Red Door
+          activate_door(linedef, key: :red_card, keys: keys)
+        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
+        when 32   # D1 Blue Door Open Stay
+          activate_door(linedef, key: :blue_card, stay_open: true, keys: keys)
+        when 33   # D1 Red Door Open Stay
+          activate_door(linedef, key: :red_card, stay_open: true, keys: keys)
+        when 34   # D1 Yellow Door Open Stay
+          activate_door(linedef, key: :yellow_card, stay_open: true, keys: keys)
+        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
 
-      def activate_door(linedef, stay_open: false, key: nil)
+      # Walk-over trigger types:
+      # W1 = once, WR = repeatable
+      # Note: stair builders (specials 7 and 8) are not modeled, so they are
+      # intentionally absent here.
+      WALK_TRIGGERS = {
+        2 => :door_open_stay,    # W1 Door Open Stay
+        5 => :raise_floor,       # W1 Raise Floor to Lowest Ceiling
+        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, 52, 124].freeze
+
+      # Walk triggers fire per player: every player must be able to cross a line
+      # and set it off. Players are processed in a fixed id order so the tic is
+      # reproducible, and each player's side memory is tracked separately (a
+      # shared record would let one player's crossing state clobber another's).
+      def check_walk_triggers
+        @near_linedefs ||= {}
+
+        @player_positions.each do |(pid, px, py)|
+          sides = (@near_linedefs[pid] ||= {})
+          check_walk_triggers_for(pid, px, py, sides)
+        end
+      end
+
+      def check_walk_triggers_for(pid, px, py, sides)
+        @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 (level-global: once any player crosses,
+          # it is spent), so the crossed record stays shared across players.
+          next if W1_TYPES.include?(ld.special) && @crossed_linedefs[idx]
+
+          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(px, py, v1.x, v1.y, v2.x, v2.y)
+          dist = Geometry.point_to_segment_distance(px, py, v1.x, v1.y, v2.x, v2.y)
+
+          near = dist < 32 # Detection range
+          prev_side = sides[idx]
+
+          if near && prev_side && prev_side != side
+            # Player crossed the line - trigger!
+            sides[idx] = side
+          elsif near && prev_side.nil?
+            # First time near - record side but don't trigger yet
+            sides[idx] = side
+            next
+          elsif !near
+            sides[idx] = nil
+            next
+          else
+            next # Same side, no crossing
+          end
+
+          @crossed_linedefs[idx] = true
+          fire_walk_action(action, ld, pid)
+        end
+      end
+
+      def fire_walk_action(action, ld, pid)
+        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_lowest_ceiling(ld)
+        when :lower_floor
+          lower_floor_to_highest(ld)
+        when :teleport
+          teleport_player(ld, pid)
+        end
+      end
+
+      # Returns which side of a line a point is on, as an integer (1 = front,
+      # 0 = back). An integer rather than a symbol so the value serializes
+      # cleanly into the snapshot's per-player side memory.
+      def line_side(px, py, x1, y1, x2, y2)
+        cross = ((x2 - x1) * (py - y1)) - ((y2 - y1) * (px - x1))
+        cross >= 0 ? 1 : 0
+      end
+
+      def activate_door(linedef, stay_open: false, key: nil, keys: {})
+        # Locked doors refuse to open without the matching key. Refusal changes
+        # no state (deterministic), and plays the "no way" grunt if a sound
+        # engine is attached.
+        if key && !keys[key]
+          @sound&.noway
+          return
+        end
+
         # Find the sector on the back side of the linedef
         return unless linedef.two_sided?
 
@@ -74,9 +261,7 @@ module Doom
         if @active_doors[sector_idx]
           door = @active_doors[sector_idx]
           # If closing, reverse direction
-          if door[:state] == DOOR_CLOSING
-            door[:state] = DOOR_OPENING
-          end
+          door[:state] = DOOR_OPENING if door[:state] == DOOR_CLOSING
           return
         end
 
@@ -92,6 +277,7 @@ module Doom
           wait_tics: 0,
           stay_open: stay_open
         }
+        @sound&.door_open
       end
 
       def update_doors
@@ -113,6 +299,7 @@ module Doom
             door[:wait_tics] -= 1
             if door[:wait_tics] <= 0
               door[:state] = DOOR_CLOSING
+              @sound&.door_close
             end
 
           when DOOR_CLOSING
@@ -150,13 +337,263 @@ module Doom
             adjacent_sector = @map.sectors[right_sidedef.sector]
           end
 
-          if adjacent_sector
-            lowest = [lowest, adjacent_sector.ceiling_height].min
-          end
+          lowest = [lowest, adjacent_sector.ceiling_height].min if adjacent_sector
         end
 
         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
+          when :floor_lowering
+            # One-way floor lower (e.g. special 23): lower to target and stay.
+            lift[:sector].floor_height -= LIFT_SPEED
+            if lift[:sector].floor_height <= lift[:target_low]
+              lift[:sector].floor_height = lift[:target_low]
+              @active_lifts.delete(idx)
+            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
+
+      # Specials 5 (W1) and 91 (WR): DOOM's raiseFloor mover raises the floor
+      # to the lowest ceiling among surrounding sectors. Both specials use the
+      # same mover in vanilla, so they are not split here.
+      def raise_floor_to_lowest_ceiling(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_ceiling_around(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)
+          next if @active_lifts[idx] # Already moving
+
+          target = find_lowest_floor_around(idx)
+          next if target >= sector.floor_height
+
+          # Animate the lower (matching the raise movers) instead of snapping.
+          @active_lifts[idx] = {
+            sector: sector,
+            state: :floor_lowering,
+            target_low: target,
+            original_height: sector.floor_height,
+            wait_tics: 0
+          }
+        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, player_id)
+        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_dests[player_id] = { 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]
+
+        return unless @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
+
+      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 = -32_768
+        each_adjacent_sector(sector_idx) do |adj|
+          highest = adj.floor_height if adj.floor_height > highest
+        end
+        highest == -32_768 ? @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|
+          best = adj.floor_height if adj.floor_height > current && adj.floor_height < best
+        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/sector_effects.rb

@@ -10,8 +10,9 @@ module Doom
       FASTDARK     = 15  # Dark duration for fast strobe (tics)
       SLOWDARK     = 35  # Dark duration for slow strobe (tics)
 
-      def initialize(map)
+      def initialize(map, random: Random.new)
         @map = map
+        @random = random
         @effects = []
         @scroll_sides = []
         spawn_specials
@@ -29,27 +30,28 @@ module Doom
         @map.sectors.each do |sector|
           case sector.special
           when 1      # Flickering lights
-            @effects << LightFlash.new(sector, find_min_light(sector))
+            @effects << LightFlash.new(sector, find_min_light(sector), @random)
           when 2      # Fast strobe
-            @effects << StrobeFlash.new(sector, find_min_light(sector), FASTDARK, false)
+            @effects << StrobeFlash.new(sector, find_min_light(sector), FASTDARK, false, @random)
           when 3      # Slow strobe
-            @effects << StrobeFlash.new(sector, find_min_light(sector), SLOWDARK, false)
+            @effects << StrobeFlash.new(sector, find_min_light(sector), SLOWDARK, false, @random)
           when 4      # Fast strobe + 20% damage
-            @effects << StrobeFlash.new(sector, find_min_light(sector), FASTDARK, false)
+            @effects << StrobeFlash.new(sector, find_min_light(sector), FASTDARK, false, @random)
           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)
+            @effects << StrobeFlash.new(sector, find_min_light(sector), SLOWDARK, true, @random)
           when 13     # Sync strobe fast
-            @effects << StrobeFlash.new(sector, find_min_light(sector), FASTDARK, true)
+            @effects << StrobeFlash.new(sector, find_min_light(sector), FASTDARK, true, @random)
           when 17     # Fire flicker
-            @effects << FireFlicker.new(sector, find_min_light(sector))
+            @effects << FireFlicker.new(sector, find_min_light(sector), @random)
           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
@@ -64,8 +66,10 @@ module Doom
         @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
 
@@ -82,11 +86,12 @@ module Doom
 
       # T_LightFlash (type 1): mostly bright with brief random dark flickers
       class LightFlash
-        def initialize(sector, minlight)
+        def initialize(sector, minlight, random)
           @sector = sector
+          @random = random
           @maxlight = sector.light_level
           @minlight = minlight
-          @count = (rand(65)) + 1
+          @count = @random.rand(65) + 1
         end
 
         def update
@@ -95,24 +100,25 @@ module Doom
 
           if @sector.light_level == @maxlight
             @sector.light_level = @minlight
-            @count = (rand(8)) + 1       # dark for 1-8 tics
+            @count = @random.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)
+            @count = (@random.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)
+        def initialize(sector, minlight, darktime, in_sync, random)
           @sector = sector
+          @random = random
           @maxlight = sector.light_level
           @minlight = minlight
           @minlight = 0 if @minlight == @maxlight
           @darktime = darktime
           @brighttime = STROBEBRIGHT
-          @count = in_sync ? 1 : (rand(8)) + 1
+          @count = in_sync ? 1 : @random.rand(8) + 1
         end
 
         def update
@@ -135,7 +141,7 @@ module Doom
           @sector = sector
           @maxlight = sector.light_level
           @minlight = minlight
-          @direction = -1  # start dimming
+          @direction = -1 # start dimming
         end
 
         def update
@@ -157,10 +163,11 @@ module Doom
 
       # T_FireFlicker (type 17): random fire-like flickering
       class FireFlicker
-        def initialize(sector, minlight)
+        def initialize(sector, minlight, random)
           @sector = sector
           @maxlight = sector.light_level
-          @minlight = minlight + 16  # fire doesn't go as dark
+          @minlight = minlight + 16 # fire doesn't go as dark
+          @random = random
           @count = 4
         end
 
@@ -168,7 +175,7 @@ module Doom
           @count -= 1
           return if @count > 0
 
-          amount = (rand(4)) * 16  # 0, 16, 32, or 48
+          amount = @random.rand(4) * 16 # 0, 16, 32, or 48
           level = @maxlight - amount
           @sector.light_level = level < @minlight ? @minlight : level
           @count = 4