doom 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c4672b03d393f17c1cd9ece97869d7239a7af3e91d3ffa47b911b0ba3058f673
-  data.tar.gz: 56772f44ced59386c92f5319c0d25dc8612e96263d68ae7e9a240d26508571cf
+  metadata.gz: c3cb562e8b88b905638cfa8792337bc1b7f818753fa90587bda474784513a6bd
+  data.tar.gz: 1f421713b797c02dfc10e2f9bdd3ad0981a631f88bc94df161aa5a792b539094
 SHA512:
-  metadata.gz: b11b52ed631217b002aae05a4f87b7ff5fcb208485b75dd9077ebcc222c3823c6ca74167e9bc6b7c3605c0481472abbc818e6445c8fa130c744fe8c54da53099
-  data.tar.gz: 808176138162ef4e21796dd995a6bd794eee89e4c631032134349746afd468d446b610a0939daf19c26a2706abac22635306d6e3fb1c1c93e9a70282a2114f7d
+  metadata.gz: b06fd18ebfa1c5755e27c11b49e9e568fc4e2acfc7bc2b9760e7b7dda500a438afe9a6ecf0e33aa4f17c2271a6c28205e6bbb793e3b9c618c4df24b8bf74679a
+  data.tar.gz: ed5387b2c42963956cfe42c1cfe790a8f7f0e89a15c5a38934780b5ceaca34e3e64456756280d9c8f2d280763ef0fff89434dd8e826dc2e9e0184e25c4f94508

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,9 +1,11 @@
 #!/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 arguments before loading heavy dependencies

data/lib/doom/game/combat.rb

@@ -50,6 +50,15 @@ module Doom
 
       DEATH_ANIM_TICS = 6  # Tics per death frame
 
+      # 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
+
+      Projectile = Struct.new(:x, :y, :z, :dx, :dy, :type, :spawn_tic)
+
       # 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
@@ -61,10 +70,12 @@ module Doom
         @sprites = sprites
         @monster_hp = {}     # thing_idx => current HP
         @dead_things = {}    # thing_idx => { tic: death_start_tic, prefix: sprite_prefix }
+        @projectiles = []    # Active projectiles in flight
+        @explosions = []     # Active explosions (for rendering)
         @tic = 0
       end
 
-      attr_reader :dead_things
+      attr_reader :dead_things, :projectiles, :explosions
 
       def dead?(thing_idx)
         @dead_things.key?(thing_idx)
@@ -88,6 +99,8 @@ module Doom
       # Called each game tic
       def update
         @tic += 1
+        update_projectiles
+        update_explosions
       end
 
       # Fire the current weapon
@@ -97,6 +110,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 +121,117 @@ module Doom
 
       private
 
+      def spawn_rocket(px, py, pz, cos_a, sin_a)
+        # Spawn slightly ahead of the player
+        @projectiles << Projectile.new(
+          px + cos_a * 20, py + sin_a * 20, pz,
+          cos_a * ROCKET_SPEED, sin_a * ROCKET_SPEED,
+          :rocket, @tic
+        )
+      end
+
+      def update_projectiles
+        @projectiles.reject! do |proj|
+          # Move projectile
+          new_x = proj.x + proj.dx
+          new_y = proj.y + proj.dy
+
+          # 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
+            end
+          end
+
+          if hit_wall || hit_monster
+            explode(new_x, new_y, hit_monster)
+            true  # Remove projectile
+          else
+            proj.x = new_x
+            proj.y = new_y
+            false # Keep projectile
+          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 }
+      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
+          blocks = ld.sidedef_left == 0xFFFF || (ld.flags & 0x0001 != 0)
+          unless blocks
+            next unless ld.sidedef_left < 0xFFFF
+            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
+          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

