doom 0.4.0 → 0.6.0

data/lib/doom/game/item_pickup.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # Handles item pickup when player touches things.
+    # Matches Chocolate Doom's P_TouchSpecialThing from p_inter.c.
+    class ItemPickup
+      PLAYER_RADIUS = 16.0
+      THING_RADIUS = 20.0
+      PICKUP_DIST = PLAYER_RADIUS + THING_RADIUS  # 36 units (bounding box overlap)
+
+      # Item definitions: type => { category, value, ... }
+      ITEMS = {
+        # Weapons (give weapon + some ammo)
+        2001 => { cat: :weapon, weapon: 2, ammo: :shells, amount: 8 },    # Shotgun
+        2002 => { cat: :weapon, weapon: 3, ammo: :bullets, amount: 20 },  # Chaingun
+        2003 => { cat: :weapon, weapon: 4, ammo: :rockets, amount: 2 },   # Rocket launcher
+        2004 => { cat: :weapon, weapon: 5, ammo: :cells, amount: 40 },    # Plasma rifle
+        2006 => { cat: :weapon, weapon: 6, ammo: :cells, amount: 40 },    # BFG9000
+        2005 => { cat: :weapon, weapon: 7, ammo: :bullets, amount: 0 },   # Chainsaw
+
+        # Ammo
+        2007 => { cat: :ammo, ammo: :bullets, amount: 10 },   # Clip
+        2048 => { cat: :ammo, ammo: :bullets, amount: 50 },   # Box of bullets
+        2008 => { cat: :ammo, ammo: :shells, amount: 4 },     # 4 shells
+        2049 => { cat: :ammo, ammo: :shells, amount: 20 },    # Box of shells
+        2010 => { cat: :ammo, ammo: :rockets, amount: 1 },    # Rocket
+        2046 => { cat: :ammo, ammo: :rockets, amount: 5 },    # Box of rockets
+        17   => { cat: :ammo, ammo: :cells, amount: 20 },     # Cell charge
+        2047 => { cat: :ammo, ammo: :cells, amount: 100 },    # Cell pack
+        8    => { cat: :backpack },                             # Backpack (doubles max ammo + some ammo)
+
+        # Health
+        2014 => { cat: :health, amount: 1, max: 200 },        # Health bonus (+1, up to 200)
+        2011 => { cat: :health, amount: 10, max: 100 },       # Stimpack
+        2012 => { cat: :health, amount: 25, max: 100 },       # Medikit
+        2013 => { cat: :health, amount: 100, max: 200 },      # Soul sphere
+
+        # Armor
+        2015 => { cat: :armor, amount: 1, max: 200 },         # Armor bonus (+1, up to 200)
+        2018 => { cat: :armor, amount: 100, armor_type: 1 },   # Green armor (100%, absorbs 1/3)
+        2019 => { cat: :armor, amount: 200, armor_type: 2 },   # Blue armor (200%, absorbs 1/2)
+
+        # Keys
+        5  => { cat: :key, key: :blue_card },
+        6  => { cat: :key, key: :yellow_card },
+        13 => { cat: :key, key: :red_card },
+        40 => { cat: :key, key: :blue_skull },
+        39 => { cat: :key, key: :yellow_skull },
+        38 => { cat: :key, key: :red_skull },
+      }.freeze
+
+      attr_reader :picked_up
+
+      def initialize(map, player_state)
+        @map = map
+        @player = player_state
+        @picked_up = {}  # thing index => true (to avoid re-picking)
+      end
+
+      def update(player_x, player_y)
+        @map.things.each_with_index do |thing, 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
+          end
+        end
+      end
+
+      private
+
+      def try_pickup(item)
+        case item[:cat]
+        when :weapon
+          give_weapon(item)
+        when :ammo
+          give_ammo(item[:ammo], item[:amount])
+        when :backpack
+          give_backpack
+        when :health
+          give_health(item[:amount], item[:max])
+        when :armor
+          give_armor(item)
+        when :key
+          give_key(item[:key])
+        else
+          false
+        end
+      end
+
+      def give_weapon(item)
+        weapon_idx = item[:weapon]
+        had_weapon = @player.has_weapons[weapon_idx]
+
+        @player.has_weapons[weapon_idx] = true
+        ammo_given = item[:ammo] ? give_ammo(item[:ammo], item[:amount]) : false
+
+        unless had_weapon
+          @player.switch_weapon(weapon_idx) unless @player.attacking
+          return true
+        end
+
+        ammo_given
+      end
+
+      def give_ammo(type, amount)
+        case type
+        when :bullets
+          return false if @player.ammo_bullets >= @player.max_bullets
+          @player.ammo_bullets = [@player.ammo_bullets + amount, @player.max_bullets].min
+        when :shells
+          return false if @player.ammo_shells >= @player.max_shells
+          @player.ammo_shells = [@player.ammo_shells + amount, @player.max_shells].min
+        when :rockets
+          return false if @player.ammo_rockets >= @player.max_rockets
+          @player.ammo_rockets = [@player.ammo_rockets + amount, @player.max_rockets].min
+        when :cells
+          return false if @player.ammo_cells >= @player.max_cells
+          @player.ammo_cells = [@player.ammo_cells + amount, @player.max_cells].min
+        end
+        true
+      end
+
+      def give_backpack
+        @player.max_bullets = 400
+        @player.max_shells = 100
+        @player.max_rockets = 100
+        @player.max_cells = 600
+        give_ammo(:bullets, 10)
+        give_ammo(:shells, 4)
+        give_ammo(:rockets, 1)
+        give_ammo(:cells, 20)
+        true
+      end
+
+      def give_health(amount, max)
+        return false if @player.health >= max
+        @player.health = [@player.health + amount, max].min
+        true
+      end
+
+      def give_armor(item)
+        if item[:armor_type]
+          # Green/blue armor: only pick up if better than current
+          return false if @player.armor >= item[:amount]
+          @player.armor = item[:amount]
+        else
+          # Armor bonus: +1, up to max
+          return false if @player.armor >= item[:max]
+          @player.armor = [@player.armor + item[:amount], item[:max]].min
+        end
+        true
+      end
+
+      def give_key(key)
+        return false if @player.keys[key]
+        @player.keys[key] = true
+        true
+      end
+    end
+  end
+end

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

