doom 0.6.0 → 0.11.0

data/lib/doom/game/combat.rb

@@ -2,34 +2,43 @@
 
 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
+        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
       }.freeze
 
+      # 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
+
       # Normal death frame sequences per sprite prefix (rotation 0 only)
       # Identified by sprite heights: frames go from standing height to flat on ground
       DEATH_FRAMES = {
@@ -46,9 +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
       }.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
+      }.freeze
+      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)
@@ -57,43 +75,127 @@ module Doom
       SPLASH_RADIUS = 128.0     # Splash damage radius
       SPLASH_DAMAGE = 128       # Max splash damage at center
 
-      Projectile = Struct.new(:x, :y, :z, :dx, :dy, :type, :spawn_tic)
+      # 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 },
+        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
+      }.freeze
+
+      # 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)
+      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
         @monster_hp = {}     # thing_idx => current HP
         @dead_things = {}    # thing_idx => { tic: death_start_tic, prefix: sprite_prefix }
+        @pain_until = {}     # thing_idx => tic when pain ends
         @projectiles = []    # Active projectiles in flight
         @explosions = []     # Active explosions (for rendering)
+        @puffs = []          # Bullet puff effects
+        @players = []
         @tic = 0
       end
 
-      attr_reader :dead_things, :projectiles, :explosions
+      # 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, target)
+        proj_type = MONSTER_PROJECTILE_TYPE[monster_type]
+        return unless proj_type
+
+        info = MONSTER_PROJECTILES[proj_type]
+        return unless info
+
+        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
+        speed = info[:speed]
+        ndx = dx / dist * speed
+        ndy = dy / dist * speed
+
+        # P_SpawnMissile: momz = (target.z - source.z) / (dist / speed)
+        # This makes the projectile arc toward the target's height
+        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, nil, damage_multiplier
+        )
+      end
+
+      attr_reader :dead_things, :projectiles, :explosions, :puffs, :sprites
+
+      def in_pain?(thing_idx)
+        @pain_until[thing_idx] && @tic < @pain_until[thing_idx]
+      end
 
       def dead?(thing_idx)
         @dead_things.key?(thing_idx)
       end
 
-      # Get the current death frame sprite for a dead monster
+      # Get the current death frame sprite for a dead monster/barrel
       def death_sprite(thing_idx, thing_type, viewer_angle, thing_angle)
         info = @dead_things[thing_idx]
         return nil unless info
 
-        frames = DEATH_FRAMES[info[:prefix]]
+        prefix = info[:prefix]
+        frames = DEATH_FRAMES[prefix]
         return nil unless frames
 
         elapsed = @tic - info[:tic]
-        frame_idx = (elapsed / DEATH_ANIM_TICS).clamp(0, frames.size - 1)
+        frame_idx = elapsed / DEATH_ANIM_TICS
+
+        # Barrels disappear after explosion animation (S_NULL in Chocolate Doom)
+        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]
 
-        @sprites.get_frame(thing_type, frame_letter, viewer_angle, thing_angle)
+        # 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(thing_type, frame_letter, viewer_angle, thing_angle)
+        else
+          @sprites.get_frame_by_prefix(prefix, frame_letter)
+        end
       end
 
       # Called each game tic
@@ -101,94 +203,204 @@ module Doom
         @tic += 1
         update_projectiles
         update_explosions
+        @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)
-        # Spawn slightly ahead of the player
+      def spawn_rocket(px, py, pz, cos_a, sin_a, shooter = nil)
         @projectiles << Projectile.new(
-          px + cos_a * 20, py + sin_a * 20, pz,
-          cos_a * ROCKET_SPEED, sin_a * ROCKET_SPEED,
-          :rocket, @tic
+          px + (cos_a * 20), py + (sin_a * 20), pz,
+          cos_a * ROCKET_SPEED, sin_a * ROCKET_SPEED, 0.0,
+          :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|
-          # Move projectile
           new_x = proj.x + proj.dx
           new_y = proj.y + proj.dy
+          new_z = proj.z + (proj.dz || 0)
 
-          # Check wall collision
           hit_wall = hits_wall?(proj.x, proj.y, new_x, new_y)
 
-          # Check monster collision
-          hit_monster = nil
-          @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
-              hit_monster = idx
-              break
+          # Check if projectile hit the floor or ceiling
+          sector = @map.sector_at(new_x, new_y)
+          hit_wall = true if sector && (new_z <= sector.floor_height || new_z >= sector.ceiling_height)
+          hit = false
+
+          if proj.target == :monsters
+            # Player projectile: check monster collision
+            hit_monster = nil
+            @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
+                hit_monster = idx
+                break
+              end
+            end
+
+            # 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: 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 }
+              hit = true
             end
           end
 
-          if hit_wall || hit_monster
-            explode(new_x, new_y, hit_monster)
-            true  # Remove projectile
+          if hit
+            true
           else
             proj.x = new_x
             proj.y = new_y
-            false # Keep projectile
+            proj.z = new_z
+            false
           end
         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 }
