doom 0.3.0 → 0.4.0

data/lib/doom/render/renderer.rb

@@ -18,7 +18,12 @@ module Doom
     # Matches Chocolate Doom's drawseg_t structure
     Drawseg = Struct.new(:x1, :x2, :scale1, :scale2,
                          :silhouette, :bsilheight, :tsilheight,
-                         :sprtopclip, :sprbottomclip)
+                         :sprtopclip, :sprbottomclip,
+                         :curline)  # seg for point-on-side test
+
+    # VisibleSprite stores sprite data for sorting and rendering
+    # Struct is faster than Hash for fixed-field data
+    VisibleSprite = Struct.new(:thing, :sprite, :view_x, :view_y, :dist, :screen_x)
 
     # Visplane stores floor/ceiling rendering info for a sector
     # Matches Chocolate Doom's visplane_t structure from r_plane.c
@@ -67,6 +72,17 @@ module Doom
         # Projection constant - distance to projection plane
         @projection = HALF_WIDTH / Math.tan(FOV * Math::PI / 360.0)
 
+        # Precomputed column data (cached based on player angle)
+        @column_cos = Array.new(SCREEN_WIDTH)
+        @column_sin = Array.new(SCREEN_WIDTH)
+        @cached_player_angle = nil
+
+        # Column distance scale is constant (doesn't depend on player angle)
+        @column_distscale = Array.new(SCREEN_WIDTH) do |x|
+          dx = x - HALF_WIDTH
+          Math.sqrt(dx * dx + @projection * @projection) / @projection
+        end
+
         # Clipping arrays
         @ceiling_clip = Array.new(SCREEN_WIDTH, -1)
         @floor_clip = Array.new(SCREEN_WIDTH, SCREEN_HEIGHT)
@@ -77,6 +93,11 @@ module Doom
 
         # Wall depth array - tracks distance to nearest wall at each column
         @wall_depth = Array.new(SCREEN_WIDTH, Float::INFINITY)
+        @sprite_wall_depth = Array.new(SCREEN_WIDTH, Float::INFINITY)
+
+        # Preallocated y_slope arrays for floor/ceiling rendering (avoids per-frame allocation)
+        @y_slope_ceil = Array.new(HALF_HEIGHT + 1, 0.0)
+        @y_slope_floor = Array.new(HALF_HEIGHT + 1, 0.0)
       end
 
       attr_reader :player_x, :player_y, :player_z, :sin_angle, :cos_angle
@@ -116,6 +137,7 @@ module Doom
 
         # Initialize visplanes for tracking visible floor/ceiling spans
         @visplanes = []
+        @visplane_hash = {}  # Hash for O(1) lookup by (height, texture, light_level, is_ceiling)
 
         # Initialize drawsegs for sprite clipping
         @drawsegs = []
@@ -126,27 +148,26 @@ module Doom
         # Draw visplanes for sectors different from background
         draw_all_visplanes
 
-        # Save wall clip arrays for sprite clipping
-        @sprite_ceiling_clip = @ceiling_clip.dup
-        @sprite_floor_clip = @floor_clip.dup
-        @sprite_wall_depth = @wall_depth.dup
+        # Save wall clip arrays for sprite clipping (reuse preallocated arrays)
+        @sprite_ceiling_clip.replace(@ceiling_clip)
+        @sprite_floor_clip.replace(@floor_clip)
+        @sprite_wall_depth.replace(@wall_depth)
 
         # Render sprites
         render_sprites if @sprites
       end
 
       # Precompute column-based data for floor/ceiling rendering (R_InitLightTables-like)
+      # Cached: only recomputes sin/cos when player angle changes
       def precompute_column_data
-        @column_cos ||= Array.new(SCREEN_WIDTH)
-        @column_sin ||= Array.new(SCREEN_WIDTH)
-        @column_distscale ||= Array.new(SCREEN_WIDTH)
+        return if @cached_player_angle == @player_angle
+
+        @cached_player_angle = @player_angle
 
         SCREEN_WIDTH.times do |x|
-          dx = x - HALF_WIDTH
-          column_angle = @player_angle - Math.atan2(dx, @projection)
+          column_angle = @player_angle - Math.atan2(x - HALF_WIDTH, @projection)
           @column_cos[x] = Math.cos(column_angle)
           @column_sin[x] = Math.sin(column_angle)
-          @column_distscale[x] = Math.sqrt(dx * dx + @projection * @projection) / @projection
         end
       end
 
@@ -260,7 +281,7 @@ module Doom
           ray_dist = perp_dist * column_distscale[x]
           tex_x = (player_x + ray_dist * column_cos[x]).to_i & 63
           tex_y = (neg_player_y - ray_dist * column_sin[x]).to_i & 63
