doom 0.3.0 → 0.5.0

data/lib/doom/render/status_bar.rb

@@ -0,0 +1,218 @@
+# 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)
+      # Positions from Chocolate Doom st_stuff.c (relative to status bar top)
+      AMMO_RIGHT_X = 44      # ST_AMMOX - right edge of 3-digit ammo
+      HEALTH_RIGHT_X = 90    # ST_HEALTHX
+      ARMOR_RIGHT_X = 221    # ST_ARMORX
+
+      ARMS_BG_X = 104        # ST_ARMSBGX
+      ARMS_BG_Y = 0          # ST_ARMSBGY (relative to status bar)
+      ARMS_X = 111            # ST_ARMSX
+      ARMS_Y = 4              # ST_ARMSY (relative to status bar)
+      ARMS_XSPACE = 12
+      ARMS_YSPACE = 10
+
+      FACE_X = 149           # Centered in face background area
+      FACE_Y = 2             # Vertically centered in status bar
+
+      KEYS_X = 239           # ST_KEY0X
+
+      # Small ammo counts (right side of status bar)
+      SMALL_AMMO_X = 288     # Current ammo X
+      SMALL_MAX_X = 314      # Max ammo X
+      SMALL_AMMO_Y = [5, 11, 23, 17]  # Bullets, Shells, Cells, Rockets (relative to bar)
+
+      NUM_WIDTH = 14          # Width of large digit
+      SMALL_NUM_WIDTH = 4     # Width of small 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
+
+        # Draw arms background (single-player only, replaces FRAG area)
+        draw_sprite(framebuffer, @gfx.arms_background, ARMS_BG_X, STATUS_BAR_Y + ARMS_BG_Y) if @gfx.arms_background
+
+        # 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
+        draw_number_right(framebuffer, @player.health, HEALTH_RIGHT_X, num_y)
+        draw_percent(framebuffer, HEALTH_RIGHT_X, num_y)
+
+        # Draw weapon selector (2-7)
+        draw_arms(framebuffer)
+
+        # Draw face
+        draw_face(framebuffer)
+
+        # Draw armor with percent
+        draw_number_right(framebuffer, @player.armor, ARMOR_RIGHT_X, num_y)
+        draw_percent(framebuffer, ARMOR_RIGHT_X, num_y)
+
+        # Draw keys
+        draw_keys(framebuffer)
+
+        # Draw small ammo counts (right side)
+        draw_ammo_counts(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_arms(framebuffer)
+        # Weapon numbers 2-7 in a 3x2 grid
+        6.times do |i|
+          weapon_num = i + 2  # weapons 2-7
+          owned = @player.has_weapons[weapon_num]
+          digit = owned ? @gfx.yellow_numbers[weapon_num] : @gfx.grey_numbers[weapon_num]
+          next unless digit
+
+          x = ARMS_X + (i % 3) * ARMS_XSPACE
+          y = STATUS_BAR_Y + ARMS_Y + (i / 3) * ARMS_YSPACE
+          draw_sprite(framebuffer, digit, x, y)
+        end
+      end
+
+      def draw_face(framebuffer)
+        # Pain level: 0 = healthy, 4 = near death
+        health = @player.health.clamp(0, 100)
+        pain_level = ((100 - health) * 5) / 101
+
+        face = if @player.health <= 0
+                 @gfx.faces[:dead]
+               else
+                 faces = @gfx.faces[pain_level]
+                 faces[:straight][@face_index] if faces && faces[:straight]
+               end
+
+        return unless face
+        draw_sprite(framebuffer, face, FACE_X, STATUS_BAR_Y + FACE_Y)
+      end
+
+      def draw_ammo_counts(framebuffer)
+        ammo_current = [@player.ammo_bullets, @player.ammo_shells, @player.ammo_cells, @player.ammo_rockets]
+        ammo_max = [@player.max_bullets, @player.max_shells, @player.max_cells, @player.max_rockets]
+
+        4.times do |i|
+          y = STATUS_BAR_Y + SMALL_AMMO_Y[i]
+          draw_small_number_right(framebuffer, ammo_current[i], SMALL_AMMO_X, y)
+          draw_small_number_right(framebuffer, ammo_max[i], SMALL_MAX_X, y)
+        end
+      end
+
+      def draw_small_number_right(framebuffer, value, right_x, y)
+        return unless value
+        str = value.to_i.to_s
+        current_x = right_x
+        str.reverse.each_char do |char|
+          digit = @gfx.yellow_numbers[char.to_i]
+          if digit
+            current_x -= SMALL_NUM_WIDTH
+            draw_sprite(framebuffer, digit, current_x, y)
+          end
+        end
+      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,99 @@
+# 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
+
+      # DOOM positions weapon sprites using their built-in offsets:
+      #   x = SCREENWIDTH/2 - sprite.left_offset
+      #   y = WEAPONTOP + SCREENHEIGHT - 200 - sprite.top_offset
+      # WEAPONTOP = 32 in fixed-point = 32 pixels above the default position
+      # We scale for our 240px screen vs DOOM's 200px.
+      WEAPONTOP = 32
+      SCREEN_Y_OFFSET = SCREEN_HEIGHT - 200  # 40px offset for 240px screen
+
+      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
+
+        # Bob offset (frozen during attack to keep weapon steady)
+        bob_x = @player.attacking ? 0 : @player.weapon_bob_x.to_i
+        bob_y = @player.attacking ? 0 : @player.weapon_bob_y.to_i
+
+        # DOOM's R_DrawPSprite: x1 = centerx + (psp->sx - centerx - spriteoffset)
+        # With psp->sx = 1 (default): x = 1 - left_offset
+        # Uses sprite's built-in offsets for both weapon and flash alignment
+        x = 1 - sprite.left_offset + bob_x
+        y = 1 - sprite.top_offset + SCREEN_Y_OFFSET + bob_y
+
+        draw_weapon_sprite(framebuffer, sprite, x, y)
+
+        # Draw muzzle flash only on the first fire frame (the actual shot)
+        if @player.attacking && @player.attack_frame == 0
+          draw_muzzle_flash(framebuffer, weapon_name)
+        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_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 uses same positioning as weapon sprite (built-in offsets)
+        # Same positioning formula as weapon sprite
+        flash_x = 1 - flash_sprite.left_offset
+        flash_y = 1 - flash_sprite.top_offset + SCREEN_Y_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.3.0'
+  VERSION = '0.5.0'
 end

data/lib/doom/wad/colormap.rb

@@ -16,12 +16,6 @@ module Doom
         @maps[map_index]
       end
 
-      def map_color(color_index, light_level)
-        map_index = 31 - (light_level >> 3)
-        map_index = map_index.clamp(0, 31)
-        @maps[map_index][color_index]
-      end
-
       def self.load(wad)
         data = wad.read_lump('COLORMAP')
         raise Error, 'COLORMAP lump not found' unless data

data/lib/doom/wad/flat.rb

@@ -26,27 +26,6 @@ module Doom
         @pixels[(y & 63) * WIDTH + (x & 63)]
       end
 
-      def to_png(palette, filename)
-        require 'chunky_png'
-
-        img = ChunkyPNG::Image.new(WIDTH, HEIGHT)
-        @pixels.each_with_index do |color_index, i|
-          x = i % WIDTH
-          y = i / WIDTH
-          r, g, b = palette[color_index]
-          img[x, y] = ChunkyPNG::Color.rgb(r, g, b)
-        end
-        img.save(filename)
-      end
-
-      def self.load(wad, name)
-        data = wad.read_lump(name)
-        return nil unless data
-        raise Error, "Invalid flat size: #{data.size}" unless data.size == SIZE
-
-        new(name, data.bytes)
-      end
-
       def self.load_all(wad)
         entries = wad.lumps_between('F_START', 'F_END')
         entries.map do |entry|

data/lib/doom/wad/hud_graphics.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module Doom
+  module Wad
+    # Loads HUD graphics (status bar, weapons) from WAD
+    class HudGraphics
+      attr_reader :status_bar, :arms_background, :numbers, :grey_numbers, :yellow_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')
+        @arms_background = load_graphic('STARMS')
+      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 (weapon not owned)
+        @grey_numbers = {}
+        (0..9).each do |n|
+          @grey_numbers[n] = load_graphic("STGNUM#{n}")
+        end
+
+        # Small yellow numbers for arms (weapon owned) and ammo counts
+        @yellow_numbers = {}
+        (0..9).each do |n|
+          @yellow_numbers[n] = load_graphic("STYSNUM#{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
+        }
+
+        # Shotgun (SHTG)
+        @weapons[:shotgun] = {
+          idle: load_graphic('SHTGA0'),
+          fire: [
+            load_graphic('SHTGB0'),
+            load_graphic('SHTGC0'),
+            load_graphic('SHTGD0')
+          ].compact,
+          flash: [load_graphic('SHTFA0'), load_graphic('SHTFB0')].compact
+        }
+
+        # Chaingun (CHGG)
+        @weapons[:chaingun] = {
+          idle: load_graphic('CHGGA0'),
+          fire: [
+            load_graphic('CHGGB0'),
+            load_graphic('CHGGC0')
+          ].compact,
+          flash: [load_graphic('CHGFA0'), load_graphic('CHGFB0')].compact
+        }
+
+        # Rocket launcher (MISG)
+        @weapons[:rocket] = {
+          idle: load_graphic('MISGA0'),
+          fire: [
+            load_graphic('MISGB0'),
+            load_graphic('MISGC0'),
+            load_graphic('MISGD0')
+          ].compact,
+          flash: [load_graphic('MISFA0'), load_graphic('MISFB0'), load_graphic('MISFC0')].compact
+        }
+
+        # Plasma rifle (PLSG)
+        @weapons[:plasma] = {
+          idle: load_graphic('PLSGA0'),
+          fire: [
+            load_graphic('PLSGB0')
+          ].compact,
+          flash: [load_graphic('PLSFA0'), load_graphic('PLSFB0')].compact
+        }
+
+        # BFG9000 (BFGG)
+        @weapons[:bfg] = {
+          idle: load_graphic('BFGGA0'),
+          fire: [
+            load_graphic('BFGGB0'),
+            load_graphic('BFGGC0')
+          ].compact,
+          flash: [load_graphic('BFGFA0'), load_graphic('BFGFB0')].compact
+        }
+
+        # Chainsaw (SAWG)
+        @weapons[:chainsaw] = {
+          idle: load_graphic('SAWGA0'),
+          fire: [
+            load_graphic('SAWGB0'),
+            load_graphic('SAWGC0'),
+            load_graphic('SAWGD0')
+          ].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