doom 0.6.0 → 0.8.0

data/lib/doom/game/item_pickup.rb

@@ -50,31 +50,66 @@ module Doom
         38 => { cat: :key, key: :red_skull },
       }.freeze
 
-      attr_reader :picked_up
+      MESSAGETICS = 140    # 4 * TICRATE (4 seconds, matching Chocolate Doom)
+      FLASH_TICS = 8       # Yellow palette flash duration
 
-      def initialize(map, player_state)
+      attr_reader :picked_up, :pickup_message, :pickup_flash, :message_tics
+      attr_accessor :ammo_multiplier, :hidden_things
+
+      def initialize(map, player_state, hidden_things = {})
         @map = map
         @player = player_state
-        @picked_up = {}  # thing index => true (to avoid re-picking)
+        @picked_up = {}
+        @hidden_things = hidden_things
+        @ammo_multiplier = 1
+        @pickup_message = nil
+        @pickup_flash = 0     # Yellow screen flash (short)
+        @message_tics = 0     # Message display timer (long)
+      end
+
+      # Decay timers each tic
+      def update_flash
+        @pickup_flash -= 1 if @pickup_flash > 0
+        @message_tics -= 1 if @message_tics > 0
       end
 
       def update(player_x, player_y)
         @map.things.each_with_index do |thing, idx|
+          next if @hidden_things[idx]
           next if @picked_up[idx]
           item = ITEMS[thing.type]
           next unless item
 
-          # DOOM uses bounding box overlap: abs(dx) < sum_of_radii
           dx = (player_x - thing.x).abs
           dy = (player_y - thing.y).abs
           next if dx >= PICKUP_DIST || dy >= PICKUP_DIST
 
           if try_pickup(item)
             @picked_up[idx] = true
+            @pickup_message = PICKUP_MESSAGES[thing.type]
+            @pickup_flash = FLASH_TICS
+            @message_tics = MESSAGETICS
           end
         end
       end
 
+      PICKUP_MESSAGES = {
+        2001 => "A SHOTGUN!", 2002 => "A CHAINGUN!", 2003 => "A ROCKET LAUNCHER!",
+        2004 => "A PLASMA RIFLE!", 2005 => "A CHAINSAW!", 2006 => "A BFG9000!",
+        2007 => "PICKED UP A CLIP.", 2048 => "PICKED UP A BOX OF BULLETS.",
+        2008 => "PICKED UP 4 SHOTGUN SHELLS.", 2049 => "PICKED UP A BOX OF SHELLS.",
+        2010 => "PICKED UP A ROCKET.", 2046 => "PICKED UP A BOX OF ROCKETS.",
+        17 => "PICKED UP AN ENERGY CELL.", 2047 => "PICKED UP AN ENERGY CELL PACK.",
+        8 => "PICKED UP A BACKPACK FULL OF AMMO!",
+        2011 => "PICKED UP A STIMPACK.", 2012 => "PICKED UP A MEDIKIT.",
+        2014 => "PICKED UP A HEALTH BONUS.", 2015 => "PICKED UP AN ARMOR BONUS.",
+        2018 => "PICKED UP THE ARMOR.", 2019 => "PICKED UP THE MEGAARMOR!",
+        2013 => "SUPERCHARGE!",
+        5 => "PICKED UP A BLUE KEYCARD.", 6 => "PICKED UP A YELLOW KEYCARD.",
+        13 => "PICKED UP A RED KEYCARD.", 40 => "PICKED UP A BLUE SKULL KEY.",
+        39 => "PICKED UP A YELLOW SKULL KEY.", 38 => "PICKED UP A RED SKULL KEY.",
+      }.freeze
+
       private
 
       def try_pickup(item)
@@ -112,6 +147,7 @@ module Doom
       end
 
       def give_ammo(type, amount)
+        amount = amount * @ammo_multiplier
         case type
         when :bullets
           return false if @player.ammo_bullets >= @player.max_bullets

