doom 0.8.0 → 0.11.0

data/lib/doom/game/combat.rb

@@ -2,41 +2,42 @@
 
 module Doom
   module Game
-    # Hitscan weapon firing and monster state tracking.
-    # Matches Chocolate Doom's P_LineAttack / P_AimLineAttack from p_map.c.
+    # Combat resolution for every weapon and every damageable thing: hitscan
+    # (pistol/shotgun/chaingun), melee (fist/chainsaw), rockets and their splash,
+    # monster fireballs, barrel chain reactions, player-vs-player damage and frag
+    # scoring. Hitscan/aim matches Chocolate Doom's P_LineAttack / P_AimLineAttack
+    # (p_map.c); splash matches P_RadiusAttack (p_inter.c).
     class Combat
       # Monster starting HP (from mobjinfo[] in info.c)
       MONSTER_HP = {
-        3004 => 20,   # Zombieman
-        9    => 30,   # Shotgun Guy
+        3004 => 20, # Zombieman
+        9 => 30, # Shotgun Guy
         3001 => 60,   # Imp
         3002 => 150,  # Demon
-        58   => 150,  # Spectre
+        58 => 150, # Spectre
         3003 => 1000, # Baron of Hell
-        69   => 500,  # Hell Knight
+        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
-        2035 => 20,   # Explosive barrel
+        16 => 4000, # Cyberdemon
+        7 => 3000, # Spider Mastermind
+        65 => 70,   # Heavy Weapon Dude
+        64 => 700,  # Archvile
+        71 => 400,  # Pain Elemental
+        84 => 20,   # Wolfenstein SS
+        2035 => 20 # Explosive barrel
       }.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,
-        2035 => 10,  # Barrel
+        2035 => 10 # Barrel
       }.freeze
 
-      # Barrel (explosive, not a monster but damageable)
+      # Barrel (explosive, not a monster but damageable). Its HP comes from
+      # MONSTER_HP[BARREL_TYPE]; its explosion reuses the shared SPLASH_* values.
       BARREL_TYPE = 2035
-      BARREL_HP = 20
-      BARREL_SPLASH_RADIUS = 128.0
-      BARREL_SPLASH_DAMAGE = 128
 
       # Normal death frame sequences per sprite prefix (rotation 0 only)
       # Identified by sprite heights: frames go from standing height to flat on ground
@@ -54,18 +55,18 @@ module Doom
         '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
-        'BEXP' => %w[A B C D E],       # Barrel explosion
+        'BEXP' => %w[A B C D E] # Barrel explosion
       }.freeze
 
-      DEATH_ANIM_TICS = 6  # Tics per death frame
+      DEATH_ANIM_TICS = 6 # Tics per death frame
 
       # Pain chance per monster (out of 256, from mobjinfo)
       PAIN_CHANCE = {
         3004 => 200, 9 => 170, 3001 => 200, 3002 => 180, 58 => 180,
         3003 => 50, 69 => 50, 3005 => 128, 3006 => 256, 16 => 40,
-        7 => 40, 65 => 170, 64 => 10, 71 => 128, 84 => 170,
+        7 => 40, 65 => 170, 64 => 10, 71 => 128, 84 => 170
       }.freeze
-      PAIN_DURATION = 6  # Tics monster is stunned when in pain
+      PAIN_DURATION = 6 # Tics monster is stunned when in pain
 
       # Projectile constants
       ROCKET_SPEED = 20.0       # Map units per tic (matches DOOM's mobjinfo MISSILESPEED)
@@ -74,31 +75,43 @@ module Doom
       SPLASH_RADIUS = 128.0     # Splash damage radius
       SPLASH_DAMAGE = 128       # Max splash damage at center
 
