quake-rb 0.1.0 → 0.2.0

data/lib/quake/renderer/gl_hud.rb

@@ -15,10 +15,30 @@ module Quake
       VIRTUAL_HEIGHT = 200
       SBAR_HEIGHT    = 24  # status bar height
       DIGIT_WIDTH    = 24  # big number digit width
-
-      def initialize(wad, palette, screen_width, screen_height)
+      CHAR_SIZE      = 8
+      WEAPON_ICONS = [
+        [:shotgun, "shotgun"],
+        [:super_shotgun, "sshotgun"],
+        [:nailgun, "nailgun"],
+        [:super_nailgun, "snailgun"],
+        [:grenade_launcher, "rlaunch"],
+        [:rocket_launcher, "srlaunch"],
+        [:lightning_gun, "lightng"]
+      ].freeze
+      INVENTORY_ITEMS = [
+        [:key, :silver, "sb_key1"],
+        [:key, :gold, "sb_key2"],
+        [:powerup, :ring, "sb_invis"],
+        [:powerup, :pentagram, "sb_invuln"],
+        [:powerup, :biosuit, "sb_suit"],
+        [:powerup, :quad, "sb_quad"]
+      ].freeze
+      INVENTORY_AMMO_TYPES = %i[shells nails rockets cells].freeze
+
+      def initialize(wad, palette, screen_width, screen_height, pak: nil)
         @wad = wad
         @palette = palette
+        @pak = pak
         @screen_width = screen_width
         @screen_height = screen_height
         @textures = {} # name -> { id:, width:, height: }
@@ -26,7 +46,7 @@ module Quake
         upload_hud_graphics
       end
 
-      def render(player_state)
+      def render(player_state, time: 0.0, stats: nil)
         setup_ortho
 
         GL.Enable(GL::TEXTURE_2D)
@@ -35,7 +55,7 @@ module Quake
         GL.Disable(GL::DEPTH_TEST)
         GL.Color4f(1.0, 1.0, 1.0, 1.0)
 
-        draw_sbar(player_state)
+        draw_hud(player_state, time: time, stats: stats)
 
         GL.Enable(GL::DEPTH_TEST)
         GL.Disable(GL::BLEND)
@@ -45,18 +65,58 @@ module Quake
 
       private
 
+      # During intermission Quake draws only Sbar_IntermissionOverlay --
+      # no status bar and no crosshair (screen.c SCR_UpdateScreen).
+      def draw_hud(player_state, time:, stats: nil)
+        if stats && stats[:intermission]
+          draw_intermission(stats)
+        else
+          draw_crosshair
+          if stats
+            draw_notify_lines(stats[:notify_lines])
+            draw_centerprint(stats[:centerprint])
+          end
+          # sb_lines from viewsize: 0 hides the bar, 24 shows the status
+          # bar only, more adds the inventory bar (screen.c/sbar.c)
+          sb_lines = stats ? stats.fetch(:sb_lines, 40) : 40
+          return if sb_lines <= 0
+
+          draw_sbar(player_state, time: time, stats: stats, inventory: sb_lines > 24)
+        end
+      end
+
       def setup_ortho
         GL.MatrixMode(GL::PROJECTION)
         GL.PushMatrix
         GL.LoadIdentity
-        # Y=0 at bottom, Y=200 at top (standard GL orientation)
-        GL.Ortho(0, VIRTUAL_WIDTH, 0, VIRTUAL_HEIGHT, -1, 1)
+        # Y=0 at bottom, Y=200 at top (standard GL orientation).
+        # Width is aspect-corrected so the HUD doesn't stretch on
+        # non-320x200-shaped windows.
+        GL.Ortho(0, virtual_width, 0, VIRTUAL_HEIGHT, -1, 1)
 
         GL.MatrixMode(GL::MODELVIEW)
         GL.PushMatrix
         GL.LoadIdentity
       end
 