data/lib/doom/game/menu.rb

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # DOOM main menu system with title screen, new game, and difficulty selection.
+    class Menu
+      SKULL_ANIM_TICS = 8  # Skull cursor blink rate
+
+      # Difficulty levels matching DOOM's skill levels
+      SKILL_BABY = 0      # I'm too young to die
+      SKILL_EASY = 1      # Hey, not too rough
+      SKILL_MEDIUM = 2    # Hurt me plenty
+      SKILL_HARD = 3      # Ultra-Violence
+      SKILL_NIGHTMARE = 4 # Nightmare!
+
+      # Menu states
+      STATE_TITLE = :title
+      STATE_MAIN = :main
+      STATE_SKILL = :skill
+      STATE_OPTIONS = :options
+      STATE_NONE = :none   # In-game, no menu
+
+      # Main menu items
+      MAIN_ITEMS = %i[new_game options quit].freeze
+
+      # Options menu items
+      OPTIONS_ITEMS = %i[god_mode infinite_ammo all_weapons fullscreen rubykaigi_mode].freeze
+      OPTIONS_LABELS = {
+        god_mode: "GOD MODE",
+        infinite_ammo: "INFINITE AMMO",
+        all_weapons: "ALL WEAPONS",
+        fullscreen: "FULLSCREEN",
+        rubykaigi_mode: "RUBYKAIGI MODE",
+      }.freeze
+
+      OPTIONS_X = 48
+      OPTIONS_Y = 50
+      OPTIONS_SPACING = 18
+
+      # Skill menu items
+      SKILL_ITEMS = [SKILL_BABY, SKILL_EASY, SKILL_MEDIUM, SKILL_HARD, SKILL_NIGHTMARE].freeze
+
+      # Menu item Y positions (from Chocolate Doom m_menu.c)
+      MAIN_X = 97
+      MAIN_Y = 64
+      MAIN_SPACING = 16
+
+      SKILL_X = 48
+      SKILL_Y = 63
+      SKILL_SPACING = 16
+
+      attr_reader :state, :selected_skill, :options, :font
+
+      def initialize(wad, hud_graphics, font = nil)
+        @wad = wad
+        @gfx = hud_graphics
+        @font = font
+        @state = STATE_TITLE
+        @cursor = 0
+        @skull_frame = 0
+        @skull_tic = 0
+        @selected_skill = SKILL_MEDIUM  # Default difficulty
+        @game_started = false
+
+        # Options toggles
+        @options = {
+          god_mode: false,
+          infinite_ammo: false,
+          all_weapons: false,
+          fullscreen: false,
+          rubykaigi_mode: false,
+        }
+
+        load_graphics
+      end
+
+      def active?
+        @state != STATE_NONE
+      end
+
+      def needs_background?
+        @state != STATE_TITLE
+      end
+
+      def update
+        @skull_tic += 1
+        if @skull_tic >= SKULL_ANIM_TICS
+          @skull_tic = 0
+          @skull_frame = 1 - @skull_frame
+        end
+      end
+
+      def render(framebuffer, palette_colors)
+        case @state
+        when STATE_TITLE
+          render_title(framebuffer)
+        when STATE_MAIN
+          render_main_menu(framebuffer)
+        when STATE_SKILL
+          render_skill_menu(framebuffer)
+        when STATE_OPTIONS
+          render_options_menu(framebuffer)
+        end
+      end
+
+      # Returns :start_game, :resume, :quit, or option action symbols
+      def handle_key(key)
+        case @state
+        when STATE_TITLE
+          @state = STATE_MAIN
+          @cursor = 0
+        when STATE_MAIN
+          handle_main_key(key)
+        when STATE_SKILL
+          handle_skill_key(key)
+        when STATE_OPTIONS
+          handle_options_key(key)
+        end
+      end
+
+      def dismiss
+        @state = STATE_NONE
+        @game_started = true
+      end
+
+      def show
+        @state = STATE_MAIN
+        @cursor = 0
+      end
+
+      private
+
+      def load_graphics
+        # Title screen
+        @title = load_patch('TITLEPIC')
+
+        # RubyKaigi title screen (pre-rendered palette indices)
+        kaigi_path = File.join(File.expand_path('../../..', __dir__), 'assets', 'kaigi_title.dat')
+        @kaigi_title = File.exist?(kaigi_path) ? Marshal.load(File.binread(kaigi_path)) : nil
+
+        # Main menu
+        @m_doom = load_patch('M_DOOM')
+        @m_newg = load_patch('M_NGAME')
+        @m_option = load_patch('M_OPTION')
+        @m_quitg = load_patch('M_QUITG')
+
+        # Skill menu
+        @m_skill = load_patch('M_SKILL')
+        @m_jkill = load_patch('M_JKILL')
+        @m_hurt = load_patch('M_HURT')
+        @m_rough = load_patch('M_ROUGH')  # Not used, but loaded
+        @m_ultra = load_patch('M_ULTRA')
+        @m_nmare = load_patch('M_NMARE')
+
+        # Episode (shareware only has 1)
+        @m_episod = load_patch('M_EPISOD')
+        @m_epi1 = load_patch('M_EPI1')
+
+        # Skull cursor
+        @skulls = [load_patch('M_SKULL1'), load_patch('M_SKULL2')]
+      end
+
+      def load_patch(name)
+        @gfx.send(:load_graphic, name)
+      end
+
+      def render_title(framebuffer)
+        if @options[:rubykaigi_mode] && @kaigi_title
+          # Draw kaigi title (raw palette indices, 320x200, offset 20px down)
+          @kaigi_title.each_with_index do |color, i|
+            x = i % 320
+            y = (i / 320) + 20
+            framebuffer[y * 320 + x] = color if y < 240
+          end
+        elsif @title
+          draw_fullscreen(framebuffer, @title)
+        end
+      end
+
+      def render_main_menu(framebuffer)
+        # Draw title logo
+        draw_sprite(framebuffer, @m_doom, 94, 2) if @m_doom
+
+        # Draw menu items
+        items = [@m_newg, @m_option, @m_quitg]
+        items.each_with_index do |item, i|
+          next unless item
+          draw_sprite(framebuffer, item, MAIN_X, MAIN_Y + i * MAIN_SPACING)
+        end
+
+        # Draw skull cursor
+        skull = @skulls[@skull_frame]
+        if skull
+          skull_x = MAIN_X - 32
+          skull_y = MAIN_Y + @cursor * MAIN_SPACING - 5
+          draw_sprite(framebuffer, skull, skull_x, skull_y)
+        end
+      end
+
+      def render_skill_menu(framebuffer)
+        # Draw skill title
+        draw_sprite(framebuffer, @m_skill, 38, 15) if @m_skill
+
+        # Draw skill items: baby, easy, medium, hard, nightmare
+        skill_items = [@m_jkill, @m_hurt, @m_rough, @m_ultra, @m_nmare]
+        skill_items.each_with_index do |item, i|
+          next unless item
+          draw_sprite(framebuffer, item, SKILL_X, SKILL_Y + i * SKILL_SPACING)
+        end
+
+        # Draw skull cursor
+        skull = @skulls[@skull_frame]
+        if skull
+          skull_x = SKILL_X - 32
+          skull_y = SKILL_Y + @cursor * SKILL_SPACING - 5
+          draw_sprite(framebuffer, skull, skull_x, skull_y)
+        end
+      end
+
+      def handle_main_key(key)
+        case key
+        when :up
+          @cursor = (@cursor - 1) % MAIN_ITEMS.size
+        when :down
+          @cursor = (@cursor + 1) % MAIN_ITEMS.size
+        when :enter
+          case MAIN_ITEMS[@cursor]
+          when :new_game
+            @state = STATE_SKILL
+            @cursor = SKILL_MEDIUM  # Default to "Hurt me plenty"
+          when :options
+            @state = STATE_OPTIONS
+            @cursor = 0
+          when :quit
+            return :quit
+          end
+        when :escape
+          if @game_started
+            # Resume game
+            @state = STATE_NONE
+            return :resume
+          else
+            @state = STATE_TITLE
+          end
+        end
+        nil
+      end
+
+      def handle_skill_key(key)
+        case key
+        when :up
+          @cursor = (@cursor - 1) % SKILL_ITEMS.size
+        when :down
+          @cursor = (@cursor + 1) % SKILL_ITEMS.size
+        when :enter
+          @selected_skill = SKILL_ITEMS[@cursor]
+          @state = STATE_NONE
+          @game_started = true
+          return :start_game
+        when :escape
+          @state = STATE_MAIN
+          @cursor = 0
+        end
+        nil
+      end
+
+      def render_options_menu(framebuffer)
+        # Draw title using font
+        @font&.draw_centered(framebuffer, "OPTIONS", 20)
+
+        # Draw each option with ON/OFF status
+        OPTIONS_ITEMS.each_with_index do |item, i|
+          y = OPTIONS_Y + i * OPTIONS_SPACING
+          label = OPTIONS_LABELS[item]
+          value = @options[item] ? "ON" : "OFF"
+          @font&.draw_text(framebuffer, label, OPTIONS_X, y)
+          @font&.draw_text(framebuffer, value, 260, y)
+        end
+
+        # Draw skull cursor
+        skull = @skulls[@skull_frame]
+        if skull
+          skull_x = OPTIONS_X - 32
+          skull_y = OPTIONS_Y + @cursor * OPTIONS_SPACING - 5
+          draw_sprite(framebuffer, skull, skull_x, skull_y)
+        end
+      end
+
+      def handle_options_key(key)
+        case key
+        when :up
+          @cursor = (@cursor - 1) % OPTIONS_ITEMS.size
+        when :down
+          @cursor = (@cursor + 1) % OPTIONS_ITEMS.size
+        when :enter
+          item = OPTIONS_ITEMS[@cursor]
+          @options[item] = !@options[item]
+          return { action: :toggle_option, option: item, value: @options[item] }
+        when :escape
+          @state = STATE_MAIN
+          @cursor = 1  # Options is the second main menu item
+        end
+        nil
+      end
+
+      def draw_fullscreen(framebuffer, sprite)
+        return unless sprite
+        # TITLEPIC is 320x200, our screen is 320x240
+        # Draw it centered vertically (offset by 20 pixels)
+        y_offset = 20
+        sprite.width.times do |x|
+          col = sprite.column_pixels(x)
+          next unless col
+          col.each_with_index do |color, y|
+            next unless color
+            screen_y = y + y_offset
+            next if screen_y < 0 || screen_y >= 240
+            framebuffer[screen_y * 320 + x] = color
+          end
+        end
+      end
+
+      def draw_sprite(framebuffer, sprite, x, y)
+        return unless sprite
+        sprite.width.times do |col_x|
+          screen_x = x + col_x
+          next if screen_x < 0 || screen_x >= 320
+
+          col = sprite.column_pixels(col_x)
+          next unless col
+
+          col.each_with_index do |color, col_y|
+            next unless color
+            screen_y = y + col_y
+            next if screen_y < 0 || screen_y >= 240
+            framebuffer[screen_y * 320 + screen_x] = color
+          end
+        end
+      end
+    end
+  end
+end

