doom 0.2.0 → 0.4.0

data/lib/doom/render/status_bar.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module Doom
+  module Render
+    # Renders the classic DOOM status bar at the bottom of the screen
+    class StatusBar
+      STATUS_BAR_HEIGHT = 32
+      STATUS_BAR_Y = SCREEN_HEIGHT - STATUS_BAR_HEIGHT
+
+      # DOOM status bar layout (from st_stuff.c)
+      # X positions are RIGHT EDGE of each number area (numbers are right-aligned)
+      # Y positions relative to status bar top
+
+      # Right edge X positions for numbers
+      AMMO_RIGHT_X = 44      # ST_AMMOX - right edge of 3-digit ammo
+      HEALTH_RIGHT_X = 90    # ST_HEALTHX - right edge of 3-digit health
+      ARMOR_RIGHT_X = 221    # ST_ARMORX - right edge of 3-digit armor
+
+      FACE_X = 149           # Adjusted for proper centering in face background
+      KEYS_X = 239           # ST_KEY0X
+
+      NUM_WIDTH = 14         # Width of each digit
+
+      def initialize(hud_graphics, player_state)
+        @gfx = hud_graphics
+        @player = player_state
+        @face_timer = 0
+        @face_index = 0
+      end
+
+      def render(framebuffer)
+        # Draw status bar background
+        draw_sprite(framebuffer, @gfx.status_bar, 0, STATUS_BAR_Y) if @gfx.status_bar
+
+        # Y position for numbers (3 pixels from top of status bar)
+        num_y = STATUS_BAR_Y + 3
+
+        # Draw ammo count (right-aligned ending at AMMO_RIGHT_X)
+        draw_number_right(framebuffer, @player.current_ammo, AMMO_RIGHT_X, num_y) if @player.current_ammo
+
+        # Draw health with percent (right-aligned ending at HEALTH_RIGHT_X)
+        draw_number_right(framebuffer, @player.health, HEALTH_RIGHT_X, num_y)
+        draw_percent(framebuffer, HEALTH_RIGHT_X, num_y)
+
+        # Draw face
+        draw_face(framebuffer)
+
+        # Draw armor with percent (right-aligned ending at ARMOR_RIGHT_X)
+        draw_number_right(framebuffer, @player.armor, ARMOR_RIGHT_X, num_y)
+        draw_percent(framebuffer, ARMOR_RIGHT_X, num_y)
+
+        # Draw keys
+        draw_keys(framebuffer)
+      end
+
+      def update
+        # Cycle face animation
+        @face_timer += 1
+        if @face_timer > 15  # Change face every ~0.5 seconds
+          @face_timer = 0
+          @face_index = (@face_index + 1) % 3
+        end
+      end
+
+      private
+
+      def draw_sprite(framebuffer, sprite, x, y)
+        return unless sprite
+
+        sprite.width.times do |sx|
+          column = sprite.column_pixels(sx)
+          next unless column
+
+          draw_x = x + sx
+          next if draw_x < 0 || draw_x >= SCREEN_WIDTH
+
+          column.each_with_index do |color, sy|
+            next unless color
+
+            draw_y = y + sy
+            next if draw_y < 0 || draw_y >= SCREEN_HEIGHT
+
+            framebuffer[draw_y * SCREEN_WIDTH + draw_x] = color
+          end
+        end
+      end
+
+      # Draw number right-aligned with right edge at right_x
+      def draw_number_right(framebuffer, value, right_x, y)
+        return unless value
+
+        value = value.to_i.clamp(-999, 999)
+        str = value.to_s
+
+        # Draw from right to left, starting from right edge
+        current_x = right_x
+        str.reverse.each_char do |char|
+          digit_sprite = if char == '-'
+                           @gfx.numbers['-']
+                         else
+                           @gfx.numbers[char.to_i]
+                         end
+
+          if digit_sprite
+            current_x -= NUM_WIDTH
+            draw_sprite(framebuffer, digit_sprite, current_x, y)
+          end
+        end
+      end
+
+      def draw_percent(framebuffer, x, y)
+        percent = @gfx.numbers['%']
+        draw_sprite(framebuffer, percent, x, y) if percent
+      end
+
+      def draw_face(framebuffer)
+        # In DOOM, face sprite health levels are inverted: 0 = full health, 4 = dying
+        sprite_health = 4 - @player.health_level
+        faces = @gfx.faces[sprite_health]
+        return unless faces
+
+        # Get current face sprite
+        face = if @player.health <= 0
+                 @gfx.faces[:dead]
+               elsif faces[:straight] && faces[:straight][@face_index]
+                 faces[:straight][@face_index]
+               else
+                 faces[:straight]&.first
+               end
+
+        return unless face
+
+        # Position face in the background area
+        face_x = FACE_X
+        face_y = STATUS_BAR_Y + 2  # Slightly below top of status bar
+        draw_sprite(framebuffer, face, face_x, face_y)
+      end
+
+      def draw_keys(framebuffer)
+        key_x = KEYS_X
+        key_spacing = 10
+
+        # Blue keys (top row)
+        if @player.keys[:blue_card]
+          draw_sprite(framebuffer, @gfx.keys[:blue_card], key_x, STATUS_BAR_Y + 3)
+        elsif @player.keys[:blue_skull]
+          draw_sprite(framebuffer, @gfx.keys[:blue_skull], key_x, STATUS_BAR_Y + 3)
+        end
+
+        # Yellow keys (middle row)
+        if @player.keys[:yellow_card]
+          draw_sprite(framebuffer, @gfx.keys[:yellow_card], key_x, STATUS_BAR_Y + 13)
+        elsif @player.keys[:yellow_skull]
+          draw_sprite(framebuffer, @gfx.keys[:yellow_skull], key_x, STATUS_BAR_Y + 13)
+        end
+
+        # Red keys (bottom row)
+        if @player.keys[:red_card]
+          draw_sprite(framebuffer, @gfx.keys[:red_card], key_x, STATUS_BAR_Y + 23)
+        elsif @player.keys[:red_skull]
+          draw_sprite(framebuffer, @gfx.keys[:red_skull], key_x, STATUS_BAR_Y + 23)
+        end
+      end
+    end
+  end
+end