+      # Virtual screen width matching the window aspect ratio at 200
+      # virtual pixels tall. Never narrower than the 320px status bar.
+      def virtual_width
+        @virtual_width ||=
+          if @screen_width && @screen_height.to_f.positive?
+            [(VIRTUAL_HEIGHT * @screen_width.to_f / @screen_height).round,
+             VIRTUAL_WIDTH].max
+          else
+            VIRTUAL_WIDTH
+          end
+      end
+
+      # Horizontal offset centering the 320-wide status bar, like Quake's
+      # (vid.width - 320) >> 1 in Sbar_DrawPic (sbar.c).
+      def sbar_x
+        @sbar_x ||= (virtual_width - VIRTUAL_WIDTH) / 2
+      end
+
       def restore_projection
         GL.MatrixMode(GL::MODELVIEW)
         GL.PopMatrix
@@ -84,39 +144,243 @@ module Quake
         GL.End
       end
 
-      def draw_sbar(ps)
+      def draw_sbar(ps, time: 0.0, stats: nil, inventory: true)
+        draw_inventory(ps, time: time) if inventory
+
         # Sbar sits at the very bottom of the screen
         sbar_y = 0
 
-        # Status bar background (320x24)
-        draw_pic(0, sbar_y, "sbar")
+        if ps.health <= 0
+          draw_pic(sbar_x, sbar_y, "scorebar")
+          draw_solo_scoreboard(stats) if stats
+          return
+        end
 
-        # Armor number (x=24, 3 digits)
-        draw_num(24, sbar_y, ps.armor, 3, ps.armor <= 25)
+        # Status bar background (320x24)
+        draw_pic(sbar_x, sbar_y, "sbar")
 
-        # Armor type icon (x=0)
-        if ps.armor > 0
-          armor_icon = case ps.armor_type
-                       when 1 then "sb_armor1"
-                       when 2 then "sb_armor2"
-                       else "sb_armor3"
-                       end
-          draw_pic(0, sbar_y, armor_icon) if @textures[armor_icon]
-        end
+        draw_armor(ps, sbar_y, time: time)
 
         # Face (x=112)
-        draw_pic(112, sbar_y, health_face(ps.health))
+        draw_pic(sbar_x + 112, sbar_y, health_face(ps, time: time))
 
         # Health (x=136, 3 digits)
-        draw_num(136, sbar_y, ps.health, 3, ps.health <= 25)
+        draw_num(sbar_x + 136, sbar_y, ps.health, 3, ps.health <= 25)
 
         # Ammo icon (x=224)
         ammo_icon = ammo_type_icon(ps.current_ammo_type)
-        draw_pic(224, sbar_y, ammo_icon) if ammo_icon && @textures[ammo_icon]
+        draw_pic(sbar_x + 224, sbar_y, ammo_icon) if ammo_icon && @textures[ammo_icon]
 
         # Ammo count (x=248, 3 digits)
         ammo = ps.current_ammo_count