data/lib/doom/game/monster_ai.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # Basic monster AI: idle until seeing player, then chase.
+    # Matches Chocolate Doom's A_Look / A_Chase / P_NewChaseDir from p_enemy.c.
+    class MonsterAI
+      # 8 movement directions + no direction
+      DI_EAST = 0; DI_NORTHEAST = 1; DI_NORTH = 2; DI_NORTHWEST = 3
+      DI_WEST = 4; DI_SOUTHWEST = 5; DI_SOUTH = 6; DI_SOUTHEAST = 7
+      DI_NODIR = 8
+
+      # Movement deltas per direction (map units, 1.0 = FRACUNIT)
+      XSPEED = [1.0, 0.7071, 0.0, -0.7071, -1.0, -0.7071, 0.0, 0.7071].freeze
+      YSPEED = [0.0, 0.7071, 1.0, 0.7071, 0.0, -0.7071, -1.0, -0.7071].freeze
+
+      OPPOSITE = [DI_WEST, DI_SOUTHWEST, DI_SOUTH, DI_SOUTHEAST,
+                  DI_EAST, DI_NORTHEAST, DI_NORTH, DI_NORTHWEST, DI_NODIR].freeze
+
+      # Monster speeds (from mobjinfo)
+      MONSTER_SPEED = {
+        3004 => 8, 9 => 8, 3001 => 8, 3002 => 10, 58 => 10,
+        3003 => 8, 69 => 8, 3005 => 8, 3006 => 8, 16 => 16,
+        7 => 12, 65 => 8, 64 => 15, 71 => 8, 84 => 8,
+      }.freeze
+
+      CHASE_TICS = 4       # Steps between A_Chase calls
+      SIGHT_RANGE = 768.0  # Max distance for sight check (DOOM uses sector sound propagation, we approximate)
+      MELEE_RANGE = 64.0
+
+      # Direction to angle (for sprite facing)
+      DIR_ANGLES = [0, 45, 90, 135, 180, 225, 270, 315].freeze
+
+      MonsterState = Struct.new(:thing_idx, :x, :y, :movedir, :movecount,
+                                :active, :chase_timer, :type)
+
+      def initialize(map, combat)
+        @map = map
+        @combat = combat
+        @monsters = []
+
+        map.things.each_with_index do |thing, idx|
+          next unless Combat::MONSTER_HP[thing.type]
+          @monsters << MonsterState.new(
+            idx, thing.x.to_f, thing.y.to_f,
+            DI_NODIR, 0, false, 0, thing.type
+          )
+        end
+      end
+
+      attr_reader :monsters
+
+      # Called each game tic
+      def update(player_x, player_y)
+        @monsters.each do |mon|
+          next if @combat.dead?(mon.thing_idx)
+
+          if mon.active
+            mon.chase_timer -= 1
+            if mon.chase_timer <= 0
+              mon.chase_timer = CHASE_TICS
+              chase(mon, player_x, player_y)
+            end
+          else
+            look(mon, player_x, player_y)
+          end
+        end
+      end
+
+      private
+
+      def look(mon, player_x, player_y)
+        dx = player_x - mon.x
+        dy = player_y - mon.y
+        dist = Math.sqrt(dx * dx + dy * dy)
+        return if dist > SIGHT_RANGE
+
+        # DOOM A_Look: monster only sees in ~180-degree forward arc
+        # unless player is very close (melee range)
+        if dist > MELEE_RANGE
+          thing = @map.things[mon.thing_idx]
+          face_angle = thing.angle * Math::PI / 180.0
+          to_player = Math.atan2(dy, dx)
+          angle_diff = ((to_player - face_angle + Math::PI) % (2 * Math::PI) - Math::PI).abs
+          return if angle_diff > Math::PI / 2  # 90 degrees each side = 180 arc
+        end
+
+        if has_line_of_sight?(mon.x, mon.y, player_x, player_y)
+          mon.active = true
+          mon.chase_timer = CHASE_TICS
+        end
+      end
+
+      def chase(mon, player_x, player_y)
+        speed = MONSTER_SPEED[mon.type] || 8
+
+        # Decrement movecount; pick new direction when expired or blocked
+        mon.movecount -= 1
+        if mon.movecount < 0 || !try_move(mon, speed)
+          new_chase_dir(mon, player_x, player_y)
+        end
+
+        # Update the thing's position and facing angle in the map for rendering
+        thing = @map.things[mon.thing_idx]
+        thing.x = mon.x.to_i
+        thing.y = mon.y.to_i
+
+        # Face toward the player (smooth turning)
+        target_angle = Math.atan2(player_y - mon.y, player_x - mon.x) * 180.0 / Math::PI
+        thing.angle = target_angle.round.to_i
+      end
+
+      def try_move(mon, speed)
+        return false if mon.movedir == DI_NODIR
+
+        new_x = mon.x + speed * XSPEED[mon.movedir]
+        new_y = mon.y + speed * YSPEED[mon.movedir]
+
+        # Check if the position is valid (inside a sector, not blocked by walls)
+        sector = @map.sector_at(new_x, new_y)
+        return false unless sector
+
+        # Check wall collision
+        blocked = false
+        @map.linedefs.each do |ld|
+          v1 = @map.vertices[ld.v1]
+          v2 = @map.vertices[ld.v2]
+
+          # Simple line-circle intersection
+          radius = Combat::MONSTER_RADIUS[mon.type] || 20
+          next unless line_circle_intersect?(v1.x, v1.y, v2.x, v2.y, new_x, new_y, radius)
+
+          # One-sided walls always block
+          if ld.sidedef_left == 0xFFFF
+            blocked = true
+            break
+          end
+
+          # Two-sided: check step height and headroom
+          if ld.sidedef_left < 0xFFFF
+            front = @map.sectors[@map.sidedefs[ld.sidedef_right].sector]
+            back = @map.sectors[@map.sidedefs[ld.sidedef_left].sector]
+            step = (back.floor_height - front.floor_height).abs
+            min_ceil = [front.ceiling_height, back.ceiling_height].min
+            max_floor = [front.floor_height, back.floor_height].max
+            if step > 24 || (min_ceil - max_floor) < 56
+              blocked = true
+              break
+            end
+          end
+        end
+        return false if blocked
+
+        mon.x = new_x
+        mon.y = new_y
+        true
+      end
+
+      def new_chase_dir(mon, player_x, player_y)
+        deltax = player_x - mon.x
+        deltay = player_y - mon.y
+        old_dir = mon.movedir
+
+        # Determine preferred directions
+        dir_x = if deltax > 10 then DI_EAST
+                elsif deltax < -10 then DI_WEST
+                else DI_NODIR
+                end
+
+        dir_y = if deltay > 10 then DI_NORTH
+                elsif deltay < -10 then DI_SOUTH
+                else DI_NODIR
+                end
+
+        # Try diagonal
+        if dir_x != DI_NODIR && dir_y != DI_NODIR
+          diag = diagonal_dir(dir_x, dir_y)
+          if diag != OPPOSITE[old_dir]
+            mon.movedir = diag
+            if try_walk(mon)
+              return
+            end
+          end
+        end
+
+        # Randomly swap X/Y priority
+        if rand > 0.22 || deltay.abs > deltax.abs
+          dir_x, dir_y = dir_y, dir_x
+        end
+
+        # Try primary direction
+        if dir_x != DI_NODIR && dir_x != OPPOSITE[old_dir]
+          mon.movedir = dir_x
+          return if try_walk(mon)
+        end
+
+        # Try secondary direction
+        if dir_y != DI_NODIR && dir_y != OPPOSITE[old_dir]
+          mon.movedir = dir_y
+          return if try_walk(mon)
+        end
+
+        # Try old direction
+        if old_dir != DI_NODIR
+          mon.movedir = old_dir
+          return if try_walk(mon)
+        end
+
+        # Try all other directions
+        start = rand(8)
+        8.times do |i|
+          d = (start + i) % 8
+          next if d == OPPOSITE[old_dir]
+          mon.movedir = d
+          return if try_walk(mon)
+        end
+
+        # Last resort: turnaround
+        if old_dir != DI_NODIR
+          mon.movedir = OPPOSITE[old_dir]
+          return if try_walk(mon)
+        end
+
+        mon.movedir = DI_NODIR
+      end
+
+      def try_walk(mon)
+        speed = MONSTER_SPEED[mon.type] || 8
+        if try_move(mon, speed)
+          mon.movecount = rand(16)
+          true
+        else
+          false
+        end
+      end
+
+      def diagonal_dir(dx, dy)
+        case [dx, dy]
+        when [DI_EAST, DI_NORTH] then DI_NORTHEAST
+        when [DI_EAST, DI_SOUTH] then DI_SOUTHEAST
+        when [DI_WEST, DI_NORTH] then DI_NORTHWEST
+        when [DI_WEST, DI_SOUTH] then DI_SOUTHWEST
+        else DI_NODIR
+        end
+      end
+
+      def has_line_of_sight?(x1, y1, x2, y2)
+        # Check if any wall blocks the line of sight
+        @map.linedefs.each do |ld|
+          v1 = @map.vertices[ld.v1]
+          v2 = @map.vertices[ld.v2]
+
+          next unless segments_intersect?(x1, y1, x2, y2, v1.x, v1.y, v2.x, v2.y)
+
+          # One-sided walls always block
+          return false if ld.sidedef_left == 0xFFFF
+
+          # Two-sided: check if opening is big enough to see through
+          if ld.sidedef_left < 0xFFFF
+            front = @map.sectors[@map.sidedefs[ld.sidedef_right].sector]
+            back = @map.sectors[@map.sidedefs[ld.sidedef_left].sector]
+            max_floor = [front.floor_height, back.floor_height].max
+            min_ceil = [front.ceiling_height, back.ceiling_height].min
+            # Block sight if the opening is too small
+            return false if (min_ceil - max_floor) < 1
+          end
+        end
+        true
+      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 line_circle_intersect?(x1, y1, x2, y2, cx, cy, radius)
+        dx = cx - x1; dy = cy - y1
+        line_dx = x2 - x1; line_dy = y2 - y1
+        line_len_sq = line_dx * line_dx + line_dy * line_dy
+        return false if line_len_sq == 0
+        t = ((dx * line_dx) + (dy * line_dy)) / line_len_sq
+        t = [[t, 0.0].max, 1.0].min
+        closest_x = x1 + t * line_dx; closest_y = y1 + t * line_dy
+        dist_sq = (cx - closest_x) ** 2 + (cy - closest_y) ** 2
+        dist_sq < radius * radius
+      end
+    end
+  end
+end