-          color = flat[tex_x, tex_y] || 0
+          color = flat[tex_x, tex_y]
           framebuffer[row_offset + x] = cmap[color]
           x += 1
         end
@@ -274,8 +295,8 @@ module Doom
         framebuffer = @framebuffer
         player_angle = @player_angle
         projection = @projection
-        sky_width = sky_texture.width
-        sky_height = sky_texture.height
+        sky_width_mask = sky_texture.width - 1    # Power-of-2 textures: & is faster than %
+        sky_height_mask = sky_texture.height - 1
 
         # Clamp to screen bounds
         minx = [plane.minx, 0].max
@@ -292,29 +313,26 @@ module Doom
 
           # Sky X based on view angle (wraps around 256 degrees)
           column_angle = player_angle - Math.atan2(x - HALF_WIDTH, projection)
-          sky_x = ((column_angle * 256 / Math::PI).to_i & 255) % sky_width
+          sky_x = (column_angle * 256 / Math::PI).to_i & sky_width_mask
           column = sky_texture.column_pixels(sky_x)
           next unless column
 
           (y1..y2).each do |y|
-            color = column[y % sky_height] || 0
+            color = column[y & sky_height_mask]
             framebuffer[y * SCREEN_WIDTH + x] = color
           end
         end
       end
 
       def find_or_create_visplane(sector, height, texture, light_level, is_ceiling)
-        # Find existing visplane with matching properties
-        plane = @visplanes.find do |vp|
-          vp.height == height &&
-          vp.texture == texture &&
-          vp.light_level == light_level &&
-          vp.is_ceiling == is_ceiling
-        end
+        # O(1) hash lookup instead of O(n) linear search
+        key = [height, texture, light_level, is_ceiling]
+        plane = @visplane_hash[key]
 
         unless plane
           plane = Visplane.new(sector, height, texture, light_level, is_ceiling)
           @visplanes << plane
+          @visplane_hash[key] = plane
         end
 
         plane
@@ -371,6 +389,11 @@ module Doom
         new_plane.minx = start_x
         new_plane.maxx = stop_x
         @visplanes << new_plane
+
+        # Update hash to point to the new plane (for subsequent lookups)
+        key = [plane.height, plane.texture, plane.light_level, plane.is_ceiling]
+        @visplane_hash[key] = new_plane
+
         new_plane
       end
 
@@ -394,9 +417,9 @@ module Doom
         light_level = default_sector.light_level
         colormap_maps = @colormap.maps
 
-        # Precompute y_slope for each row (perpendicular distance)
-        y_slope_ceil = Array.new(HALF_HEIGHT + 1, 0.0)
-        y_slope_floor = Array.new(HALF_HEIGHT + 1, 0.0)
+        # Compute y_slope for each row (perpendicular distance) - reuse preallocated arrays
+        y_slope_ceil = @y_slope_ceil
+        y_slope_floor = @y_slope_floor
         (1..HALF_HEIGHT).each do |dy|
           y_slope_ceil[dy] = ceil_height * projection / dy.to_f
           y_slope_floor[dy] = floor_height * projection / dy.to_f
@@ -414,14 +437,14 @@ module Doom
               row_offset = y * SCREEN_WIDTH
 
               if is_sky && sky_texture
-                sky_height = sky_texture.height
-                sky_width = sky_texture.width
-                sky_y = y % sky_height
+                sky_height_mask = sky_texture.height - 1
+                sky_width_mask = sky_texture.width - 1
+                sky_y = y & sky_height_mask
                 x = 0
                 while x < SCREEN_WIDTH
                   column_angle = player_angle - Math.atan2(x - HALF_WIDTH, projection)
-                  sky_x = ((column_angle * 256 / Math::PI).to_i & 255) % sky_width
-                  color = sky_texture.column_pixels(sky_x)[sky_y] || 0
+                  sky_x = (column_angle * 256 / Math::PI).to_i & sky_width_mask
+                  color = sky_texture.column_pixels(sky_x)[sky_y]
                   framebuffer[row_offset + x] = color
                   x += 1
                 end
@@ -431,7 +454,7 @@ module Doom
                   ray_dist = perp_dist * column_distscale[x]
                   tex_x = (player_x + ray_dist * column_cos[x]).to_i & 63
                   tex_y = (neg_player_y - ray_dist * column_sin[x]).to_i & 63
-                  color = ceil_flat[tex_x, tex_y] || 0
+                  color = ceil_flat[tex_x, tex_y]
                   framebuffer[row_offset + x] = cmap[color]
                   x += 1
                 end
@@ -458,7 +481,7 @@ module Doom
                   ray_dist = perp_dist * column_distscale[x]
                   tex_x = (player_x + ray_dist * column_cos[x]).to_i & 63
                   tex_y = (neg_player_y - ray_dist * column_sin[x]).to_i & 63