-        draw_num(248, sbar_y, ammo, 3, ammo && ammo <= 10) if ammo
+        draw_num(sbar_x + 248, sbar_y, ammo, 3, ammo && ammo <= 10) if ammo
+      end
+
+      def draw_inventory(ps, time: 0.0)
+        draw_pic(sbar_x, SBAR_HEIGHT, "ibar")
+
+        WEAPON_ICONS.each_with_index do |(weapon, icon), index|
+          next unless ps.weapons_owned.include?(weapon)
+
+          variant = weapon_flash_variant(ps, weapon, index, time)
+          draw_pic(sbar_x + (index * 24), SBAR_HEIGHT, "#{variant}_#{icon}")
+        end
+
+        draw_inventory_ammo(ps)
+        draw_inventory_items(ps, time: time)
+        draw_sigils(ps)
+      end
+
+      def draw_armor(ps, y, time: 0.0)
+        if powerup_item_active?(ps, :pentagram, time)
+          draw_num(sbar_x + 24, y, 666, 3, true)
+          draw_pic(sbar_x, y, "disc")
+          return
+        end
+
+        draw_num(sbar_x + 24, y, ps.armor, 3, ps.armor <= 25)
+        return unless ps.armor > 0
+
+        armor_icon = case ps.armor_type
+                     when 1 then "sb_armor1"
+                     when 2 then "sb_armor2"
+                     else "sb_armor3"
+                     end
+        draw_pic(sbar_x, y, armor_icon) if @textures[armor_icon]
+      end
+
+      def weapon_flash_variant(ps, weapon, index, time)
+        gettime = ps.weapon_gettime[index].to_f
+        flashon = [((time.to_f - gettime) * 10.0).to_i, 0].max
+        return "inva#{(flashon % 5) + 1}" if flashon < 10
+
+        ps.current_weapon == weapon ? "inv2" : "inv"
+      end
+
+      def draw_inventory_ammo(ps)
+        INVENTORY_AMMO_TYPES.each_with_index do |ammo_type, index|
+          num = format("%3i", ps.ammo.fetch(ammo_type, 0))
+          3.times do |digit_index|
+            ch = num[digit_index]
+            next if ch == " "
+
+            # Sbar_DrawCharacter adds +4 to x (sbar.c)
+            x = sbar_x + (((6 * index) + digit_index + 1) * CHAR_SIZE) - 2 + 4
+            draw_character(x, SBAR_HEIGHT + 16, 18 + ch.ord - "0".ord)
+          end
+        end
+      end
+
+      def draw_inventory_items(ps, time: 0.0)
+        INVENTORY_ITEMS.each_with_index do |(type, item, icon), index|
+          next unless inventory_item_active?(ps, type, item, time)
+
+          draw_pic(sbar_x + 192 + (index * 16), SBAR_HEIGHT, icon)
+        end
+      end
+
+      def inventory_item_active?(ps, type, item, time)
+        case type
+        when :key
+          ps.keys_owned.include?(item)
+        when :powerup
+          powerup_item_active?(ps, item, time)
+        else
+          false
+        end
+      end
+
+      def draw_sigils(ps)
+        4.times do |index|
+          next if (ps.serverflags & (1 << index)).zero?
+
+          draw_pic(sbar_x + 288 + (index * 8), SBAR_HEIGHT, "sb_sigil#{index + 1}")
+        end
+      end
+
+      # Sbar_SoloScoreboard (sbar.c:491): monster/secret counts, level
+      # time and level name drawn over the scorebar when the player is
+      # dead. C y offsets are from the top of the 24px sbar (top-down);
+      # in this file's bottom-up ortho a char at C offset y sits at
+      # GL y = SBAR_HEIGHT - y - CHAR_SIZE = 16 - y.
+      def draw_solo_scoreboard(stats)
+        draw_string(sbar_x + 8, 12,
+                    format("Monsters:%3i /%3i",
+                           stats[:monsters].to_i, stats[:total_monsters].to_i))
+        draw_string(sbar_x + 8, 4,
+                    format("Secrets :%3i /%3i",
+                           stats[:secrets].to_i, stats[:total_secrets].to_i))
+
+        total = stats[:time].to_f.to_i
+        minutes = total / 60
+        seconds = total - (60 * minutes)
+        draw_string(sbar_x + 184, 12,
+                    format("Time :%3i:%i%i", minutes, seconds / 10, seconds % 10))
+
+        level_name = stats[:level_name].to_s
+        draw_string(sbar_x + 232 - (level_name.length * 4), 4, level_name)
+      end
+
+      # Sbar_IntermissionOverlay (sbar.c:1193). C coords are top-down in
+      # the 320x200 virtual screen; converted here with
+      # GL y = VIRTUAL_HEIGHT - y - pic_height (big digits are 24 tall).
+      def draw_intermission(stats)
+        ensure_intermission_pics
+
+        draw_pic_top(sbar_x + 64, 24, "complete")
+        draw_pic_top(sbar_x, 56, "inter")
+
+        # time
+        time_y = VIRTUAL_HEIGHT - 64 - DIGIT_WIDTH
+        completed = stats[:completed_time].to_f.to_i
+        minutes = completed / 60
+        seconds = completed - (60 * minutes)
+        draw_num(sbar_x + 160, time_y, minutes, 3)
+        draw_pic(sbar_x + 234, time_y, "num_colon")
+        draw_pic(sbar_x + 246, time_y, "num_#{seconds / 10}")
+        draw_pic(sbar_x + 266, time_y, "num_#{seconds % 10}")
+
+        secrets_y = VIRTUAL_HEIGHT - 104 - DIGIT_WIDTH
+        draw_num(sbar_x + 160, secrets_y, stats[:secrets].to_i, 3)
+        draw_pic(sbar_x + 232, secrets_y, "num_slash")
+        draw_num(sbar_x + 240, secrets_y, stats[:total_secrets].to_i, 3)
+
+        monsters_y = VIRTUAL_HEIGHT - 144 - DIGIT_WIDTH
+        draw_num(sbar_x + 160, monsters_y, stats[:monsters].to_i, 3)
+        draw_pic(sbar_x + 232, monsters_y, "num_slash")
+        draw_num(sbar_x + 240, monsters_y, stats[:total_monsters].to_i, 3)
+      end
+
+      # Draw a pic whose y is given top-down (like Quake's Draw_Pic).
+      def draw_pic_top(x, y, name)
+        tex = @textures[name]
+        return unless tex
+
+        draw_pic(x, VIRTUAL_HEIGHT - y - tex[:height], name)
+      end
+
+      # Console notify lines (sprint messages) like Con_DrawNotify
+      # (console.c): up to four lines at the top left, x = 8, stacked
+      # 8px apart from the top of the screen.
+      def draw_notify_lines(lines)
+        Array(lines).each_with_index do |line, index|
+          draw_string(8, VIRTUAL_HEIGHT - ((index + 1) * CHAR_SIZE), line)
+        end
+      end
+
+      # Centerprint text like SCR_DrawCenterString (screen.c): each line
+      # centered horizontally, the block starting 35% down the screen
+      # (or at fixed C y = 48 for messages taller than four lines).
+      def draw_centerprint(text)
+        text = text.to_s
+        return if text.empty?
+
+        lines = text.split("\n")
+        y = if lines.length <= 4
+              VIRTUAL_HEIGHT - (VIRTUAL_HEIGHT * 0.35).to_i
+            else
+              VIRTUAL_HEIGHT - 48
+            end
+        lines.each do |line|
+          draw_string((virtual_width - (line.length * CHAR_SIZE)) / 2, y, line)
+          y -= CHAR_SIZE
+        end
+      end
+
+      # Draw the '+' crosshair glyph at the center of the view, like
+      # Draw_Character(scr_vrect center, '+') in screen.c.
+      def draw_crosshair
+        draw_character((virtual_width / 2) - 4, (VIRTUAL_HEIGHT / 2) - 4, "+".ord)
+      end
+
+      def draw_character(x, y, num)
+        return if num == 32
+
+        tex = @textures["conchars"]
+        return unless tex
+
+        num &= 255
+        row = num >> 4
+        col = num & 15
+        step = 1.0 / 16.0
+        s = col * step
+        t = row * step
+
+        GL.BindTexture(GL::TEXTURE_2D, tex[:id])
+        GL.Begin(GL::QUADS)
+        GL.TexCoord2f(s, t); GL.Vertex2f(x, y + CHAR_SIZE)
+        GL.TexCoord2f(s + step, t); GL.Vertex2f(x + CHAR_SIZE, y + CHAR_SIZE)
+        GL.TexCoord2f(s + step, t + step); GL.Vertex2f(x + CHAR_SIZE, y)
+        GL.TexCoord2f(s, t + step); GL.Vertex2f(x, y)
+        GL.End
+      end
+
+      # Draw a string of console characters left-to-right, like
+      # Draw_String (each char CHAR_SIZE apart).
+      def draw_string(x, y, str)
+        str.to_s.each_char.with_index do |ch, i|
+          draw_character(x + (i * CHAR_SIZE), y, ch.ord)
+        end
       end
 
       # Draw a right-justified number using big digit graphics.