data/lib/doom/game/monster_ai.rb

@@ -25,37 +25,132 @@ module Doom
       }.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)
+      SIGHT_RANGE = 768.0  # Max distance for sight check
       MELEE_RANGE = 64.0
+      MISSILE_RANGE = 768.0
+      KEEP_DISTANCE = 196.0  # Ranged monsters prefer to stay this far from player
 
       # Direction to angle (for sprite facing)
       DIR_ANGLES = [0, 45, 90, 135, 180, 225, 270, 315].freeze
 
+      # Monster attack definitions (from mobjinfo / A_Chase)
+      # Cooldown = attack_anim_tics + avg_movecount(7.5) * chase_tics(4)
+      # In DOOM, monsters only attempt attacks when movecount reaches 0,
+      # then play full attack animation before returning to chase.
+      MONSTER_ATTACK = {
+        3004 => { type: :hitscan, damage: [3, 15], cooldown: 56 },     # Zombieman
+        9    => { type: :hitscan, damage: [3, 15], cooldown: 56 },     # Shotgun Guy
+        3001 => { type: :projectile, cooldown: 52 },                    # Imp: fireball
+        3002 => { type: :melee,  damage: [4, 40], cooldown: 42 },      # Demon
+        58   => { type: :melee,  damage: [4, 40], cooldown: 42 },      # Spectre
+        3003 => { type: :projectile, cooldown: 54 },                    # Baron: fireball
+        69   => { type: :projectile, cooldown: 54 },                    # Hell Knight
+        3005 => { type: :projectile, cooldown: 56 },                    # Cacodemon
+        65   => { type: :hitscan, damage: [3, 15], cooldown: 40 },     # Heavy Weapon Dude
+      }.freeze
+
+      REACTIONTIME = 8  # Tics before first attack after activation (from mobjinfo)
+
+      # Hitscan hit probability by distance (DOOM's P_AimLineAttack has bullet spread)
+      # Close = ~85%, mid = ~60%, far = ~35%
+      HITSCAN_ACCURACY = 0.85
+
+      # Attack animation frames per sprite prefix (E, F, G typically)
+      ATTACK_FRAMES = {
+        'POSS' => %w[E F],       # Zombieman: raise, fire
+        'SPOS' => %w[E F],       # Shotgun Guy
+        'TROO' => %w[E F G H],   # Imp: raise, fireball, throw, recover
+        'SARG' => %w[E F G],     # Demon: bite
+        'HEAD' => %w[E F],       # Cacodemon
+        'BOSS' => %w[E F G],     # Baron
+        'BOS2' => %w[E F G],     # Hell Knight
+        'CPOS' => %w[E F],       # Heavy Weapon Dude
+      }.freeze
+
+      ATTACK_FRAME_TICS = 8  # Tics per attack animation frame
+
+      # Which frame index the actual attack happens on (matching Chocolate Doom)
+      # Zombieman: A_PosAttack on frame F (index 1)
+      # Imp: A_TroopAttack on frame G (index 2)
+      # Demon: A_SargAttack on frame F (index 1)
+      FIRE_FRAME_INDEX = {
+        'POSS' => 1,  # Zombieman: E=raise, F=fire
+        'SPOS' => 1,  # Shotgun Guy: E=raise, F=fire
+        'TROO' => 2,  # Imp: E=raise, F=aim, G=throw, H=recover
+        'SARG' => 1,  # Demon: E=open, F=bite, G=close
+        'HEAD' => 1,  # Cacodemon: E=charge, F=fire
+        'BOSS' => 1,  # Baron: E=raise, F=throw, G=recover
+        'BOS2' => 1,  # Hell Knight
+        'CPOS' => 1,  # Heavy Weapon Dude
+      }.freeze
+
       MonsterState = Struct.new(:thing_idx, :x, :y, :movedir, :movecount,
-                                :active, :chase_timer, :type)
+                                :active, :chase_timer, :type, :attack_cooldown,
+                                :reactiontime, :last_saw_player,
+                                :attacking, :attack_frame_tic, :fired)
 
