doom 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70d72175c1f115b3363e188d7075047bc32cece4f3a3dd1feda17dc6f965b07f
-  data.tar.gz: 22eb9172267c578a6fbaa3dd526ec19e8d4587dba9a349080ad1626d3e04fd92
+  metadata.gz: c4672b03d393f17c1cd9ece97869d7239a7af3e91d3ffa47b911b0ba3058f673
+  data.tar.gz: 56772f44ced59386c92f5319c0d25dc8612e96263d68ae7e9a240d26508571cf
 SHA512:
-  metadata.gz: 6f5fdd281119ba4bec5a29b8f9cd32f8d0aa37d1674125c3095835ba24942e66e6356037c3e424f320578cac5b1ed94dc7738388d3ced296f8de22ce78e9e79e
-  data.tar.gz: 35de5ff2f711aa4084a54d811d26b919cf8f1b00be1d9b06597b7e7aac09eab3ee8ff597b1ece2ac451d175dad2faf3c16bc73f3dbf56b50867407509fc4f234
+  metadata.gz: b11b52ed631217b002aae05a4f87b7ff5fcb208485b75dd9077ebcc222c3823c6ca74167e9bc6b7c3605c0481472abbc818e6445c8fa130c744fe8c54da53099
+  data.tar.gz: 808176138162ef4e21796dd995a6bd794eee89e4c631032134349746afd468d446b610a0939daf19c26a2706abac22635306d6e3fb1c1c93e9a70282a2114f7d

data/README.md

@@ -2,7 +2,7 @@
 
 A faithful ruby port of the DOOM (1993) rendering engine to Ruby.
 