+      # 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
@@ -198,50 +410,41 @@ module Doom
 
       def hits_wall?(x1, y1, x2, y2)
         @map.linedefs.each do |ld|
-          # One-sided walls always block
-          blocks = ld.sidedef_left == 0xFFFF || (ld.flags & 0x0001 != 0)
-          unless blocks
-            next unless ld.sidedef_left < 0xFFFF
+          # One-sided walls always block projectiles
+          if ld.sidedef_left == 0xFFFF
+            blocks = true
+          elsif ld.sidedef_left < 0xFFFF
+            # Two-sided: only block if opening is too small for a projectile
+            # BLOCKING flag (0x0001) stops players/monsters but NOT projectiles
             front = @map.sidedefs[ld.sidedef_right]
             back = @map.sidedefs[ld.sidedef_left]
             fs = @map.sectors[front.sector]
             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) < 56
+            blocks = (min_ceil - max_floor) < 1 # Closed door/wall
+          else
+            next
           end
           next unless blocks
 
           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
@@ -249,9 +452,11 @@ 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|
+            next if @hidden_things[idx]
             next unless MONSTER_HP[thing.type]
             next if @dead_things[idx]
 
@@ -263,15 +468,36 @@ module Doom
             end
           end
 
-          if best_idx
-            damage = (rand(3) + 1) * multiplier
+          # 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 = pz
+          @puffs << { x: puff_x, y: puff_y, z: puff_z, tic: @tic }
+
+          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|
@@ -280,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
@@ -293,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
@@ -306,35 +547,66 @@ module Doom
         @monster_hp[thing_idx] -= damage
 
         if @monster_hp[thing_idx] <= 0
-          prefix = @sprites.prefix_for(thing.type)
-          @dead_things[thing_idx] = { tic: @tic, prefix: prefix } if prefix
+          return if @dead_things[thing_idx] # Already dead
+
+          if thing.type == BARREL_TYPE
+            @dead_things[thing_idx] = { tic: @tic, prefix: 'BEXP' }
+            @sound&.explosion
+            barrel_explode(thing.x, thing.y, thing_idx)
+          else
+            prefix = @sprites.prefix_for(thing.type)
+            @dead_things[thing_idx] = { tic: @tic, prefix: prefix } if prefix
+            @sound&.monster_death(thing.type)
+          end
+        else
+          # Pain state: monster flinches (not barrels)
+          if thing.type != BARREL_TYPE
+            pain_chance = PAIN_CHANCE[thing.type] || 128
+            if @random.rand(256) < pain_chance
+              @pain_until[thing_idx] = @tic + PAIN_DURATION
+              @sound&.monster_pain(thing.type)
+            end
+          end
         end
       end
 
+      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!), 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]
           v2 = @map.vertices[ld.v2]
 
-          # One-sided always blocks; two-sided only if impassable
-          blocks = (ld.sidedef_left == 0xFFFF) || (ld.flags & 0x0001 != 0)
-          unless blocks
-            next unless ld.sidedef_left < 0xFFFF
+          # One-sided always blocks hitscan
+          if ld.sidedef_left == 0xFFFF
+            blocks = true
+          elsif ld.sidedef_left < 0xFFFF
+            # Two-sided: only blocks if opening is too small
+            # BLOCKING flag does NOT stop hitscan (only affects movement)
             front = @map.sidedefs[ld.sidedef_right]
             back = @map.sidedefs[ld.sidedef_left]
             fs = @map.sectors[front.sector]
             bs = @map.sectors[back.sector]
-            # Blocks if opening is too small (step or low ceiling)
             max_floor = [fs.floor_height, bs.floor_height].max
             min_ceil = [fs.ceiling_height, bs.ceiling_height].min
             blocks = (min_ceil - max_floor) < 56
+          else
+            next
           end
           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
 
@@ -344,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