-      # Monster projectile definitions
+      # Monster projectile definitions. :radius is the projectile's own collision
+      # radius, added to the player radius when testing a hit.
       MONSTER_PROJECTILES = {
-        imp:    { sprite: 'BAL1', speed: 10.0, damage: [3, 24], radius: 6, splash: false },
-        baron:  { sprite: 'BAL7', speed: 15.0, damage: [8, 64], radius: 6, splash: false },
-        caco:   { sprite: 'BAL2', speed: 10.0, damage: [5, 40], radius: 6, splash: false },
+        imp: { sprite: 'BAL1', speed: 10.0, damage: [3, 24], radius: 6 },
+        baron: { sprite: 'BAL7', speed: 15.0, damage: [8, 64], radius: 6 },
+        caco: { sprite: 'BAL2', speed: 10.0, damage: [5, 40], radius: 6 }
       }.freeze
 
       # Map monster type to projectile type
       MONSTER_PROJECTILE_TYPE = {
         3001 => :imp,     # Imp
         3003 => :baron,   # Baron
-        69   => :baron,   # Hell Knight
-        3005 => :caco,    # Cacodemon
+        69 => :baron, # Hell Knight
+        3005 => :caco # Cacodemon
       }.freeze
 
-      Projectile = Struct.new(:x, :y, :z, :dx, :dy, :dz, :type, :spawn_tic, :sprite_prefix, :target)
+      # Radius used when a shot or a rocket is tested against a player. Matches
+      # the 16 the monster-projectile collision already assumed.
+      PLAYER_RADIUS = 16
+
+      # `owner` is the Player who fired, so a kill can be credited. Monster
+      # projectiles leave it nil: DOOM gives no frag for a death by monster.
+      # `damage_multiplier` scales the damage a monster fireball deals on impact,
+      # so a skill's damage factor reaches the fireball it spawned. Player
+      # projectiles (rockets) carry 1.0.
+      Projectile = Struct.new(:x, :y, :z, :dx, :dy, :dz, :type, :spawn_tic, :sprite_prefix,
+                              :target, :owner, :damage_multiplier)
 
       # 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, hidden_things = {}, sound_engine = nil)
+      def initialize(map, sprites = nil, hidden_things = {}, sound_engine = nil,
+                     random: Random.new)
         @map = map
-        @player = player_state
+        @random = random
         @sprites = sprites
         @hidden_things = hidden_things
         @sound = sound_engine
@@ -108,30 +121,26 @@ module Doom
         @projectiles = []    # Active projectiles in flight
         @explosions = []     # Active explosions (for rendering)
         @puffs = []          # Bullet puff effects
-        @player_x = 0.0
-        @player_y = 0.0
-        @player_z = 0.0
+        @players = []
         @tic = 0
       end
 
-      def update_player_pos(x, y, z = nil)
-        @player_x = x
-        @player_y = y
-        @player_z = z if z
-      end
+      # Every player the world knows about. Projectile collision, splash damage
+      # and monster aim all consider all of them, not one bound player.
+      attr_accessor :players
 
       # Spawn a monster projectile (fireball, etc.)
       # Matches Chocolate Doom's P_SpawnMissile: calculates momz for vertical aim
-      def spawn_monster_projectile(monster_x, monster_y, monster_z, monster_type, damage_multiplier)
+      def spawn_monster_projectile(monster_x, monster_y, monster_z, monster_type, damage_multiplier, target)
         proj_type = MONSTER_PROJECTILE_TYPE[monster_type]
         return unless proj_type
 
         info = MONSTER_PROJECTILES[proj_type]
         return unless info
 
-        dx = @player_x - monster_x
-        dy = @player_y - monster_y
-        dist = Math.sqrt(dx * dx + dy * dy)
+        dx = target.x - monster_x
+        dy = target.y - monster_y
+        dist = Math.sqrt((dx * dx) + (dy * dy))
         return if dist < 1
 
         # Normalize direction and apply speed
@@ -141,18 +150,18 @@ module Doom
 
         # P_SpawnMissile: momz = (target.z - source.z) / (dist / speed)
         # This makes the projectile arc toward the target's height