data/lib/doom/render/weapon_renderer.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Doom
+  module Render
+    # Renders the first-person weapon view
+    class WeaponRenderer
+      # Weapon is rendered above the status bar
+      WEAPON_AREA_HEIGHT = SCREEN_HEIGHT - StatusBar::STATUS_BAR_HEIGHT
+
+      def initialize(hud_graphics, player_state)
+        @gfx = hud_graphics
+        @player = player_state
+      end
+
+      def render(framebuffer)
+        weapon_name = @player.weapon_name
+        weapon_data = @gfx.weapons[weapon_name]
+        return unless weapon_data
+
+        # Get the appropriate frame
+        sprite = if @player.attacking && weapon_data[:fire]
+                   frame = @player.attack_frame.clamp(0, weapon_data[:fire].length - 1)
+                   weapon_data[:fire][frame]
+                 else
+                   weapon_data[:idle]
+                 end
+
+        return unless sprite
+
+        # Calculate position with bob offset
+        bob_x = @player.weapon_bob_x.to_i
+        bob_y = @player.weapon_bob_y.to_i
+
+        # Center weapon horizontally (sprite width / 2 from center)
+        # Position weapon at bottom of view area
+        x = (SCREEN_WIDTH / 2) - (sprite.width / 2) + bob_x
+        # Only allow downward bob (positive values) to keep weapon bottom at status bar
+        clamped_bob_y = [bob_y, 0].max
+        y = WEAPON_AREA_HEIGHT - sprite.height + clamped_bob_y
+
+        # Add some vertical offset during attack (recoil effect)
+        if @player.attacking
+          recoil = case @player.attack_frame
+                   when 0 then -6
+                   when 1 then -3
+                   when 2 then 3
+                   else 0
+                   end
+          y += recoil
+        end
+
+        draw_weapon_sprite(framebuffer, sprite, x, y)
+
+        # Draw muzzle flash for pistol
+        if @player.attacking && @player.attack_frame < 2
+          draw_muzzle_flash(framebuffer, weapon_name, x, y)
+        end
+      end
+
+      private
+
+      def draw_weapon_sprite(framebuffer, sprite, base_x, base_y)
+        return unless sprite
+
+        # Clip to screen bounds (don't draw over status bar)
+        max_y = WEAPON_AREA_HEIGHT - 1
+
+        sprite.width.times do |sx|
+          column = sprite.column_pixels(sx)
+          next unless column
+
+          draw_x = base_x + sx
+          next if draw_x < 0 || draw_x >= SCREEN_WIDTH
+
+          column.each_with_index do |color, sy|
+            next unless color  # Skip transparent pixels
+
+            draw_y = base_y + sy
+            next if draw_y < 0 || draw_y > max_y
+
+            framebuffer[draw_y * SCREEN_WIDTH + draw_x] = color
+          end
+        end
+      end
+
+      def draw_muzzle_flash(framebuffer, weapon_name, weapon_x, weapon_y)
+        weapon_data = @gfx.weapons[weapon_name]
+        return unless weapon_data && weapon_data[:flash]
+
+        flash_frame = @player.attack_frame.clamp(0, weapon_data[:flash].length - 1)
+        flash_sprite = weapon_data[:flash][flash_frame]
+        return unless flash_sprite
+
+        # Flash is drawn at weapon position (sprite handles offset)
+        flash_x = (SCREEN_WIDTH / 2) - flash_sprite.left_offset
+        flash_y = WEAPON_AREA_HEIGHT - flash_sprite.top_offset
+
+        draw_weapon_sprite(framebuffer, flash_sprite, flash_x, flash_y)
+      end
+    end
+  end
+end