data/lib/doom/game/player_state.rb

@@ -46,6 +46,8 @@ module Doom
       attr_accessor :attacking, :attack_frame, :attack_tics
       attr_accessor :bob_angle, :bob_amount
       attr_accessor :is_moving
+      attr_accessor :dead, :death_tic
+      attr_accessor :damage_count  # Red flash intensity (0-8), decays each tic
 
       # Smooth step-up/down (matching Chocolate Doom's P_CalcHeight / P_ZMovement)
       VIEWHEIGHT = 41.0
@@ -107,6 +109,11 @@ module Doom
         @attack_frame = 0
         @attack_tics = 0
 
+        # Death state
+        @dead = false
+        @death_tic = 0
+        @damage_count = 0
+
         # Weapon bob
         @bob_angle = 0.0
         @bob_amount = 0.0
@@ -308,6 +315,42 @@ module Doom
 
         @weapon = weapon_num
       end
+
+      # Apply damage (from environment or enemies). Armor absorbs some.
+      def take_damage(amount)
+        return if @dead
+
+        absorbed = 0
+        if @armor > 0
+          absorbed = amount / 3  # Green armor absorbs 1/3
+          absorbed = @armor if absorbed > @armor
+          @armor -= absorbed
+        end
+
+        actual = amount - absorbed
+        @health -= actual
+
+        # Red flash proportional to damage (capped at palette 8)
+        @damage_count = [(@damage_count + actual / 2.0).ceil, 8].min
+
+        if @health <= 0
+          @health = 0
+          @damage_count = 8
+          die
+        end
+      end
+
+      # Decay damage flash each tic
+      def update_damage_count
+        @damage_count -= 1 if @damage_count > 0
+      end
+
+      def die
+        @dead = true
+        @death_tic = 0
+        @attacking = false
+        @deltaviewheight = -VIEWHEIGHT / 8.0  # View drops to ground
+      end
     end
   end
 end