-      def initialize(map, combat)
+      def initialize(map, combat, player_state, sprites_mgr = nil, hidden_things = {}, sound_engine = nil)
         @map = map
         @combat = combat
+        @player = player_state
+        @sprites_mgr = sprites_mgr
         @monsters = []
+        @aggression = true  # Monsters fight back (toggle with C)
+        @damage_multiplier = 1.0
+        @tic_counter = 0
+        @sound = sound_engine
+        @monster_by_thing_idx = {}
 
         map.things.each_with_index do |thing, idx|
+          next if hidden_things[idx]  # Filtered by difficulty
           next unless Combat::MONSTER_HP[thing.type]
-          @monsters << MonsterState.new(
+          next if thing.type == Combat::BARREL_TYPE
+          mon = MonsterState.new(
             idx, thing.x.to_f, thing.y.to_f,
-            DI_NODIR, 0, false, 0, thing.type
+            DI_NODIR, 0, false, 0, thing.type, 0, REACTIONTIME, 0,
+            false, 0, false
           )
+          @monsters << mon
+          @monster_by_thing_idx[idx] = mon
         end
       end
 
-      attr_reader :monsters
+      attr_reader :monsters, :monster_by_thing_idx
+      attr_accessor :aggression, :damage_multiplier
 
       # Called each game tic
       def update(player_x, player_y)
+        @tic_counter += 1
         @monsters.each do |mon|
           next if @combat.dead?(mon.thing_idx)
 
+          # Pain state: monster is stunned, skip movement and attacks
+          next if @combat.in_pain?(mon.thing_idx)
+
           if mon.active
+            # Attack animation in progress: freeze movement, tick animation
+            if mon.attacking
+              mon.attack_frame_tic += 1
+              prefix = @sprites_mgr&.prefix_for(mon.type)
+              frames = ATTACK_FRAMES[prefix]
+              total_tics = (frames&.size || 2) * ATTACK_FRAME_TICS
+
+              # Fire on the correct frame (matching Chocolate Doom)
+              fire_idx = FIRE_FRAME_INDEX[prefix] || 1
+              fire_tic = fire_idx * ATTACK_FRAME_TICS
+              if !mon.fired && mon.attack_frame_tic >= fire_tic
+                execute_attack(mon, player_x, player_y)
+                mon.fired = true
+              end
+
+              if mon.attack_frame_tic >= total_tics
+                mon.attacking = false
+                mon.attack_frame_tic = 0
+                mon.fired = false
+              end
+              next
+            end
+
             mon.chase_timer -= 1
             if mon.chase_timer <= 0
               mon.chase_timer = CHASE_TICS
@@ -88,16 +183,52 @@ module Doom
         if has_line_of_sight?(mon.x, mon.y, player_x, player_y)
           mon.active = true
           mon.chase_timer = CHASE_TICS
+          @sound&.monster_see(mon.type)
         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)