-        target_z = @player_z - 16  # Aim at player center (z + height/2, roughly)
+        target_z = target.z - 16 # Aim at player center (z + height/2, roughly)
         travel_tics = dist / speed
         travel_tics = 1.0 if travel_tics < 1.0
         ndz = (target_z - monster_z) / travel_tics
 
         @projectiles << Projectile.new(
-          monster_x + ndx * 2, monster_y + ndy * 2, monster_z,
-          ndx, ndy, ndz, proj_type, @tic, info[:sprite], :player
+          monster_x + (ndx * 2), monster_y + (ndy * 2), monster_z,
+          ndx, ndy, ndz, proj_type, @tic, info[:sprite], :player, nil, damage_multiplier
         )
       end
 
-      attr_reader :dead_things, :projectiles, :explosions, :puffs
+      attr_reader :dead_things, :projectiles, :explosions, :puffs, :sprites
 
       def in_pain?(thing_idx)
         @pain_until[thing_idx] && @tic < @pain_until[thing_idx]
@@ -175,19 +184,17 @@ module Doom
         frame_idx = elapsed / DEATH_ANIM_TICS
 
         # Barrels disappear after explosion animation (S_NULL in Chocolate Doom)
-        if thing_type == BARREL_TYPE && frame_idx >= frames.size
-          return nil
-        end
+        return nil if thing_type == BARREL_TYPE && frame_idx >= frames.size
 
         frame_idx = frame_idx.clamp(0, frames.size - 1)
         frame_letter = frames[frame_idx]
 
         # Use prefix directly if it differs from the thing's sprite (e.g. BEXP for barrels)
         thing_prefix = @sprites.prefix_for(thing_type)
-        if prefix != thing_prefix
-          @sprites.get_frame_by_prefix(prefix, frame_letter)
-        else
+        if prefix == thing_prefix
           @sprites.get_frame(thing_type, frame_letter, viewer_angle, thing_angle)
+        else
+          @sprites.get_frame_by_prefix(prefix, frame_letter)
         end
       end
 
@@ -199,32 +206,71 @@ module Doom
         @puffs.reject! { |p| @tic - p[:tic] > 12 }
       end
 
-      # Fire the current weapon
-      def fire(px, py, pz, cos_a, sin_a, weapon)
+      # Fire the current weapon. `shooter` is the Player pulling the trigger,
+      # needed to credit a deathmatch kill and to stop a shot from hitting the
+      # person who fired it.
+      def fire(px, py, pz, cos_a, sin_a, weapon, shooter = nil)
         case weapon
         when PlayerState::WEAPON_PISTOL, PlayerState::WEAPON_CHAINGUN
-          hitscan(px, py, cos_a, sin_a, 1, 0.0, 5)
+          hitscan(px, py, pz, cos_a, sin_a, 1, 0.0, 5, shooter)
         when PlayerState::WEAPON_SHOTGUN
-          hitscan(px, py, cos_a, sin_a, 7, Math::PI / 32, 5)
+          hitscan(px, py, pz, cos_a, sin_a, 7, Math::PI / 32, 5, shooter)
         when PlayerState::WEAPON_ROCKET
-          spawn_rocket(px, py, pz, cos_a, sin_a)
+          spawn_rocket(px, py, pz, cos_a, sin_a, shooter)
         when PlayerState::WEAPON_FIST
-          melee(px, py, cos_a, sin_a, 2, 64)
+          melee(px, py, cos_a, sin_a, 2, 64, shooter)
         when PlayerState::WEAPON_CHAINSAW
-          melee(px, py, cos_a, sin_a, 2, 64)
+          melee(px, py, cos_a, sin_a, 2, 64, shooter)
         end
       end
 
       private
 
-      def spawn_rocket(px, py, pz, cos_a, sin_a)
+      def spawn_rocket(px, py, pz, cos_a, sin_a, shooter = nil)
         @projectiles << Projectile.new(
-          px + cos_a * 20, py + sin_a * 20, pz,
+          px + (cos_a * 20), py + (sin_a * 20), pz,
           cos_a * ROCKET_SPEED, sin_a * ROCKET_SPEED, 0.0,
-          :rocket, @tic, 'MISL', :monsters
+          :rocket, @tic, 'MISL', :monsters, shooter, 1.0
         )
       end
 