@@ -26,16 +26,16 @@ module Doom
         WEAPON_CHAINSAW => :chainsaw
       }.freeze
 
-      # Attack durations (in frames at 35fps)
+      # Attack durations in tics (at 35fps), matching DOOM's weapon state sequences
       ATTACK_DURATIONS = {
-        WEAPON_FIST => 12,
-        WEAPON_PISTOL => 8,
-        WEAPON_SHOTGUN => 20,
-        WEAPON_CHAINGUN => 4,
-        WEAPON_ROCKET => 16,
-        WEAPON_PLASMA => 6,
-        WEAPON_BFG => 40,
-        WEAPON_CHAINSAW => 4
+        WEAPON_FIST => 14,       # Punch windup + swing
+        WEAPON_PISTOL => 16,     # S_PISTOL: 6+4+5+1 tics
+        WEAPON_SHOTGUN => 40,    # Pump action cycle
+        WEAPON_CHAINGUN => 8,    # Rapid fire (2 shots per cycle)
+        WEAPON_ROCKET => 20,     # Rocket launch + recovery
+        WEAPON_PLASMA => 8,      # Fast energy weapon
+        WEAPON_BFG => 60,        # Long charge + fire
+        WEAPON_CHAINSAW => 6     # Fast melee
       }.freeze
 
       attr_accessor :health, :armor, :max_health, :max_armor
@@ -46,6 +46,28 @@ 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
+      VIEWHEIGHT_HALF = VIEWHEIGHT / 2.0
+      DELTA_ACCEL = 0.25        # deltaviewheight += FRACUNIT/4 per tic
+      attr_reader :viewheight, :deltaviewheight
+
+      # View bob (camera bounce when walking, matching Chocolate Doom's
+      # P_CalcHeight + P_XYMovement + P_Thrust from p_user.c / p_mobj.c)
+      MAXBOB = 16.0           # Maximum bob amplitude (0x100000 in fixed-point = 16 map units)
+      STOPSPEED = 0.0625      # Snap-to-zero threshold (0x1000 in fixed-point)
+      # Continuous-time equivalents of DOOM's per-tic constants (35 fps tic rate):
+      #   FRICTION = 0xE800/0x10000 = 0.90625 per tic
+      #   decay_rate = -ln(0.90625) * 35 = 3.44/sec
+      #   walk thrust = forwardmove(25) * 2048 / 65536 = 0.78 map units/tic = 27.3/sec
+      #   terminal velocity = 27.3 / 3.44 = 7.56 -> bob = 7.56^2/4 = 14.3 (89% of MAXBOB)
+      BOB_DECAY_RATE = 3.44   # Friction as continuous decay rate (1/sec)
+      BOB_THRUST = 26.0       # Walk thrust (map units/sec), gives terminal ~7.5
+      BOB_FREQUENCY = 11.0    # Bob cycle frequency (rad/sec): FINEANGLES/20 * 35 / 8192 * 2*PI
+      attr_reader :view_bob_offset
 
       def initialize
         reset