-![DOOM Ruby Screenshot](https://raw.githubusercontent.com/khasinski/doom-rb/main/e1m1_spawn.png)
+![DOOM Ruby](demo.gif)
 
 ## Features
 

data/lib/doom/game/animations.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # Animated texture/flat cycling, matching Chocolate Doom's P_InitPicAnims
+    # and P_UpdateSpecials from p_spec.c.
+    #
+    # All animations run at 8 tics per frame (8/35 sec ≈ 0.23s).
+    # Frames must be consecutive entries in the WAD; the engine uses
+    # start/end names to find the range.
+    class Animations
+      TICS_PER_FRAME = 8
+
+      # [is_texture, start_name, end_name]
+      # From Chocolate Doom animdefs[] in p_spec.c
+      ANIMDEFS = [
+        # Animated flats
+        [false, 'NUKAGE1',  'NUKAGE3'],
+        [false, 'FWATER1',  'FWATER4'],
+        [false, 'SWATER1',  'SWATER4'],
+        [false, 'LAVA1',    'LAVA4'],
+        [false, 'BLOOD1',   'BLOOD3'],
+        [false, 'RROCK05',  'RROCK08'],
+        [false, 'SLIME01',  'SLIME04'],
+        [false, 'SLIME05',  'SLIME08'],
+        [false, 'SLIME09',  'SLIME12'],
+        # Animated wall textures
+        [true, 'BLODGR1',  'BLODGR4'],
+        [true, 'SLADRIP1', 'SLADRIP3'],
+        [true, 'BLODRIP1', 'BLODRIP4'],
+        [true, 'FIREWALA', 'FIREWALL'],
+        [true, 'GSTFONT1', 'GSTFONT3'],
+        [true, 'FIRELAV3', 'FIRELAVA'],
+        [true, 'FIREMAG1', 'FIREMAG3'],
+        [true, 'FIREBLU1', 'FIREBLU2'],
+        [true, 'ROCKRED1', 'ROCKRED3'],
+        [true, 'BFALL1',   'BFALL4'],
+        [true, 'SFALL1',   'SFALL4'],
+        [true, 'WFALL1',   'WFALL4'],
+        [true, 'DBRAIN1',  'DBRAIN4'],
+      ].freeze
+
+      attr_reader :flat_translation, :texture_translation
+
+      def initialize(texture_names, flat_names)
+        @flat_translation = {}      # flat_name -> current_frame_name
+        @texture_translation = {}   # texture_name -> current_frame_name
+        @anims = []
+
+        ANIMDEFS.each do |is_texture, start_name, end_name|
+          names = is_texture ? texture_names : flat_names
+
+          start_idx = names.index(start_name)
+          end_idx = names.index(end_name)
+          next unless start_idx && end_idx
+          next if end_idx <= start_idx
+
+          frames = names[start_idx..end_idx]
+          next if frames.size < 2
+
+          @anims << {
+            is_texture: is_texture,
+            frames: frames,
+            speed: TICS_PER_FRAME,
+          }
+        end
+      end
+
+      # Call every game tic (or approximate with leveltime).
+      # Matches Chocolate Doom P_UpdateSpecials:
+      #   pic = basepic + ((leveltime / speed + i) % numpics)
+      def update(leveltime)
+        @anims.each do |anim|
+          frames = anim[:frames]
+          numpics = frames.size
+          phase = leveltime / anim[:speed]
+          translation = anim[:is_texture] ? @texture_translation : @flat_translation
+
+          numpics.times do |i|
+            current_frame = frames[(phase + i) % numpics]
+            translation[frames[i]] = current_frame
+          end
+        end
+      end
+
+      # Translate a flat name to its current animation frame
+      def translate_flat(name)
+        @flat_translation[name] || name
+      end
+
+      # Translate a texture name to its current animation frame
+      def translate_texture(name)
+        @texture_translation[name] || name
+      end
+    end
+  end
+end

data/lib/doom/game/combat.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module Doom
+  module Game
+    # Hitscan weapon firing and monster state tracking.
+    # Matches Chocolate Doom's P_LineAttack / P_AimLineAttack from p_map.c.
+    class Combat
+      # Monster starting HP (from mobjinfo[] in info.c)
+      MONSTER_HP = {
+        3004 => 20,   # Zombieman
+        9    => 30,   # Shotgun Guy
+        3001 => 60,   # Imp
+        3002 => 150,  # Demon
+        58   => 150,  # Spectre
+        3003 => 1000, # Baron of Hell
+        69   => 500,  # Hell Knight
+        3005 => 400,  # Cacodemon
+        3006 => 100,  # Lost Soul
+        16   => 4000, # Cyberdemon
+        7    => 3000, # Spider Mastermind
+        65   => 70,   # Heavy Weapon Dude
+        64   => 700,  # Archvile
+        71   => 400,  # Pain Elemental
+        84   => 20,   # Wolfenstein SS
+      }.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,
+      }.freeze
+
+      # 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 = {
+        'POSS' => %w[H I J K L],       # Zombieman: 55→46→34→27→17
+        'SPOS' => %w[H I J K L],       # Shotgun Guy: 60→50→35→27→17
+        'TROO' => %w[I J K L M],       # Imp: 62→59→54→46→22
+        'SARG' => %w[I J K L M N],     # Demon/Spectre: 56→56→53→57→46→32
+        'BOSS' => %w[H I J K L M N],   # Baron
+        'BOS2' => %w[H I J K L M N],   # Hell Knight
+        'HEAD' => %w[G H I J K L],     # Cacodemon
+        'SKUL' => %w[G H I J K],       # Lost Soul
+        'CYBR' => %w[I J],             # Cyberdemon
+        'SPID' => %w[I J K],           # Spider Mastermind
+        '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
+      }.freeze
+
+      DEATH_ANIM_TICS = 6  # Tics per death frame
+
+      # 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)
+        @map = map
+        @player = player_state
+        @sprites = sprites
+        @monster_hp = {}     # thing_idx => current HP
+        @dead_things = {}    # thing_idx => { tic: death_start_tic, prefix: sprite_prefix }
+        @tic = 0
+      end
+
+      attr_reader :dead_things
+
+      def dead?(thing_idx)
+        @dead_things.key?(thing_idx)
+      end
+
+      # Get the current death frame sprite for a dead monster
+      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]]
+        return nil unless frames
+
+        elapsed = @tic - info[:tic]
+        frame_idx = (elapsed / DEATH_ANIM_TICS).clamp(0, frames.size - 1)
+        frame_letter = frames[frame_idx]
+
+        @sprites.get_frame(thing_type, frame_letter, viewer_angle, thing_angle)
+      end
+
+      # Called each game tic
+      def update
+        @tic += 1
+      end
+
+      # Fire the current weapon
+      def fire(px, py, pz, cos_a, sin_a, weapon)
+        case weapon
+        when PlayerState::WEAPON_PISTOL, PlayerState::WEAPON_CHAINGUN
+          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_FIST
+          melee(px, py, cos_a, sin_a, 2, 64)
+        when PlayerState::WEAPON_CHAINSAW
+          melee(px, py, cos_a, sin_a, 2, 64)
+        end
+      end
+
+      private
+
+      def hitscan(px, py, cos_a, sin_a, pellets, spread, multiplier)
+        pellets.times do
+          # Add random spread
+          if spread > 0
+            angle = Math.atan2(sin_a, cos_a) + (rand - 0.5) * spread * 2
+            ca = Math.cos(angle)
+            sa = Math.sin(angle)
+          else
+            # Slight pistol/chaingun spread
+            angle = Math.atan2(sin_a, cos_a) + (rand - 0.5) * 0.04
+            ca = Math.cos(angle)
+            sa = Math.sin(angle)
+          end
+
+          wall_dist = trace_wall(px, py, ca, sa)
+
+          best_idx = nil
+          best_dist = wall_dist
+
+          @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
+            hit_dist = ray_circle_hit(px, py, ca, sa, thing.x, thing.y, radius)
+            if hit_dist && hit_dist > 0 && hit_dist < best_dist
+              best_dist = hit_dist
+              best_idx = idx
+            end
+          end
+
+          if best_idx
+            damage = (rand(3) + 1) * multiplier
+            apply_damage(best_idx, damage)
+          end
+        end
+      end
+
+      def melee(px, py, cos_a, sin_a, multiplier, range)
+        best_idx = nil
+        best_dist = range.to_f
+
+        @map.things.each_with_index do |thing, idx|
+          next unless MONSTER_HP[thing.type]
+          next if @dead_things[idx]
+
+          dx = thing.x - px
+          dy = thing.y - py
+          dist = Math.sqrt(dx * dx + dy * dy)
+          next if dist > range + (MONSTER_RADIUS[thing.type] || 20)
+
+          # Check if roughly facing the monster
+          dot = dx * cos_a + dy * sin_a
+          next if dot < 0
+
+          if dist < best_dist
+            best_dist = dist
+            best_idx = idx
+          end
+        end
+
+        if best_idx
+          damage = (rand(3) + 1) * multiplier
+          apply_damage(best_idx, damage)
+        end
+      end
+
+      def apply_damage(thing_idx, damage)
+        thing = @map.things[thing_idx]
+        @monster_hp[thing_idx] ||= MONSTER_HP[thing.type] || 20
+
+        @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
+        end
+      end
+
+      def trace_wall(px, py, cos_a, sin_a)
+        best_t = 4096.0  # Max hitscan range
+
+        @map.linedefs.each do |ld|
+          v1 = @map.vertices[ld.v1]
+          v2 = @map.vertices[ld.v2]
+
+          # One-sided always blocks; two-sided only if impassable
+          blocks = (ld.sidedef_left == 0xFFFF) || (ld.flags & 0x0001 != 0)
+          unless blocks
+            next unless ld.sidedef_left < 0xFFFF
+            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
+          end
+          next unless blocks
+
+          t = ray_segment_intersect(px, py, cos_a, sin_a,
+                                     v1.x, v1.y, v2.x, v2.y)
+          best_t = t if t && t > 0 && t < best_t
+        end
+
+        best_t
+      end
+
+      def ray_segment_intersect(px, py, dx, dy, x1, y1, x2, y2)
+        sx = x2 - x1
+        sy = y2 - y1
+        denom = dx * sy - dy * sx
+        return nil if denom.abs < 0.001
+
+        t = ((x1 - px) * sy - (y1 - py) * sx) / denom
+        u = ((x1 - px) * dy - (y1 - py) * dx) / denom
+
+        (t > 0 && u >= 0.0 && u <= 1.0) ? t : nil
+      end
+
+      def ray_circle_hit(px, py, cos_a, sin_a, cx, cy, radius)
+        dx = cx - px
+        dy = cy - py
+        proj = dx * cos_a + dy * sin_a
+        return nil if proj < 0
+
+        perp_sq = dx * dx + dy * dy - proj * proj
+        return nil if perp_sq > radius * radius
+
+        chord_half = Math.sqrt([radius * radius - perp_sq, 0].max)
+        proj - chord_half
+      end
+    end
+  end
+end

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