@@ -141,22 +405,36 @@ module Quake
         ptr = str.length > digits ? str[str.length - digits..] : str
 
         ptr.each_char do |ch|
+          prefix = red ? "anum_" : "num_"
           if ch == "-"
-            draw_pic(x, y, "num_minus")
+            draw_pic(x, y, "#{prefix}minus")
           else
-            prefix = red ? "anum_" : "num_"
             draw_pic(x, y, "#{prefix}#{ch}")
           end
           x += DIGIT_WIDTH
         end
       end
 
-      def health_face(health)
+      def health_face(player_state, time: 0.0)
+        if powerup_item_active?(player_state, :ring, time) &&
+           powerup_item_active?(player_state, :pentagram, time)
+          return "face_inv2"
+        end
+        return "face_quad" if powerup_item_active?(player_state, :quad, time)
+        return "face_invis" if powerup_item_active?(player_state, :ring, time)
+        return "face_invul2" if powerup_item_active?(player_state, :pentagram, time)
+
+        health = player_state.health
         # Quake face mapping: face1 = best (health 100+), face5 = worst (near death)
         # sb_faces[4] = face1, sb_faces[0] = face5
         # f = health >= 100 ? 4 : health / 20
         f = health >= 100 ? 4 : [health / 20, 0].max
-        "face#{5 - f}"
+        prefix = time.to_f <= player_state.face_anim_time.to_f ? "face_p" : "face"
+        "#{prefix}#{5 - f}"
+      end
+
+      def powerup_item_active?(player_state, powerup, time)
+        player_state.powerup_item_active?(powerup, game_time: time)
       end
 
       def ammo_type_icon(ammo_type)
