doom 0.5.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c4672b03d393f17c1cd9ece97869d7239a7af3e91d3ffa47b911b0ba3058f673
-  data.tar.gz: 56772f44ced59386c92f5319c0d25dc8612e96263d68ae7e9a240d26508571cf
+  metadata.gz: e59cb32b1487d61b1c310ee5eae7ec30a702c64129c7fe5e18e1c06204d08208
+  data.tar.gz: f8f5450c3c37d661618234cf0abe80a5f0cd796aaa13694ee35d786ef25c5728
 SHA512:
-  metadata.gz: b11b52ed631217b002aae05a4f87b7ff5fcb208485b75dd9077ebcc222c3823c6ca74167e9bc6b7c3605c0481472abbc818e6445c8fa130c744fe8c54da53099
-  data.tar.gz: 808176138162ef4e21796dd995a6bd794eee89e4c631032134349746afd468d446b610a0939daf19c26a2706abac22635306d6e3fb1c1c93e9a70282a2114f7d
+  metadata.gz: 4a65c31832aff4838f924eb1263bda1f16ef6e820da9d776fa759656fdb9a58d83b2146ea30d5e0c236d1fc9e39206ad14312191f3bf5db70597cec815aef113
+  data.tar.gz: f6215f28a05e9924b9864f2f51d36cd694c4abfe7c0ad1618116486f62c72d26b0d7f609e945725b2218ee4b3e77e13eb3316153396977bf773673185d93ba40

data/README.md

@@ -1,17 +1,19 @@
 # DOOM Ruby
 
-A faithful ruby port of the DOOM (1993) rendering engine to Ruby.
+A faithful port of the DOOM (1993) engine to pure Ruby. Renders the original WAD files with near pixel-perfect BSP rendering, full HUD, item pickups, and hitscan/projectile combat.
 
 ![DOOM Ruby](demo.gif)
 
 ## Features
 
-- Pure Ruby implementation of DOOM's BSP rendering engine
-- Accurate wall, floor, and ceiling rendering with proper texture mapping
-- Sprite rendering with depth-correct clipping
-- Original DOOM lighting and colormap support
-- Mouse look and WASD movement controls
-- Supports original WAD files (shareware and registered)
+- **Rendering**: BSP traversal, visplanes, drawsegs, sprite clipping, sky rendering matching Chocolate Doom
+- **Combat**: Hitscan weapons (pistol, shotgun, chaingun), melee (fist, chainsaw), projectile rockets with splash damage
+- **Items**: Weapons, ammo, health, armor, keys -- all pickupable with correct DOOM behavior
+- **Movement**: Momentum-based physics with friction, smooth step transitions, wall sliding, view bob
+- **HUD**: Full status bar with ammo, health, armor, face, weapon selector, key cards, small ammo counts
+- **Effects**: Animated textures (NUKAGE, SLADRIP), sector light effects (flickering, glowing, strobing), scrolling walls
+- **Monsters**: Death animations, solid collision, HP tracking
+- **Compatibility**: Supports original WAD files (shareware and registered), YJIT-optimized
 
 ## Installation
 
@@ -21,7 +23,7 @@ gem install doom
 
 ## Quick Start
 
-Just run `doom` - it will offer to download the free shareware version:
+Just run `doom` -- it will offer to download the free shareware version:
 
 ```bash
 doom
@@ -44,11 +46,16 @@ doom /path/to/doom.wad
 | Left Arrow | Turn left |
 | Right Arrow | Turn right |
 | Mouse | Look around (click to capture) |
+| Left Click / X / Shift | Fire weapon |
+| Space / E | Use (open doors) |
+| 1-7 | Switch weapons |
+| M | Toggle automap |
+| Z | Toggle debug overlay |
 | Escape | Release mouse / Quit |
 
 ## Requirements
 
-- Ruby 3.1 or higher
+- Ruby 3.1+ (Ruby 4.0 with YJIT recommended for best performance)
 - Gosu gem (for window/graphics)
 - SDL2 (native library required by Gosu)
 
@@ -61,7 +68,7 @@ brew install sdl2
 
 **Ubuntu/Debian:**
 ```bash
-sudo apt-get install build-essential libsdl2-dev libgl1-mesa-dev libfontconfig1-dev
+sudo apt-get install build-essential libsdl2-dev libgl1-mesa-dev libopenal-dev libsndfile1-dev libmpg123-dev libfontconfig1-dev
 ```
 
 **Fedora:**
@@ -75,15 +82,15 @@ sudo pacman -S sdl2 mesa
 ```
 
 **Windows:**