@@ -87,10 +109,27 @@ 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
         @is_moving = false
+
+        # Smooth step height (P_CalcHeight viewheight/deltaviewheight)
+        @viewheight = VIEWHEIGHT
+        @deltaviewheight = 0.0
+
+        # View bob (camera bounce) - simulated momentum for P_CalcHeight
+        @view_bob_offset = 0.0
+        @momx = 0.0        # Simulated X momentum (map units/sec, not actual movement)
+        @momy = 0.0        # Simulated Y momentum
+        @thrust_x = 0.0    # Per-frame thrust input (raw, before normalization)
+        @thrust_y = 0.0
+        @view_bob_angle = 0.0
       end
 
       def weapon_name
@@ -190,6 +229,66 @@ module Doom
         end
       end
 
+      # Called when player moves onto a different floor height.
+      # Matches Chocolate Doom P_ZMovement: reduce viewheight by the step amount
+      # so the camera doesn't snap, then let P_CalcHeight recover it smoothly.
+      def notify_step(step_amount)
+        return if step_amount == 0
+        @viewheight -= step_amount
+        @deltaviewheight = (VIEWHEIGHT - @viewheight) / 8.0
+      end
+
+      # Gradually restore viewheight to VIEWHEIGHT (called each tic).
+      # Matches Chocolate Doom P_CalcHeight viewheight recovery loop.
+      # For step-up: viewheight < 41, delta > 0, accelerates upward.
+      # For step-down: viewheight > 41, delta < 0, decelerates then recovers.
+      def update_viewheight
+        @viewheight += @deltaviewheight
+
+        if @viewheight > VIEWHEIGHT && @deltaviewheight >= 0
+          @viewheight = VIEWHEIGHT
+          @deltaviewheight = 0.0
+        end
+
+        if @viewheight < VIEWHEIGHT_HALF
+          @viewheight = VIEWHEIGHT_HALF
+          @deltaviewheight = 1.0 if @deltaviewheight <= 0
+        end
+
+        if @deltaviewheight != 0
+          @deltaviewheight += DELTA_ACCEL
+          @deltaviewheight = 0.0 if @deltaviewheight.abs < 0.01 && (@viewheight - VIEWHEIGHT).abs < 0.5
+        end
+      end
+
+      # Set movement momentum directly (called from GosuWindow with actual
+      # movement momentum, which already has thrust + friction applied).
+      def set_movement_momentum(momx, momy)
+        @momx = momx
+        @momy = momy
+      end
+
+      # Compute view bob from actual movement momentum.
+      # Matches Chocolate Doom P_CalcHeight:
+      #   bob = (momx*momx + momy*momy) >> 2, capped at MAXBOB
+      #   viewz += finesine[angle] * bob/2
+      # Momentum is in units/sec; DOOM's bob uses units/tic (divide by 35).
+      BOB_MOM_SCALE = 1.0 / (35.0 * 35.0 * 4.0)  # (mom/35)^2 / 4
+
+      def update_view_bob(delta_time)
+        dt = delta_time.clamp(0.001, 0.05)
+
+        # P_CalcHeight: bob = (momx_per_tic^2 + momy_per_tic^2) / 4, capped at MAXBOB
+        bob = (@momx * @momx + @momy * @momy) * BOB_MOM_SCALE
+        bob = MAXBOB if bob > MAXBOB
+
+        # Advance bob sine wave (FINEANGLES/20 per tic = ~11 rad/sec)
+        @view_bob_angle += BOB_FREQUENCY * dt
+
+        # viewz offset: sin(angle) * bob/2
+        @view_bob_offset = Math.sin(@view_bob_angle) * bob / 2.0
+      end
+
       def weapon_bob_x
         Math.cos(@bob_angle) * @bob_amount
       end
@@ -216,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