@@ -169,8 +447,12 @@ module Quake
       end
 
       def upload_hud_graphics
+        upload_charset
+
         # Status bar background
         upload_wad_pic("sbar")
+        upload_wad_pic("ibar")
+        upload_wad_pic("scorebar")
 
         # Big numbers (0-9) and alternate (red) numbers
         10.times do |i|
@@ -178,14 +460,20 @@ module Quake
           upload_wad_pic("anum_#{i}")
         end
         upload_wad_pic("num_minus")
+        upload_wad_pic("anum_minus")
         upload_wad_pic("num_colon")
         upload_wad_pic("num_slash")
 
         # Face graphics
         (1..5).each { |i| upload_wad_pic("face#{i}") }
         (1..5).each { |i| upload_wad_pic("face_p#{i}") }
+        upload_wad_pic("face_invis")
+        upload_wad_pic("face_invul2")
+        upload_wad_pic("face_inv2")
+        upload_wad_pic("face_quad")
 
         # Armor icons
+        upload_wad_pic("disc")
         upload_wad_pic("sb_armor1")
         upload_wad_pic("sb_armor2")
         upload_wad_pic("sb_armor3")
@@ -196,6 +484,15 @@ module Quake
         upload_wad_pic("sb_rocket")
         upload_wad_pic("sb_cells")
 
+        WEAPON_ICONS.each do |_weapon, icon|
+          upload_wad_pic("inv_#{icon}")
+          upload_wad_pic("inv2_#{icon}")
+          (1..5).each { |i| upload_wad_pic("inva#{i}_#{icon}") }
+        end
+
+        INVENTORY_ITEMS.each { |_type, _item, icon| upload_wad_pic(icon) }
+        (1..4).each { |i| upload_wad_pic("sb_sigil#{i}") }
+
         count = @textures.size
         puts "Loaded #{count} HUD graphics from WAD"
       end