data/lib/doom/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Doom
-  VERSION = "0.2.0"
+  VERSION = '0.4.0'
 end

data/lib/doom/wad/colormap.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Doom
+  module Wad
+    class Colormap
+      MAPS = 34
+      MAP_SIZE = 256
+
+      attr_reader :maps
+
+      def initialize(maps)
+        @maps = maps
+      end
+
+      def [](map_index)
+        @maps[map_index]
+      end
+
+      def self.load(wad)
+        data = wad.read_lump('COLORMAP')
+        raise Error, 'COLORMAP lump not found' unless data
+
+        maps = MAPS.times.map do |i|
+          offset = i * MAP_SIZE
+          data[offset, MAP_SIZE].bytes
+        end
+
+        new(maps)
+      end
+    end
+  end
+end

data/lib/doom/wad/flat.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Doom
+  module Wad
+    class Flat
+      WIDTH = 64
+      HEIGHT = 64
+      SIZE = WIDTH * HEIGHT
+
+      attr_reader :name, :pixels
+
+      def width
+        WIDTH
+      end
+
+      def height
+        HEIGHT
+      end
+
+      def initialize(name, pixels)
+        @name = name
+        @pixels = pixels
+      end
+
+      def [](x, y)
+        @pixels[(y & 63) * WIDTH + (x & 63)]
+      end
+
+      def self.load_all(wad)
+        entries = wad.lumps_between('F_START', 'F_END')
+        entries.map do |entry|
+          next if entry.size != SIZE
+
+          data = wad.read_lump_at(entry)
+          new(entry.name, data.bytes)
+        end.compact
+      end
+    end
+  end
+end

data/lib/doom/wad/hud_graphics.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Doom
+  module Wad
+    # Loads HUD graphics (status bar, weapons) from WAD
+    class HudGraphics
+      attr_reader :status_bar, :numbers, :weapons, :faces, :keys
+
+      def initialize(wad)
+        @wad = wad
+        @cache = {}
+
+        load_status_bar
+        load_numbers
+        load_weapons
+        load_faces
+        load_keys
+      end
+
+      # Get a cached graphic by name
+      def [](name)
+        @cache[name]
+      end
+
+      private
+
+      def load_graphic(name)
+        return @cache[name] if @cache[name]
+
+        entry = @wad.find_lump(name)
+        return nil unless entry
+
+        data = @wad.read_lump_at(entry)
+        return nil unless data && data.size > 8
+
+        sprite = parse_patch(name, data)
+        @cache[name] = sprite
+        sprite
+      end
+
+      def parse_patch(name, data)
+        width = data[0, 2].unpack1('v')
+        height = data[2, 2].unpack1('v')
+        left_offset = data[4, 2].unpack1('s<')
+        top_offset = data[6, 2].unpack1('s<')
+
+        # Read column offsets
+        column_offsets = width.times.map do |i|
+          data[8 + i * 4, 4].unpack1('V')
+        end
+
+        # Build column data
+        columns = column_offsets.map do |offset|
+          read_column(data, offset, height)
+        end
+
+        HudSprite.new(name, width, height, left_offset, top_offset, columns)
+      end
+
+      def read_column(data, offset, height)
+        pixels = Array.new(height)
+        pos = offset
+
+        loop do
+          break if pos >= data.size
+          top_delta = data[pos].ord
+          break if top_delta == 0xFF
+
+          length = data[pos + 1].ord
+          # Skip padding byte, read pixels, skip end padding
+          pixel_data = data[pos + 3, length]
+          break unless pixel_data
+
+          pixel_data.bytes.each_with_index do |color, i|
+            y = top_delta + i
+            pixels[y] = color if y < height
+          end
+
+          pos += length + 4
+        end
+
+        pixels
+      end
+
+      def load_status_bar
+        @status_bar = load_graphic('STBAR')
+      end
+
+      def load_numbers
+        @numbers = {}
+        # Large red numbers for health/ammo
+        (0..9).each do |n|
+          @numbers[n] = load_graphic("STTNUM#{n}")
+        end
+        @numbers['-'] = load_graphic('STTMINUS')
+        @numbers['%'] = load_graphic('STTPRCNT')
+
+        # Small grey numbers for arms
+        @grey_numbers = {}
+        (0..9).each do |n|
+          @grey_numbers[n] = load_graphic("STGNUM#{n}")
+        end
+      end
+
+      def load_weapons
+        @weapons = {}
+
+        # Pistol frames (PISG = pistol gun)
+        @weapons[:pistol] = {
+          idle: load_graphic('PISGA0'),
+          fire: [
+            load_graphic('PISGB0'),
+            load_graphic('PISGC0'),
+            load_graphic('PISGD0'),
+            load_graphic('PISGE0')
+          ].compact,
+          flash: [
+            load_graphic('PISFA0'),
+            load_graphic('PISFB0')
+          ].compact
+        }
+
+        # Fist frames (PUNG = punch)
+        @weapons[:fist] = {
+          idle: load_graphic('PUNGA0'),
+          fire: [
+            load_graphic('PUNGB0'),
+            load_graphic('PUNGC0'),
+            load_graphic('PUNGD0')
+          ].compact
+        }
+      end
+
+      def load_faces
+        @faces = {}
+
+        # Straight ahead faces at different health levels
+        # STF = status face, ST = straight, 0-4 = health level (4=full, 0=dying)
+        (0..4).each do |health_level|
+          @faces[health_level] = {
+            straight: [
+              load_graphic("STFST#{health_level}0"),
+              load_graphic("STFST#{health_level}1"),
+              load_graphic("STFST#{health_level}2")
+            ].compact,
+            left: load_graphic("STFTL#{health_level}0"),
+            right: load_graphic("STFTR#{health_level}0"),
+            ouch: load_graphic("STFOUCH#{health_level}"),
+            evil: load_graphic("STFEVL#{health_level}"),
+            kill: load_graphic("STFKILL#{health_level}")
+          }
+        end
+
+        # Special faces
+        @faces[:dead] = load_graphic('STFDEAD0')
+        @faces[:god] = load_graphic('STFGOD0')
+      end
+
+      def load_keys
+        @keys = {
+          blue_card: load_graphic('STKEYS0'),
+          yellow_card: load_graphic('STKEYS1'),
+          red_card: load_graphic('STKEYS2'),
+          blue_skull: load_graphic('STKEYS3'),
+          yellow_skull: load_graphic('STKEYS4'),
+          red_skull: load_graphic('STKEYS5')
+        }
+      end
+    end
+
+    # Simple sprite container for HUD graphics
+    class HudSprite
+      attr_reader :name, :width, :height, :left_offset, :top_offset, :columns
+
+      def initialize(name, width, height, left_offset, top_offset, columns)
+        @name = name
+        @width = width
+        @height = height
+        @left_offset = left_offset
+        @top_offset = top_offset
+        @columns = columns
+      end
+
+      def column_pixels(x)
+        @columns[x % @width]
+      end
+    end
+  end
+end