+      # Players a shot fired by `shooter` may hit: everyone alive except the
+      # shooter, who cannot hit themselves with a bullet or a fist.
+      #
+      # Not gated on the mode. Vanilla DOOM has no friendly-fire switch --
+      # P_DamageMobj checks nothing about who is shooting whom -- so co-op
+      # players hurt each other exactly as deathmatch ones do. In single player
+      # this is empty anyway, the only player being the shooter.
+      def player_targets(shooter)
+        @players.reject { |pl| pl.state.dead || pl.equal?(shooter) }
+      end
+
+      # Damage a player and score the kill in the same place, so no damage path
+      # can quietly forget to. `attacker` is the Player responsible, or nil when
+      # a monster or the level itself did it.
+      def damage_player(victim, damage, attacker)
+        return if damage <= 0
+        return if victim.state.dead
+
+        victim.state.take_damage(damage)
+        return unless victim.state.dead
+
+        record_frag(victim, attacker)
+      end
+
+      # DOOM's scoring: killing someone else is worth a frag, killing yourself
+      # costs one, and being killed by a monster or the environment is worth
+      # nothing either way.
+      def record_frag(victim, attacker)
+        return unless attacker
+
+        if attacker.equal?(victim)
+          victim.frags -= 1
+        else
+          attacker.frags += 1
+        end
+      end
+
       def update_projectiles
         @projectiles.reject! do |proj|
           new_x = proj.x + proj.dx
@@ -235,9 +281,7 @@ module Doom
 
           # Check if projectile hit the floor or ceiling
           sector = @map.sector_at(new_x, new_y)
-          if sector
-            hit_wall = true if new_z <= sector.floor_height || new_z >= sector.ceiling_height
-          end
+          hit_wall = true if sector && (new_z <= sector.floor_height || new_z >= sector.ceiling_height)
           hit = false
 
           if proj.target == :monsters
@@ -246,32 +290,52 @@ module Doom
             @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) + ROCKET_RADIUS
               dx = new_x - thing.x
               dy = new_y - thing.y
-              if dx * dx + dy * dy < radius * radius
+              if (dx * dx) + (dy * dy) < radius * radius
                 hit_monster = idx
                 break
               end
             end
 
-            if hit_wall || hit_monster
-              explode(new_x, new_y, hit_monster) if proj.type == :rocket
-              hit_monster ? apply_damage(hit_monster, (rand(8) + 1) * 5) : nil unless proj.type == :rocket
+            # In deathmatch a rocket also detonates on a player. There is no
+            # separate direct-hit damage: exploding on top of someone already
+            # deals full splash, which is close enough to DOOM's direct hit and
+            # keeps the RNG draws the same as any other detonation.
+            hit_player = player_targets(proj.owner).find do |pl|
+              radius = PLAYER_RADIUS + ROCKET_RADIUS
+              dx = new_x - pl.x
+              dy = new_y - pl.y
+              (dx * dx) + (dy * dy) < radius * radius
+            end
+
+            if hit_wall || hit_monster || hit_player
+              # Only rockets target :monsters, so the detonation is always a
+              # rocket explosion (direct hit plus splash).
+              explode(new_x, new_y, hit_monster, proj.owner)
               hit = true
             end
           elsif proj.target == :player
-            # Monster projectile: check player collision
-            player_radius = 16
-            dx = new_x - @player_x
-            dy = new_y - @player_y
-            if hit_wall || (dx * dx + dy * dy < (player_radius + 6) ** 2)
-              unless hit_wall
-                info = MONSTER_PROJECTILES[proj.type]
-                if info
-                  min_d, max_d = info[:damage]
-                  @player.take_damage(rand(min_d..max_d))
-                end
+            # Monster projectile: hits whichever player it reaches first, not
+            # only the one it was aimed at -- a fireball meant for someone else
+            # still hurts if you walk into it.
+            info = MONSTER_PROJECTILES[proj.type]
+            hit_radius = PLAYER_RADIUS + (info ? info[:radius] : 6)
+            struck = @players.find do |pl|
+              next false if pl.state.dead
+
+              dx = new_x - pl.x
+              dy = new_y - pl.y
+              (dx * dx) + (dy * dy) < hit_radius**2
+            end
+
+            if hit_wall || struck
+              if !hit_wall && struck && info
+                min_d, max_d = info[:damage]
+                damage = (@random.rand(min_d..max_d) * (proj.damage_multiplier || 1.0)).to_i
+                damage_player(struck, damage, nil)
               end
               # Spawn fireball explosion
               @explosions << { x: new_x, y: new_y, z: proj.z, tic: @tic, sprite: proj.sprite_prefix }