-                  color = floor_flat[tex_x, tex_y] || 0
+                  color = floor_flat[tex_x, tex_y]
                   framebuffer[row_offset + x] = cmap[color]
                   x += 1
                 end
@@ -641,6 +664,35 @@ module Doom
         [x, y]
       end
 
+      # Determine which side of a seg a point is on (R_PointOnSegSide from Chocolate Doom)
+      # Returns true if point is on back side, false if on front side
+      def point_on_seg_side(x, y, seg)
+        v1 = @map.vertices[seg.v1]
+        v2 = @map.vertices[seg.v2]
+
+        lx = v1.x
+        ly = v1.y
+        ldx = v2.x - lx
+        ldy = v2.y - ly
+
+        # Handle axis-aligned lines
+        if ldx == 0
+          return x <= lx ? ldy > 0 : ldy < 0
+        end
+        if ldy == 0
+          return y <= ly ? ldx < 0 : ldx > 0
+        end
+
+        dx = x - lx
+        dy = y - ly
+
+        # Cross product to determine side
+        left = ldy * dx
+        right = dy * ldx
+
+        right >= left
+      end
+
       def draw_seg_range(x1, x2, sx1, sx2, dist1, dist2, sector, back_sector, sidedef, linedef, seg, seg_length)
         # Get seg vertices in world space for texture coordinate calculation
         seg_v1 = @map.vertices[seg.v1]
@@ -748,6 +800,12 @@ module Doom
             high_ceil = [ceil_y, back_ceil_y].max
             low_floor = [floor_y, back_floor_y].min
 
+            # Check for closed door (no opening between sectors)
+            # Matches Chocolate Doom: backsector->ceilingheight <= frontsector->floorheight
+            #                      || backsector->floorheight >= frontsector->ceilingheight
+            closed_door = back_sector.ceiling_height <= sector.floor_height ||
+                          back_sector.floor_height >= sector.ceiling_height
+
             # Mark ceiling visplane - mark front sector's ceiling for two-sided lines
             # Matches Chocolate Doom: mark from ceilingclip+1 to yl-1 (front ceiling)
             # (yl is clamped to ceilingclip+1, so we use ceil_y which is already clamped)
@@ -811,30 +869,37 @@ module Doom
             end
 
             # Update clip bounds after marking
-            # Ceiling clip increases (moves down) as ceiling is marked
-            if sector.ceiling_height > back_sector.ceiling_height
-              # Upper wall drawn - clip ceiling to back ceiling
-              @ceiling_clip[x] = [back_ceil_y, @ceiling_clip[x]].max
-            elsif sector.ceiling_height < back_sector.ceiling_height
-              # Ceiling step up - clip to front ceiling
-              @ceiling_clip[x] = [ceil_y, @ceiling_clip[x]].max
-            elsif should_mark_ceiling
-              # Same height but different texture/light - still update clip
-              # Matches Chocolate Doom: if (markceiling) ceilingclip[rw_x] = yl-1;
-              @ceiling_clip[x] = [ceil_y - 1, @ceiling_clip[x]].max
-            end
+            if closed_door
+              # Closed door - fully occlude this column
+              @wall_depth[x] = [@wall_depth[x], dist].min
+              @ceiling_clip[x] = SCREEN_HEIGHT
+              @floor_clip[x] = -1
+            else
+              # Ceiling clip increases (moves down) as ceiling is marked
+              if sector.ceiling_height > back_sector.ceiling_height
+                # Upper wall drawn - clip ceiling to back ceiling
+                @ceiling_clip[x] = [back_ceil_y, @ceiling_clip[x]].max
+              elsif sector.ceiling_height < back_sector.ceiling_height
+                # Ceiling step up - clip to front ceiling
+                @ceiling_clip[x] = [ceil_y, @ceiling_clip[x]].max
+              elsif should_mark_ceiling
+                # Same height but different texture/light - still update clip
+                # Matches Chocolate Doom: if (markceiling) ceilingclip[rw_x] = yl-1;
+                @ceiling_clip[x] = [ceil_y - 1, @ceiling_clip[x]].max
+              end
 