data/lib/doom/wad/palette.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Doom
+  module Wad
+    class Palette
+      COLORS = 256
+      PALETTES = 14
+      PALETTE_SIZE = COLORS * 3
+
+      attr_reader :colors
+
+      def initialize(colors)
+        @colors = colors
+      end
+
+      def [](index)
+        @colors[index]
+      end
+
+      def self.load(wad, palette_index = 0)
+        data = wad.read_lump('PLAYPAL')
+        raise Error, 'PLAYPAL lump not found' unless data
+
+        offset = palette_index * PALETTE_SIZE
+        colors = COLORS.times.map do |i|
+          [
+            data[offset + i * 3].ord,
+            data[offset + i * 3 + 1].ord,
+            data[offset + i * 3 + 2].ord
+          ]
+        end
+
+        new(colors)
+      end
+    end
+  end
+end

data/lib/doom/wad/patch.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Doom
+  module Wad
+    class Patch
+      Post = Struct.new(:top_delta, :pixels)
+
+      attr_reader :name, :width, :height, :left_offset, :top_offset, :columns
+
+      def initialize(name, width, height, left_offset, top_offset, columns)
+        @name = name
+        @width = width
+        @height = height
+        @left_offset = left_offset
+        @top_offset = top_offset
+        @columns = columns
+      end
+
+      def self.load(wad, name)
+        data = wad.read_lump(name)
+        return nil unless data
+
+        parse(name, data)
+      end
+
+      def self.parse(name, data)
+        width = data[0, 2].unpack1('v')
+        height = data[2, 2].unpack1('v')
+        left_offset = data[4, 2].unpack1('s<')
+        top_offset = data[6, 2].unpack1('s<')
+
+        column_offsets = width.times.map do |i|
+          data[8 + i * 4, 4].unpack1('V')
+        end
+
+        columns = column_offsets.map do |offset|
+          read_column(data, offset)
+        end
+
+        new(name, width, height, left_offset, top_offset, columns)
+      end
+
+      def self.read_column(data, offset)
+        posts = []
+        pos = offset
+
+        loop do
+          top_delta = data[pos].ord
+          break if top_delta == 0xFF
+
+          length = data[pos + 1].ord
+          pixels = data[pos + 3, length].bytes
+          posts << Post.new(top_delta, pixels)
+          pos += length + 4
+        end
+
+        posts
+      end
+    end
+  end
+end