@@ -290,31 +354,53 @@ module Doom
         end
       end
 
-      def explode(x, y, direct_hit_idx)
+      def explode(x, y, direct_hit_idx, owner = nil)
         # Direct hit damage
         if direct_hit_idx
-          damage = (rand(8) + 1) * ROCKET_DAMAGE
+          damage = (@random.rand(8) + 1) * ROCKET_DAMAGE
           apply_damage(direct_hit_idx, damage)
         end
 
-        # Splash damage to all monsters in radius
+        splash_monsters(x, y, SPLASH_RADIUS, SPLASH_DAMAGE, direct_hit_idx)
+        splash_players(x, y, SPLASH_RADIUS, SPLASH_DAMAGE, owner)
+
+        # Spawn explosion visual
+        @explosions << { x: x, y: y, tic: @tic, sprite: 'MISL' }
+      end
+
+      # Splash damage to every monster (and barrel, for chain reactions) in
+      # radius, falling off linearly, skipping any dead thing and the excluded
+      # index (a rocket's direct-hit target or the barrel that just went off).
+      def splash_monsters(x, y, radius, max_damage, exclude_idx)
         @map.things.each_with_index do |thing, idx|
           next unless MONSTER_HP[thing.type]
           next if @dead_things[idx]
-          next if idx == direct_hit_idx  # Already took direct hit
+          next if idx == exclude_idx
 
           dx = x - thing.x
           dy = y - thing.y
-          dist = Math.sqrt(dx * dx + dy * dy)
-          next if dist >= SPLASH_RADIUS
+          dist = Math.sqrt((dx * dx) + (dy * dy))
+          next if dist >= radius
 
-          # Damage falls off linearly with distance
-          damage = ((SPLASH_DAMAGE * (1.0 - dist / SPLASH_RADIUS))).to_i
+          damage = (max_damage * (1.0 - (dist / radius))).to_i
           apply_damage(idx, damage) if damage > 0
         end
+      end
 
-        # Spawn explosion visual
-        @explosions << { x: x, y: y, tic: @tic, sprite: 'MISL' }
+      # Splash reaches the shooter too, which is how a rocket suicide happens.
+      #
+      # In every mode, single player included. PIT_RadiusAttack damages every
+      # shootable thing in range and never excludes the bomb source, which is
+      # why firing a rocket at your own feet has always been fatal in DOOM.
+      def splash_players(x, y, radius, max_damage, attacker)
+        @players.each do |pl|
+          next if pl.state.dead
+
+          dist = Math.hypot(x - pl.x, y - pl.y)
+          next unless dist < radius
+
+          damage_player(pl, (max_damage * (1.0 - (dist / radius))).to_i, attacker)
+        end
       end
 
       def update_explosions
@@ -336,7 +422,7 @@ module Doom
             bs = @map.sectors[back.sector]
             max_floor = [fs.floor_height, bs.floor_height].max
             min_ceil = [fs.ceiling_height, bs.ceiling_height].min
-            blocks = (min_ceil - max_floor) < 1  # Closed door/wall
+            blocks = (min_ceil - max_floor) < 1 # Closed door/wall
           else
             next
           end
@@ -344,34 +430,21 @@ module Doom
 
           v1 = @map.vertices[ld.v1]
           v2 = @map.vertices[ld.v2]