data/lib/doom/platform/gosu_window.rb

@@ -48,9 +48,11 @@ module Doom
         2046 => 16,                                          # Burning barrel
       }.freeze
 
-      def initialize(renderer, palette, map, player_state = nil, status_bar = nil, weapon_renderer = nil, sector_actions = nil, animations = nil, sector_effects = nil, item_pickup = nil, combat = nil)
-        super(Render::SCREEN_WIDTH * SCALE, Render::SCREEN_HEIGHT * SCALE, false)
+      def initialize(renderer, palette, map, player_state = nil, status_bar = nil, weapon_renderer = nil, sector_actions = nil, animations = nil, sector_effects = nil, item_pickup = nil, combat = nil, monster_ai = nil)
+        fullscreen = ARGV.include?('--fullscreen') || ARGV.include?('-f')
+        super(Render::SCREEN_WIDTH * SCALE, Render::SCREEN_HEIGHT * SCALE, fullscreen)
         self.caption = 'Doom Ruby'
+        self.update_interval = 0  # Uncap framerate (default 16.67ms = 60 FPS cap)
 
         @renderer = renderer
         @palette = palette
@@ -63,6 +65,7 @@ module Doom
         @sector_effects = sector_effects
         @item_pickup = item_pickup
         @combat = combat
+        @monster_ai = monster_ai
         @last_floor_height = nil
         @move_momx = 0.0
         @move_momy = 0.0