-No additional setup needed - the gem includes SDL2.
+No additional setup needed -- the gem includes SDL2.
 
 ## Development
 
 ```bash
-git clone https://github.com/khasinski/doom-rb.git
-cd doom-rb
+git clone https://github.com/khasinski/doom.git
+cd doom
 bundle install
-ruby bin/doom doom1.wad
+ruby bin/doom
 ```
 
 Run specs:
@@ -92,15 +99,30 @@ Run specs:
 bundle exec rspec
 ```
 
+### Benchmarking
+
+```bash
+ruby bench/benchmark.rb                     # without YJIT
+ruby --yjit bench/benchmark.rb              # with YJIT
+ruby bench/benchmark.rb --compare           # side-by-side
+ruby bench/benchmark.rb --profile           # CPU profile with StackProf
+```
+
 ## Technical Details
 
-This implementation includes:
+- **BSP Traversal**: Front-to-back rendering using the map's BSP tree with R_CheckBBox culling
+- **Visplanes**: Floor/ceiling rendering with R_CheckPlane splitting and span-based drawing
+- **Drawsegs**: Wall segment tracking for proper sprite clipping (silhouette system)
+- **Texture Mapping**: Perspective-correct ray-seg intersection with non-power-of-2 support
+- **Lighting**: Distance-based light diminishing with wall and flat colormaps
+- **Sky Rendering**: Chocolate Doom sky hack (worldtop = worldhigh) with correct placement
+- **Movement Physics**: Continuous-time momentum/friction matching Chocolate Doom's P_XYMovement
+- **Hitscan**: Ray tracing against walls and monster bounding circles
+- **Projectiles**: Physical rockets with wall/monster collision and splash damage
+
+## Performance
 
-- **BSP Traversal**: Front-to-back rendering using the map's BSP tree
-- **Visplanes**: Floor/ceiling rendering with R_CheckPlane splitting
-- **Drawsegs**: Wall segment tracking for proper sprite clipping
-- **Texture Mapping**: Perspective-correct texture coordinates
-- **Lighting**: Distance-based light diminishing with colormaps
+With Ruby 4.0 and YJIT enabled, the renderer achieves 80-130 FPS on E1M1 (Apple Silicon). See [docs/performance-profiling.md](docs/performance-profiling.md) and [docs/yjit-vs-zjit.md](docs/yjit-vs-zjit.md) for detailed analysis.
 
 ## Legal
 
@@ -112,7 +134,7 @@ please purchase DOOM from [Steam](https://store.steampowered.com/app/2280/Ultima
 
 ## License
 
-GPL-2.0 - Same license as the original DOOM source code.
+GPL-2.0 -- Same license as the original DOOM source code.
 
 ## Author
 

data/bin/doom

@@ -1,13 +1,18 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-# Enable YJIT if available (Ruby 3.1+) for better performance
-if defined?(RubyVM::YJIT) && RubyVM::YJIT.respond_to?(:enable)
-  RubyVM::YJIT.enable
+# Enable YJIT unless --no-yjit flag is passed (for live toggle demo)
+unless ARGV.delete('--no-yjit')
+  if defined?(RubyVM::YJIT) && RubyVM::YJIT.respond_to?(:enable)
+    RubyVM::YJIT.enable
+  end
 end
 
+# Parse flags
+rubykaigi_mode = ARGV.delete('--rubykaigi') || ARGV.delete('--kaigi')
+
 # Parse arguments before loading heavy dependencies
-wad_path = ARGV[0]
+wad_path = ARGV.find { |a| !a.start_with?('-') }
 
 # Show help (before loading anything)
 if wad_path == '-h' || wad_path == '--help'
@@ -49,7 +54,7 @@ require_relative '../lib/doom'
 begin
   # Find or download WAD
   wad_path = Doom::WadDownloader.ensure_wad_available(wad_path)
-  Doom.run(wad_path)
+  Doom.run(wad_path, rubykaigi: rubykaigi_mode)
 rescue Doom::WadDownloader::DownloadError => e
   puts "Error: #{e.message}"
   exit 1

data/lib/doom/game/combat.rb

@@ -22,14 +22,22 @@ module Doom
         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)
+      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
       DEATH_FRAMES = {
@@ -46,48 +54,149 @@ 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
 
+      # 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)
+      ROCKET_DAMAGE = 20        # Direct hit base (DOOM: 1d8 * 20)
+      ROCKET_RADIUS = 11        # Collision radius
+      SPLASH_RADIUS = 128.0     # Splash damage radius
+      SPLASH_DAMAGE = 128       # Max splash damage at center
+
+      # Monster projectile definitions
+      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 },
+      }.freeze
+
+      # Map monster type to projectile type
+      MONSTER_PROJECTILE_TYPE = {
+        3001 => :imp,     # Imp
+        3003 => :baron,   # Baron
+        69   => :baron,   # Hell Knight
+        3005 => :caco,    # Cacodemon
+      }.freeze
+
+      Projectile = Struct.new(:x, :y, :z, :dx, :dy, :dz, :type, :spawn_tic, :sprite_prefix, :target)
+
       # 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, player_state, sprites, hidden_things = {}, sound_engine = nil)
         @map = map
         @player = player_state
         @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
+        @player_x = 0.0
+        @player_y = 0.0
+        @player_z = 0.0
         @tic = 0
       end
 
-      attr_reader :dead_things
+      def update_player_pos(x, y, z = nil)
+        @player_x = x
+        @player_y = y
+        @player_z = z if z
+      end
+
+      # 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)
+        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)
+        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 = @player_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
+        )
+      end
+
+      attr_reader :dead_things, :projectiles, :explosions, :puffs
+
+      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)
+        if thing_type == BARREL_TYPE && frame_idx >= frames.size
+          return nil
+        end
+
+        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_by_prefix(prefix, frame_letter)
+        else
+          @sprites.get_frame(thing_type, frame_letter, viewer_angle, thing_angle)
+        end
       end
 
       # Called each game tic
       def update
         @tic += 1
+        update_projectiles
+        update_explosions
+        @puffs.reject! { |p| @tic - p[:tic] > 12 }
       end
 
       # Fire the current weapon
@@ -97,6 +206,8 @@ module Doom
           hitscan(px, py, cos_a, sin_a, 1, 0.0, 5)
         when PlayerState::WEAPON_SHOTGUN
           hitscan(px, py, cos_a, sin_a, 7, Math::PI / 32, 5)
+        when PlayerState::WEAPON_ROCKET
+          spawn_rocket(px, py, pz, cos_a, sin_a)
         when PlayerState::WEAPON_FIST
           melee(px, py, cos_a, sin_a, 2, 64)
         when PlayerState::WEAPON_CHAINSAW
@@ -106,6 +217,151 @@ module Doom
 
       private
 
+      def spawn_rocket(px, py, pz, cos_a, sin_a)
+        @projectiles << Projectile.new(
+          px + cos_a * 20, py + sin_a * 20, pz,
+          cos_a * ROCKET_SPEED, sin_a * ROCKET_SPEED, 0.0,
+          :rocket, @tic, 'MISL', :monsters
+        )
+      end
+
+      def update_projectiles
+        @projectiles.reject! do |proj|
+          new_x = proj.x + proj.dx
+          new_y = proj.y + proj.dy
+          new_z = proj.z + (proj.dz || 0)
+
+          hit_wall = hits_wall?(proj.x, proj.y, new_x, new_y)
+
+          # 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 = 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
+
+            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
+              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
+              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
+            true
+          else
+            proj.x = new_x
+            proj.y = new_y
+            proj.z = new_z
+            false
+          end
+        end
+      end
+
+      def explode(x, y, direct_hit_idx)
+        # Direct hit damage
+        if direct_hit_idx
+          damage = (rand(8) + 1) * ROCKET_DAMAGE
+          apply_damage(direct_hit_idx, damage)
+        end
+
+        # Splash damage to all monsters in radius
+        @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
+
+          dx = x - thing.x
+          dy = y - thing.y
+          dist = Math.sqrt(dx * dx + dy * dy)
+          next if dist >= SPLASH_RADIUS
+
+          # Damage falls off linearly with distance
+          damage = ((SPLASH_DAMAGE * (1.0 - dist / SPLASH_RADIUS))).to_i
+          apply_damage(idx, damage) if damage > 0
+        end
+
+        # Spawn explosion visual
+        @explosions << { x: x, y: y, tic: @tic, sprite: 'MISL' }
+      end
+
+      def update_explosions
+        # Explosions last 20 tics then disappear
+        @explosions.reject! { |e| @tic - e[:tic] > 20 }
+      end
+
+      def hits_wall?(x1, y1, x2, y2)
+        @map.linedefs.each do |ld|
+          # 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) < 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
+        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)
         pellets.times do
           # Add random spread
@@ -126,6 +382,7 @@ module Doom
           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]
 
@@ -137,6 +394,12 @@ module Doom
             end
           end
 
+          # Spawn bullet puff at hit location
+          puff_x = px + ca * best_dist
+          puff_y = py + sa * best_dist
+          puff_z = @player_z
+          @puffs << { x: puff_x, y: puff_y, z: puff_z, tic: @tic }
+
           if best_idx
             damage = (rand(3) + 1) * multiplier
             apply_damage(best_idx, damage)
@@ -180,8 +443,54 @@ 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 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!)
+        @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
       end
 
@@ -192,18 +501,21 @@ module Doom
           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