+        # Tick down attack cooldown
+        mon.attack_cooldown -= CHASE_TICS if mon.attack_cooldown > 0
+
+        dx = player_x - mon.x
+        dy = player_y - mon.y
+        dist = Math.sqrt(dx * dx + dy * dy)
+
+        # Track if monster can see the player
+        can_see = dist < SIGHT_RANGE && has_line_of_sight?(mon.x, mon.y, player_x, player_y)
+        if can_see
+          mon.last_saw_player = @tic_counter
+        elsif @tic_counter - (mon.last_saw_player || 0) > 105  # ~3 seconds without LOS
+          # Monster gives up and goes idle (like DOOM's A_Chase returning to spawnstate)
+          mon.active = false
+          mon.reactiontime = REACTIONTIME
+          return
+        end
+
+        # Only attempt attacks when: movecount == 0, has LOS, and in range
+        if @aggression && mon.attack_cooldown <= 0 && mon.movecount <= 0 && can_see && !@player.dead
+          attacked = try_attack(mon, player_x, player_y, dist)
+        end
+
+        # Move -- but ranged monsters stop advancing when they have LOS and are close enough
+        # In DOOM, A_Chase skips movement when P_CheckMissileRange succeeds
+        unless attacked
+          atk = MONSTER_ATTACK[mon.type]
+          ranged = atk && (atk[:type] == :hitscan || atk[:type] == :projectile)
+          skip_move = ranged && can_see && dist < KEEP_DISTANCE
+
+          if skip_move
+            # Still tick movecount down so attack condition can trigger
+            mon.movecount -= 1 if mon.movecount > 0
+          else
+            mon.movecount -= 1
+            if mon.movecount < 0 || !try_move(mon, speed)
+              new_chase_dir(mon, player_x, player_y)
+            end
+          end
         end
 
         # Update the thing's position and facing angle in the map for rendering