-            # Floor clip decreases (moves up) as floor is marked
-            if sector.floor_height < back_sector.floor_height
-              # Lower wall drawn - clip floor to back floor
-              @floor_clip[x] = [back_floor_y, @floor_clip[x]].min
-            elsif sector.floor_height > back_sector.floor_height
-              # Floor step down - clip to front floor to allow back sector to mark later
-              @floor_clip[x] = [floor_y, @floor_clip[x]].min
-            elsif should_mark_floor
-              # Same height but different texture/light - still update clip
-              # Matches Chocolate Doom: if (markfloor) floorclip[rw_x] = yh+1;
-              @floor_clip[x] = [floor_y + 1, @floor_clip[x]].min
+              # Floor clip decreases (moves up) as floor is marked
+              if sector.floor_height < back_sector.floor_height
+                # Lower wall drawn - clip floor to back floor
+                @floor_clip[x] = [back_floor_y, @floor_clip[x]].min
+              elsif sector.floor_height > back_sector.floor_height
+                # Floor step down - clip to front floor to allow back sector to mark later
+                @floor_clip[x] = [floor_y, @floor_clip[x]].min
+              elsif should_mark_floor
+                # Same height but different texture/light - still update clip
+                # Matches Chocolate Doom: if (markfloor) floorclip[rw_x] = yh+1;
+                @floor_clip[x] = [floor_y + 1, @floor_clip[x]].min
+              end
             end
           else
             # One-sided (solid) wall
@@ -883,7 +948,8 @@ module Doom
             scale1, scale2,
             silhouette,
             bsilheight, tsilheight,
-            sprtopclip, sprbottomclip
+            sprtopclip, sprbottomclip,
+            seg
           )
           @drawsegs << drawseg
         end
@@ -911,12 +977,11 @@ module Doom
         light = calculate_light(light_level, dist)
         cmap = @colormap.maps[light]
         framebuffer = @framebuffer
-        tex_width = texture.width
-        tex_height = texture.height
+        tex_width_mask = texture.width - 1   # For power-of-2 textures: & mask is faster than %
+        tex_height_mask = texture.height - 1
 
-        # Texture X coordinate (wrap around texture width)
-        tex_x = tex_col.to_i % tex_width
-        tex_x += tex_width if tex_x < 0
+        # Texture X coordinate (wrap around texture width using bitwise AND)
+        tex_x = tex_col.to_i & tex_width_mask
 
         # Get the column of pixels
         column = texture.column_pixels(tex_x)
@@ -939,10 +1004,9 @@ module Doom
         y = y1
         while y <= y2
           screen_offset = y - y1
-          tex_y = (tex_y_at_y1 + screen_offset * tex_step).to_i % tex_height
-          tex_y += tex_height if tex_y < 0
+          tex_y = (tex_y_at_y1 + screen_offset * tex_step).to_i & tex_height_mask
 
-          color = column[tex_y] || 0
+          color = column[tex_y]
           framebuffer[y * SCREEN_WIDTH + x] = cmap[color]
           y += 1
         end
@@ -1047,18 +1111,11 @@ module Doom
           next if screen_x + sprite_half_width < 0
           next if screen_x - sprite_half_width >= SCREEN_WIDTH
 
-          visible_sprites << {
-            thing: thing,
-            sprite: sprite,
-            view_x: view_x,
-            view_y: view_y,
-            dist: dist,
-            screen_x: screen_x
-          }
+          visible_sprites << VisibleSprite.new(thing, sprite, view_x, view_y, dist, screen_x)
         end
 
         # Sort by distance (back to front for proper overdraw)
-        visible_sprites.sort_by! { |s| -s[:dist] }
+        visible_sprites.sort_by! { |s| -s.dist }
 
         # Draw each sprite
         visible_sprites.each do |vs|
@@ -1067,10 +1124,10 @@ module Doom
       end
 
       def draw_sprite(vs)
-        sprite = vs[:sprite]
-        dist = vs[:dist]
-        screen_x = vs[:screen_x]
-        thing = vs[:thing]
+        sprite = vs.sprite
+        dist = vs.dist
+        screen_x = vs.screen_x
+        thing = vs.thing
 
         # Calculate scale (inverse of distance, used for depth comparison)
         sprite_scale = @projection / dist
@@ -1120,12 +1177,14 @@ module Doom
           lowscale = [ds.scale1, ds.scale2].min
           highscale = [ds.scale1, ds.scale2].max
 
-          # If drawseg is behind sprite, skip (seg must be closer to clip)
+          # Chocolate Doom logic: skip if seg is behind sprite
+          # If highscale < sprite_scale: wall entirely behind sprite
+          # OR if lowscale < sprite_scale AND sprite is on front side of wall
           if highscale < sprite_scale
             next
           elsif lowscale < sprite_scale
-            # Seg partially overlaps in depth - would need point-on-seg test
-            # For simplicity, we'll clip if any part of seg is closer
+            # Partial overlap - check if sprite is in front of the seg
+            next unless point_on_seg_side(thing.x, thing.y, ds.curline)
           end
 
           # Determine which silhouettes apply based on sprite Z
@@ -1208,11 +1267,6 @@ module Doom
           end
         end
       end
-
-      def set_pixel(x, y, color)
-        return if x < 0 || x >= SCREEN_WIDTH || y < 0 || y >= SCREEN_HEIGHT
-        @framebuffer[y * SCREEN_WIDTH + x] = color
-      end
     end
   end
 end

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