@@ -204,7 +501,63 @@ module Quake
         qpic = @wad.read_qpic(name)
         return unless qpic
 
-        rgba = @palette.indexed_to_rgba(qpic.pixels)
+        upload_texture(name, qpic.width, qpic.height, qpic.pixels)
+      end
+
+      # gfx/complete.lmp and gfx/inter.lmp are standalone qpic pak
+      # entries (not in gfx.wad), loaded on first intermission and
+      # skipped tolerantly if the pak lacks them.
+      def ensure_intermission_pics
+        return if @intermission_pics_loaded
+
+        @intermission_pics_loaded = true
+        upload_pak_lmp("complete", "gfx/complete.lmp")
+        upload_pak_lmp("inter", "gfx/inter.lmp")
+      end
+
+      # Standalone qpic lump: int32 width, int32 height, then
+      # width*height palette-indexed bytes.
+      def upload_pak_lmp(name, path)
+        return unless @pak
+
+        data = @pak.read(path)
+        return unless data && data.bytesize > 8
+
+        width, height = data[0, 8].unpack("VV")
+        return unless width.positive? && height.positive?
+        return if data.bytesize < 8 + (width * height)
+
+        upload_texture(name, width, height, data[8, width * height])
+      end
+
+      def upload_texture(name, width, height, pixels, transparent_index: 255)
+        rgba = @palette.indexed_to_rgba(pixels, transparent_index: transparent_index)
+
+        buf = "\0" * 4
+        GL.GenTextures(1, buf)
+        tex_id = buf.unpack1("V")
+
+        GL.BindTexture(GL::TEXTURE_2D, tex_id)
+        GL.TexImage2D(GL::TEXTURE_2D, 0, GL::RGBA,
+                      width, height, 0,
+                      GL::RGBA, GL::UNSIGNED_BYTE, rgba)
+        # Quake filters sbar pics with gl_filter_max (GL_LINEAR); only the
+        # charset uses GL_NEAREST (gl_draw.c)
+        GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_MIN_FILTER, GL::LINEAR)
+        GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_MAG_FILTER, GL::LINEAR)
+        GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_WRAP_S, GL::CLAMP_TO_EDGE)
+        GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_WRAP_T, GL::CLAMP_TO_EDGE)
+
+        @textures[name] = { id: tex_id, width: width, height: height }
+      end
+
+      def upload_charset
+        return unless @wad.list.include?("conchars")
+
+        # Quake makes only palette index 0 transparent in the charset
+        # (GL_LoadTexture_Alpha with alpha=0 in gl_draw.c)
+        pixels = @wad.read("conchars")
+        rgba = @palette.indexed_to_rgba(pixels, transparent_index: 0)
 
         buf = "\0" * 4
         GL.GenTextures(1, buf)
@@ -212,14 +565,14 @@ module Quake
 
         GL.BindTexture(GL::TEXTURE_2D, tex_id)
         GL.TexImage2D(GL::TEXTURE_2D, 0, GL::RGBA,
-                      qpic.width, qpic.height, 0,
+                      128, 128, 0,
                       GL::RGBA, GL::UNSIGNED_BYTE, rgba)
         GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_MIN_FILTER, GL::NEAREST)
         GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_MAG_FILTER, GL::NEAREST)
         GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_WRAP_S, GL::CLAMP_TO_EDGE)
         GL.TexParameteri(GL::TEXTURE_2D, GL::TEXTURE_WRAP_T, GL::CLAMP_TO_EDGE)
 
-        @textures[name] = { id: tex_id, width: qpic.width, height: qpic.height }
+        @textures["conchars"] = { id: tex_id, width: 128, height: 128 }
       end
     end
   end