-          if segments_intersect?(x1, y1, x2, y2, v1.x, v1.y, v2.x, v2.y)
-            return true
-          end
+          return true if Geometry.segments_intersect?(x1, y1, x2, y2, v1.x, v1.y, v2.x, v2.y)
         end
         false
       end
 
-      def segments_intersect?(ax1, ay1, ax2, ay2, bx1, by1, bx2, by2)
-        d1x = ax2 - ax1; d1y = ay2 - ay1
-        d2x = bx2 - bx1; d2y = by2 - by1
-        denom = d1x * d2y - d1y * d2x
-        return false if denom.abs < 0.001
-        dx = bx1 - ax1; dy = by1 - ay1
-        t = (dx * d2y - dy * d2x).to_f / denom
-        u = (dx * d1y - dy * d1x).to_f / denom
-        t > 0.0 && t < 1.0 && u >= 0.0 && u <= 1.0
-      end
-
-      def hitscan(px, py, cos_a, sin_a, pellets, spread, multiplier)
+      def hitscan(px, py, pz, cos_a, sin_a, pellets, spread, multiplier, shooter = nil)
         pellets.times do
           # Add random spread
           if spread > 0
-            angle = Math.atan2(sin_a, cos_a) + (rand - 0.5) * spread * 2
+            angle = Math.atan2(sin_a, cos_a) + ((@random.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
+            angle = Math.atan2(sin_a, cos_a) + ((@random.rand - 0.5) * 0.04)
             ca = Math.cos(angle)
             sa = Math.sin(angle)
           end
@@ -379,6 +452,7 @@ module Doom
           wall_dist = trace_wall(px, py, ca, sa)
 
           best_idx = nil
+          best_player = nil
           best_dist = wall_dist
 
           @map.things.each_with_index do |thing, idx|
@@ -394,21 +468,36 @@ module Doom
             end
           end
 
+          # Players compete with monsters for the same ray: whoever is nearest
+          # takes the bullet, so you cannot shoot through someone to hit the
+          # imp behind them.
+          player_targets(shooter).each do |pl|
+            hit_dist = ray_circle_hit(px, py, ca, sa, pl.x, pl.y, PLAYER_RADIUS)
+            next unless hit_dist && hit_dist > 0 && hit_dist < best_dist
+
+            best_dist = hit_dist
+            best_player = pl
+            best_idx = nil
+          end
+
           # Spawn bullet puff at hit location
-          puff_x = px + ca * best_dist
-          puff_y = py + sa * best_dist
-          puff_z = @player_z
+          puff_x = px + (ca * best_dist)
+          puff_y = py + (sa * best_dist)
+          puff_z = pz
           @puffs << { x: puff_x, y: puff_y, z: puff_z, tic: @tic }
 
-          if best_idx
-            damage = (rand(3) + 1) * multiplier
+          if best_player
+            damage_player(best_player, (@random.rand(3) + 1) * multiplier, shooter)
+          elsif best_idx
+            damage = (@random.rand(3) + 1) * multiplier
             apply_damage(best_idx, damage)
           end
         end
       end
 
-      def melee(px, py, cos_a, sin_a, multiplier, range)
+      def melee(px, py, cos_a, sin_a, multiplier, range, shooter = nil)
         best_idx = nil
+        best_player = nil
         best_dist = range.to_f
 
         @map.things.each_with_index do |thing, idx|
@@ -417,11 +506,11 @@ module Doom
 
           dx = thing.x - px
           dy = thing.y - py
-          dist = Math.sqrt(dx * dx + dy * dy)
+          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
+          dot = (dx * cos_a) + (dy * sin_a)
           next if dot < 0
 
           if dist < best_dist
@@ -430,8 +519,23 @@ module Doom
           end
         end
 
-        if best_idx
-          damage = (rand(3) + 1) * multiplier
+        player_targets(shooter).each do |pl|
+          dx = pl.x - px
+          dy = pl.y - py
+          dist = Math.hypot(dx, dy)
+          next if dist > range + PLAYER_RADIUS
+          next if (dx * cos_a) + (dy * sin_a) < 0 # behind the swing
+          next unless dist < best_dist
+
+          best_dist = dist
+          best_player = pl
+          best_idx = nil
+        end
+
+        if best_player
+          damage_player(best_player, (@random.rand(3) + 1) * multiplier, shooter)
+        elsif best_idx
+          damage = (@random.rand(3) + 1) * multiplier
           apply_damage(best_idx, damage)
         end
       end
@@ -443,7 +547,7 @@ module Doom
         @monster_hp[thing_idx] -= damage
 
         if @monster_hp[thing_idx] <= 0
-          return if @dead_things[thing_idx]  # Already dead
+          return if @dead_things[thing_idx] # Already dead
 
           if thing.type == BARREL_TYPE
             @dead_things[thing_idx] = { tic: @tic, prefix: 'BEXP' }
@@ -458,7 +562,7 @@ module Doom
           # Pain state: monster flinches (not barrels)
           if thing.type != BARREL_TYPE
             pain_chance = PAIN_CHANCE[thing.type] || 128
-            if rand(256) < pain_chance
+            if @random.rand(256) < pain_chance
               @pain_until[thing_idx] = @tic + PAIN_DURATION
               @sound&.monster_pain(thing.type)
             end
@@ -469,33 +573,15 @@ module Doom
       def barrel_explode(x, y, barrel_idx)
         @explosions << { x: x, y: y, tic: @tic, sprite: 'MISL' }
 
-        # Splash damage to monsters and other barrels (chain reactions!)
-        @map.things.each_with_index do |thing, idx|
-          next unless MONSTER_HP[thing.type]
-          next if @dead_things[idx]
-          next if idx == barrel_idx
-
-          dx = x - thing.x
-          dy = y - thing.y
-          dist = Math.sqrt(dx * dx + dy * dy)
-          next if dist >= BARREL_SPLASH_RADIUS
-
-          damage = ((BARREL_SPLASH_DAMAGE * (1.0 - dist / BARREL_SPLASH_RADIUS))).to_i
-          apply_damage(idx, damage) if damage > 0
-        end
-
-        # Splash damage to player
-        dx = x - @player_x
-        dy = y - @player_y
-        dist = Math.sqrt(dx * dx + dy * dy)
-        if dist < BARREL_SPLASH_RADIUS
-          damage = ((BARREL_SPLASH_DAMAGE * (1.0 - dist / BARREL_SPLASH_RADIUS))).to_i
-          @player.take_damage(damage) if damage > 0
-        end
+        # Splash damage to monsters and other barrels (chain reactions!), then to
+        # every player in radius including the one who set it off. Nobody is
+        # credited: the barrel is not a player, and we do not track who shot it.
+        splash_monsters(x, y, SPLASH_RADIUS, SPLASH_DAMAGE, barrel_idx)
+        splash_players(x, y, SPLASH_RADIUS, SPLASH_DAMAGE, nil)
       end
 
       def trace_wall(px, py, cos_a, sin_a)
-        best_t = 4096.0  # Max hitscan range
+        best_t = 4096.0 # Max hitscan range
 
         @map.linedefs.each do |ld|
           v1 = @map.vertices[ld.v1]
@@ -520,7 +606,7 @@ module Doom
           next unless blocks
 
           t = ray_segment_intersect(px, py, cos_a, sin_a,
-                                     v1.x, v1.y, v2.x, v2.y)
+                                    v1.x, v1.y, v2.x, v2.y)
           best_t = t if t && t > 0 && t < best_t
         end
 
@@ -530,25 +616,25 @@ module Doom
       def ray_segment_intersect(px, py, dx, dy, x1, y1, x2, y2)
         sx = x2 - x1
         sy = y2 - y1
-        denom = dx * sy - dy * sx
+        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 = (((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
+        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
+        proj = (dx * cos_a) + (dy * sin_a)
         return nil if proj < 0
 
-        perp_sq = dx * dx + dy * dy - proj * proj
+        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)
+        chord_half = Math.sqrt([(radius * radius) - perp_sq, 0].max)
         proj - chord_half
       end
     end