@@ -76,12 +79,21 @@ module Doom
         @show_debug = false
         @show_map = false
         @debug_font = Gosu::Font.new(16)
+        @fps_frames = 0
+        @fps_time = Time.now
+        @fps_display = 0.0
 
         # Precompute sector colors for automap
         @sector_colors = build_sector_colors
 
-        # Pre-build palette lookup for speed
-        @palette_rgba = palette.colors.map { |r, g, b| [r, g, b, 255].pack('CCCC') }
+        # Pre-build palette RGBA lookups for all 14 palettes (0=normal, 1-8=pain red)
+        @all_palette_rgba = []
+        wad = renderer.instance_variable_get(:@wad)
+        14.times do |pal_idx|
+          pal = Wad::Palette.load(wad, pal_idx)
+          @all_palette_rgba << pal.colors.map { |r, g, b| [r, g, b, 255].pack('CCCC') }
+        end
+        @palette_rgba = @all_palette_rgba[0]
       end
 
       def update
@@ -107,6 +119,19 @@ module Doom
           @player_state&.update_viewheight
           @player_state&.update_attack  # Attack timing at 35fps like DOOM
           @combat&.update
+          @monster_ai&.update(@renderer.player_x, @renderer.player_y)
+
+          @player_state&.update_damage_count
+
+          # Sector damage (nukage, lava, etc.) every 32 tics
+          if @player_state && !@player_state.dead && (@leveltime % 32 == 0)
+            check_sector_damage
+          end
+
+          # Track death tic for death animation
+          if @player_state&.dead
+            @player_state.death_tic += 1
+          end
         end
         @animations&.update(@leveltime)
 
@@ -127,20 +152,38 @@ module Doom
 
         # Pass combat state to renderer for death frame rendering
         @renderer.combat = @combat
+        @renderer.monster_ai = @monster_ai
+        @renderer.leveltime = @leveltime
 
         # Render the 3D world
         @renderer.render_frame
 
         # Render HUD on top
-        if @weapon_renderer
+        if @weapon_renderer && !@player_state&.dead
           @weapon_renderer.render(@renderer.framebuffer)
         end
         if @status_bar
           @status_bar.render(@renderer.framebuffer)
         end
+
+        # Red tint when dead
+        if @player_state&.dead
+          apply_death_tint(@renderer.framebuffer)
+        end
       end
 
       def handle_input(delta_time)
+        # Handle respawn when dead
+        if @player_state&.dead
+          if @player_state.death_tic > 35  # 1 second delay before respawn allowed
+            if Gosu.button_down?(Gosu::KB_SPACE) || Gosu.button_down?(Gosu::KB_X) ||
+               Gosu.button_down?(Gosu::MS_LEFT) || Gosu.button_down?(Gosu::KB_LEFT_SHIFT)
+              respawn_player
+            end
+          end
+          return  # No other input while dead
+        end
+
         # Mouse look
         handle_mouse_look
 
@@ -616,8 +659,10 @@ module Doom
         if @show_map
           draw_automap
         else