@@ -105,11 +236,79 @@ module Doom
         thing.x = mon.x.to_i
         thing.y = mon.y.to_i
 
-        # Face toward the player (smooth turning)
+        # Face toward the player
         target_angle = Math.atan2(player_y - mon.y, player_x - mon.x) * 180.0 / Math::PI
         thing.angle = target_angle.round.to_i
       end
 
+      # Decide whether to start an attack (does NOT apply damage yet)
+      # Matches Chocolate Doom's P_CheckMissileRange from p_enemy.c
+      def try_attack(mon, player_x, player_y, dist)
+        if mon.reactiontime > 0
+          mon.reactiontime -= 1
+          return false
+        end
+
+        atk = MONSTER_ATTACK[mon.type]
+        return false unless atk
+
+        case atk[:type]
+        when :melee
+          return false if dist > MELEE_RANGE + (Combat::MONSTER_RADIUS[mon.type] || 20)
+        when :hitscan, :projectile
+          return false if dist > MISSILE_RANGE
+          return false unless has_line_of_sight?(mon.x, mon.y, player_x, player_y)
+
+          # P_CheckMissileRange: subtract grace distance, cap at 200
+          check_dist = dist - 64  # 64 unit grace distance
+          check_dist -= 128 if atk[:type] == :projectile  # Pure ranged fire more
+          check_dist = [check_dist, 0].max
+          check_dist = [check_dist, 200].min  # Cap: always >= 22% chance to fire
+          return false if rand(256) < check_dist
+        end
+
+        # Start attack animation (damage applied later on fire frame)
+        mon.attacking = true
+        mon.attack_frame_tic = 0
+        mon.fired = false
+        mon.attack_cooldown = atk[:cooldown]
+        true
+      end
+
+      # Called on the fire frame of the attack animation
+      def execute_attack(mon, player_x, player_y)
+        atk = MONSTER_ATTACK[mon.type]
+        return unless atk
+
+        @sound&.monster_attack(mon.type)
+
+        dx = player_x - mon.x
+        dy = player_y - mon.y
+        dist = Math.sqrt(dx * dx + dy * dy)
+
+        case atk[:type]
+        when :melee
+          min_dmg, max_dmg = atk[:damage]
+          damage = (rand(min_dmg..max_dmg) * @damage_multiplier).to_i
+          @player.take_damage(damage) if damage > 0
+
+        when :hitscan
+          hit_chance = HITSCAN_ACCURACY * (1.0 - dist / (MISSILE_RANGE * 2))
+          hit_chance = [hit_chance, 0.15].max
+          if rand < hit_chance
+            min_dmg, max_dmg = atk[:damage]
+            damage = (rand(min_dmg..max_dmg) * @damage_multiplier).to_i
+            @player.take_damage(damage) if damage > 0
+          end
+
+        when :projectile
+          # P_SpawnMissile: z = source->z + 32 (chest height)
+          sector = @map.sector_at(mon.x, mon.y)
+          spawn_z = (sector ? sector.floor_height : 0) + 32
+          @combat.spawn_monster_projectile(mon.x, mon.y, spawn_z, mon.type, @damage_multiplier)
+        end
+      end
+
       def try_move(mon, speed)
         return false if mon.movedir == DI_NODIR