doom 0.8.0 → 0.11.0

data/lib/doom/game/sector_actions.rb

@@ -6,27 +6,30 @@ 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
+      DOOR_WAIT = 150 # Tics to wait when open (~4 seconds)
 
       # Lift constants
       LIFT_SPEED = 4
-      LIFT_WAIT = 105  # ~3 seconds
+      LIFT_WAIT = 105 # ~3 seconds
 
       attr_reader :exit_triggered, :secrets_found
 
-      def pop_teleport
-        dest = @teleport_dest
-        @teleport_dest = nil
-        dest
+      # 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, sound_engine = nil)
@@ -36,14 +39,32 @@ module Doom
         @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
@@ -53,8 +74,10 @@ module Doom
         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
@@ -62,24 +85,24 @@ module Doom
         when 1    # DR Door Open Wait Close
           activate_door(linedef)
         when 26   # DR Blue Door
-          activate_door(linedef, key: :blue_card)
+          activate_door(linedef, key: :blue_card, keys: keys)
         when 27   # DR Yellow Door
-          activate_door(linedef, key: :yellow_card)
+          activate_door(linedef, key: :yellow_card, keys: keys)
         when 28   # DR Red Door
-          activate_door(linedef, key: :red_card)
+          activate_door(linedef, key: :red_card, keys: keys)
         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)
+          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)
+          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)
+          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)
+        when 62 # SR Lift Lower Wait Raise (repeatable)
           activate_lift(linedef)
 
         # --- Floor changes ---
@@ -112,11 +135,11 @@ module Doom
 
       # 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
-        7  => :stairs,            # S1 Build Stairs
-        8  => :stairs,            # W1 Build Stairs
+        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
@@ -125,90 +148,104 @@ module Doom
         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
+        124 => :secret_exit # W1 Secret Exit
       }.freeze
 
       # W1 types that only trigger once
-      W1_TYPES = [2, 5, 7, 8, 52, 124].freeze
+      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
-          if W1_TYPES.include?(ld.special)
-            next if @crossed_linedefs[idx]
-          end
+          # 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(@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)
+          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 = @near_linedefs[idx]
+          near = dist < 32 # Detection range
+          prev_side = sides[idx]
 
           if near && prev_side && prev_side != side
             # Player crossed the line - trigger!
-            @near_linedefs[idx] = side
+            sides[idx] = side
           elsif near && prev_side.nil?
             # First time near - record side but don't trigger yet
-            @near_linedefs[idx] = side
+            sides[idx] = side
             next
           elsif !near
-            @near_linedefs[idx] = nil
+            sides[idx] = nil
             next
           else
-            next  # Same side, no crossing
+            next # Same side, no crossing
           end
 
           @crossed_linedefs[idx] = true
+          fire_walk_action(action, ld, pid)
+        end
+      end
 
-          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
+      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 (:front or :back)
+      # 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 ? :front : :back
+        cross = ((x2 - x1) * (py - y1)) - ((y2 - y1) * (px - x1))
+        cross >= 0 ? 1 : 0
       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, 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
 
-      def activate_door(linedef, stay_open: false, key: nil)
         # Find the sector on the back side of the linedef
         return unless linedef.two_sided?
 
@@ -224,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
 
@@ -302,9 +337,7 @@ 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
@@ -326,7 +359,7 @@ module Doom
             target_height: target,
             original_height: sector.ceiling_height,
             wait_tics: 0,
-            stay_open: stay_open,
+            stay_open: stay_open
           }
         end
         @sound&.door_open
@@ -340,7 +373,7 @@ module Doom
         activated = false
         @map.sectors.each_with_index do |sector, idx|
           next unless sector_has_tag?(idx, tag)
-          next if @active_lifts[idx]  # Already moving
+          next if @active_lifts[idx] # Already moving
 
           lowest = find_lowest_floor_around(idx)
           @active_lifts[idx] = {
@@ -348,7 +381,7 @@ module Doom
             state: :lowering,
             target_low: lowest,
             original_height: sector.floor_height,
-            wait_tics: 0,
+            wait_tics: 0
           }
           activated = true
         end
@@ -379,6 +412,13 @@ module Doom
               @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
@@ -389,6 +429,7 @@ module Doom
 
         @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
 
@@ -397,7 +438,30 @@ module Doom
             state: :raising,
             target_low: sector.floor_height,
             original_height: target,
-            wait_tics: 0,
+            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
@@ -408,8 +472,19 @@ module Doom
 
         @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)
-          sector.floor_height = target
+          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
 
@@ -419,29 +494,31 @@ module Doom
 
         @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)
+      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
+          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 }
+          @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(
@@ -465,12 +542,12 @@ module Doom
         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
+        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)
@@ -486,20 +563,18 @@ module Doom
       end
 
       def find_highest_floor_around(sector_idx)
-        highest = -32768
+        highest = -32_768
         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
+        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|
-          if adj.floor_height > current && adj.floor_height < best
-            best = adj.floor_height
-          end
+          best = adj.floor_height if adj.floor_height > current && adj.floor_height < best
         end
         best == Float::INFINITY ? current : best
       end
@@ -507,6 +582,7 @@ module Doom
       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

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