-          # Fast RGBA conversion using pre-built palette
-          rgba = @renderer.framebuffer.map { |idx| @palette_rgba[idx] }.join
+          # Select palette: red tint when taking damage (palettes 1-8)
+          pal_idx = @player_state ? @player_state.damage_count.clamp(0, 8) : 0
+          active_pal = @all_palette_rgba[pal_idx]
+          rgba = @renderer.framebuffer.map { |idx| active_pal[idx] }.join
 
           @screen_image = Gosu::Image.from_blob(
             Render::SCREEN_WIDTH,
@@ -632,6 +677,16 @@ module Doom
       end
 
       def draw_debug_overlay
+        # Update FPS counter (refresh every 0.5 seconds)
+        @fps_frames += 1
+        now = Time.now
+        elapsed = now - @fps_time
+        if elapsed >= 0.5
+          @fps_display = (@fps_frames / elapsed).round(1)
+          @fps_frames = 0
+          @fps_time = now
+        end
+
         sector = @map.sector_at(@renderer.player_x, @renderer.player_y)
         return unless sector
 
@@ -639,12 +694,14 @@ module Doom
         sector_idx = @map.sectors.index(sector)
 
         lines = [
+          "FPS: #{@fps_display}",
           "Sector #{sector_idx}",
           "Floor: #{sector.floor_height} (#{sector.floor_texture})",
           "Ceil:  #{sector.ceiling_height} (#{sector.ceiling_texture})",
           "Light: #{sector.light_level}",
           "Pos: #{@renderer.player_x.round}, #{@renderer.player_y.round}",
           "Heading: #{(Math.atan2(@renderer.sin_angle, @renderer.cos_angle) * 180.0 / Math::PI).round(1)}",
+          "YJIT: #{defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled? ? 'ON' : 'OFF'} (Y to toggle)",
         ]
 
         y = 4
@@ -672,6 +729,17 @@ module Doom
           end
         when Gosu::KB_Z
           @show_debug = !@show_debug
+        when Gosu::KB_Y
+          if defined?(RubyVM::YJIT)
+            setup_yjit_toggle
+            if RubyVM::YJIT.enabled?
+              RubyVM::YJIT.disable
+              puts "YJIT disabled!"
+            else
+              RubyVM::YJIT.enable
+              puts "YJIT enabled!"
+            end
+          end
         when Gosu::KB_M
           @show_map = !@show_map
         when Gosu::KB_F12
@@ -679,6 +747,70 @@ module Doom
         end
       end
 
+      # Sector damage types from DOOM (p_spec.c)
+      # Type 5: 10 damage, Type 7: 5 damage, Type 4/16: 20 damage
+      SECTOR_DAMAGE = { 5 => 10, 7 => 5, 4 => 20, 16 => 20, 11 => 20 }.freeze
+
+      def check_sector_damage
+        sector = @map.sector_at(@renderer.player_x, @renderer.player_y)
+        return unless sector
+
+        damage = SECTOR_DAMAGE[sector.special]
+        @player_state.take_damage(damage) if damage
+      end
+
+      def apply_death_tint(framebuffer)
+        # Death keeps damage_count at max so the pain palette stays red
+        @player_state.damage_count = 8 if @player_state&.dead
+      end
+
+      def respawn_player
+        @player_state.reset
+        @last_floor_height = nil
+        @move_momx = 0.0
+        @move_momy = 0.0
+
+        # Reset item pickup, combat, and monster AI state
+        sprites = @combat&.instance_variable_get(:@sprites)
+        @item_pickup = Game::ItemPickup.new(@map, @player_state) if @item_pickup
+        @combat = Game::Combat.new(@map, @player_state, sprites) if @combat && sprites
+        @monster_ai = Game::MonsterAI.new(@map, @combat) if @monster_ai && @combat
+
+        # Move player to start position
+        ps = @map.player_start
+        if ps
+          @renderer.set_player(ps.x, ps.y, 41, ps.angle)
+          update_player_height(ps.x, ps.y)
+        end
+      end
+
+      def setup_yjit_toggle
+        return if @yjit_toggle_ready || !defined?(RubyVM::YJIT)
+        require "fiddle"
+
+        address = Fiddle::Handle::DEFAULT["rb_yjit_enabled_p"]
+        enabled_ptr = Fiddle::Pointer.new(address, Fiddle::SIZEOF_CHAR)
+
+        RubyVM::YJIT.singleton_class.prepend(Module.new do
+          define_method(:enable) do |**kwargs|
+            return false if enabled?
+            return super(**kwargs) unless RUBY_DESCRIPTION.include?("+YJIT")
+            enabled_ptr[0] = 1
+            true
+          end
+
+          define_method(:disable) do
+            return false unless enabled?
+            enabled_ptr[0] = 0
+            true
+          end
+        end)
+
+        @yjit_toggle_ready = true
+      rescue => e
+        puts "YJIT toggle setup failed: #{e.message}"
+      end
+
       def needs_cursor?
         !@mouse_captured
       end

data/lib/doom/render/renderer.rb

@@ -64,6 +64,8 @@ module Doom
         @animations = animations
         @hidden_things = nil
         @combat = nil
+        @monster_ai = nil
+        @leveltime = 0
 
         @framebuffer = Array.new(SCREEN_WIDTH * SCREEN_HEIGHT, 0)
 
@@ -104,7 +106,7 @@ module Doom
       end
 
       attr_reader :player_x, :player_y, :player_z, :sin_angle, :cos_angle, :framebuffer
-      attr_writer :hidden_things, :combat
+      attr_writer :hidden_things, :combat, :monster_ai, :leveltime
 
       # Diagnostic: returns info about all sprites and why they are/aren't visible
       def sprite_diagnostics
@@ -1302,9 +1304,17 @@ module Doom
           dy = thing.y - @player_y
           angle_to_thing = Math.atan2(dy, dx)
 
-          # Get sprite - use death frame if monster is dead
+          # Get sprite: death frame > walking frame > idle frame
           if @combat && @combat.dead?(thing_idx)
             sprite = @combat.death_sprite(thing_idx, thing.type, angle_to_thing, thing.angle)
+          elsif @monster_ai
+            mon = @monster_ai.monsters.find { |m| m.thing_idx == thing_idx }
+            if mon && mon.active
+              # Walking animation: cycle through frames A-D based on leveltime
+              walk_frame = %w[A B C D][@leveltime / 4 % 4]
+              sprite = @sprites.get_frame(thing.type, walk_frame, angle_to_thing, thing.angle)
+            end
+            sprite ||= @sprites.get_rotated(thing.type, angle_to_thing, thing.angle)
           else
             sprite = @sprites.get_rotated(thing.type, angle_to_thing, thing.angle)
           end
@@ -1328,6 +1338,45 @@ module Doom
         visible_sprites.each do |vs|
           draw_sprite(vs)
         end
+
+        # Draw projectiles and explosions
+        render_projectiles if @combat
+      end
+
+      def render_projectiles
+        # Render rockets in flight
+        @combat.projectiles.each do |proj|
+          view_x, view_y = transform_point(proj.x, proj.y)
+          next if view_y <= 0
+
+          # Rocket has rotations 1-8 based on travel direction relative to viewer
+          rocket_angle = Math.atan2(proj.dy, proj.dx)
+          viewer_angle = Math.atan2(proj.y - @player_y, proj.x - @player_x)
+          angle_diff = (viewer_angle - rocket_angle) % (2 * Math::PI)
+          rotation = ((angle_diff + Math::PI / 8) / (Math::PI / 4)).to_i % 8 + 1
+          rocket_sprite = @sprites.send(:load_sprite_frame, 'MISL', 'A', rotation)
+          next unless rocket_sprite
+
+          screen_x = HALF_WIDTH + (view_x * @projection / view_y)
+          thing_stub = Map::Thing.new(proj.x, proj.y, 0, 0, 0)
+          visible = VisibleSprite.new(thing_stub, rocket_sprite, view_x, view_y, view_y, screen_x)
+          draw_sprite(visible)
+        end
+
+        # Render explosions (frames B, C, D - all rotation 0)
+        @combat.explosions.each do |expl|
+          view_x, view_y = transform_point(expl[:x], expl[:y])
+          next if view_y <= 0
+          elapsed = (@combat.instance_variable_get(:@tic) - expl[:tic])
+          frame_idx = (elapsed / 4).clamp(0, 2)
+          frame_letter = %w[B C D][frame_idx]
+          expl_sprite = @sprites.send(:load_sprite_frame, 'MISL', frame_letter, 0)
+          next unless expl_sprite
+          screen_x = HALF_WIDTH + (view_x * @projection / view_y)
+          thing_stub = Map::Thing.new(expl[:x], expl[:y], 0, 0, 0)
+          visible = VisibleSprite.new(thing_stub, expl_sprite, view_x, view_y, view_y, screen_x)
+          draw_sprite(visible)
+        end
       end
 
       def draw_sprite(vs)

data/lib/doom/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Doom
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

data/lib/doom/wad/sprite.rb

@@ -178,8 +178,9 @@ module Doom
         return sprite if sprite
 
         # Calculate rotation frame (1-8)
-        # Doom rotations: 1=front, 2=front-right, 3=right, etc. (clockwise)
-        angle_diff = viewer_angle - (thing_angle * Math::PI / 180.0)
+        # DOOM: rot = (R_PointToAngle(thing) - thing->angle + ANG45/2*9) >> 29
+        # Rotation 1=front (viewer faces monster's front), 5=back
+        angle_diff = viewer_angle - (thing_angle * Math::PI / 180.0) + Math::PI
         angle_diff = angle_diff % (2 * Math::PI)
         angle_diff += 2 * Math::PI if angle_diff < 0
         rotation = ((angle_diff + Math::PI / 8) / (Math::PI / 4)).to_i % 8 + 1
@@ -196,8 +197,8 @@ module Doom
         sprite = load_sprite_frame(prefix, frame_letter, 0)
         return sprite if sprite
 
-        # Try with calculated rotation
-        angle_diff = viewer_angle - (thing_angle * Math::PI / 180.0)
+        # Try with calculated rotation (same formula as get_rotated)
+        angle_diff = viewer_angle - (thing_angle * Math::PI / 180.0) + Math::PI
         angle_diff = angle_diff % (2 * Math::PI)
         angle_diff += 2 * Math::PI if angle_diff < 0
         rotation = ((angle_diff + Math::PI / 8) / (Math::PI / 4)).to_i % 8 + 1

data/lib/doom/wad_downloader.rb

@@ -66,7 +66,16 @@ module Doom
       uri = URI.parse(SHAREWARE_URL)
       downloaded = 0
 
-      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+      ssl_opts = { use_ssl: uri.scheme == 'https' }
+      # Workaround for SSL certificate issues on some systems
+      begin
+        Net::HTTP.start(uri.host, uri.port, **ssl_opts) { |h| h.head(uri) }
+      rescue OpenSSL::SSL::SSLError
+        puts "SSL certificate verification failed, retrying without verification..."
+        ssl_opts[:verify_mode] = OpenSSL::SSL::VERIFY_NONE
+      end
+
+      Net::HTTP.start(uri.host, uri.port, **ssl_opts) do |http|
         request = Net::HTTP::Get.new(uri)
 
         http.request(request) do |response|

data/lib/doom.rb

@@ -17,6 +17,7 @@ require_relative 'doom/game/animations'
 require_relative 'doom/game/item_pickup'
 require_relative 'doom/game/combat'
 require_relative 'doom/game/sector_effects'
+require_relative 'doom/game/monster_ai'
 require_relative 'doom/render/renderer'
 require_relative 'doom/render/status_bar'
 require_relative 'doom/render/weapon_renderer'
@@ -81,9 +82,10 @@ module Doom
       sector_effects = Game::SectorEffects.new(map)
       item_pickup = Game::ItemPickup.new(map, player_state)
       combat = Game::Combat.new(map, player_state, sprites)
+      monster_ai = Game::MonsterAI.new(map, combat)
 
       puts 'Starting game window...'
-      window = Platform::GosuWindow.new(renderer, palette, map, player_state, status_bar, weapon_renderer, sector_actions, animations, sector_effects, item_pickup, combat)
+      window = Platform::GosuWindow.new(renderer, palette, map, player_state, status_bar, weapon_renderer, sector_actions, animations, sector_effects, item_pickup, combat, monster_ai)
       window.show
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: doom
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Chris Hasinski
@@ -66,6 +66,7 @@ files:
 - lib/doom/game/animations.rb
 - lib/doom/game/combat.rb
 - lib/doom/game/item_pickup.rb
+- lib/doom/game/monster_ai.rb
 - lib/doom/game/player_state.rb
 - lib/doom/game/sector_actions.rb
 - lib/doom/game/sector_effects.rb
@@ -84,7 +85,7 @@ files:
 - lib/doom/wad/sprite.rb
 - lib/doom/wad/texture.rb
 - lib/doom/wad_downloader.rb
-homepage: https://github.com/khasinski/doom-rb
+homepage: https://github.com/khasinski/doom
 licenses:
 - GPL-2.0
 metadata: {}
@@ -102,7 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Doom engine port in pure Ruby
 test_files: []