doom 0.6.0 → 0.11.0

data/lib/doom/render/renderer.rb

@@ -16,10 +16,14 @@ module Doom
 
     # Drawseg stores wall segment info for sprite clipping
     # Matches Chocolate Doom's drawseg_t structure
-    Drawseg = Struct.new(:x1, :x2, :scale1, :scale2,
+    Drawseg = Struct.new(:x1, :x2, :scale1, :scale2, :scalestep,
                          :silhouette, :bsilheight, :tsilheight,
                          :sprtopclip, :sprbottomclip,
-                         :curline)  # seg for point-on-side test
+                         :curline, # seg for point-on-side test
+                         :maskedtexturecol, # per-column texture X for masked mid textures
+                         :frontsector, :backsector, # sectors for masked rendering
+                         :sidedef, # sidedef for texture lookup
+                         :dist1, :dist2, :sx1, :sx2) # for per-column distance recomputation
 
     # VisibleSprite stores sprite data for sorting and rendering
     # Struct is faster than Hash for fixed-field data
@@ -39,6 +43,7 @@ module Doom
 
       def mark(x, y1, y2)
         return if y1 > y2
+
         top[x] = [top[x], y1].min
         bottom[x] = [bottom[x], y2].max
         self.minx = [minx, x].min
@@ -51,21 +56,33 @@ module Doom
     end
 
     class Renderer
-      attr_reader :framebuffer
-
       def initialize(wad, map, textures, palette, colormap, flats, sprites = nil, animations = nil)
         @wad = wad
         @map = map
         @textures = textures
         @palette = palette
         @colormap = colormap
+        @flats_array = flats
         @flats = flats.to_h { |f| [f.name, f] }
+        # Opt-in: route the wall/floor/ceiling rasterisation through the
+        # spinel_native-compiled port of this renderer's hot path. Everything
+        # else (sprites, weapon, HUD, physics, sound) stays the real game.
+        @native_kernel = !ENV["DOOM_NATIVE"].to_s.empty? && ENV["DOOM_NATIVE"] != "0"
+        if @native_kernel
+          warn "[doom] compiling spinel_native render kernel (first run may take a few seconds)..."
+          @sn = build_native_renderer
+          @native_kernel = !@sn.nil?
+          warn "[doom] spinel_native renderer ready" if @sn
+        end
         @sprites = sprites
         @animations = animations
         @hidden_things = nil
         @combat = nil
         @monster_ai = nil
+        @players = []       # Every player in the world, for drawing the others
+        @view_player = nil  # The one we are looking through, never drawn
         @leveltime = 0
+        @skip_background_fill = false
 
         @framebuffer = Array.new(SCREEN_WIDTH * SCREEN_HEIGHT, 0)
 
@@ -73,6 +90,8 @@ module Doom
         @player_y = 0.0
         @player_z = 41.0
         @player_angle = 0.0
+        @sin_angle = 0.0
+        @cos_angle = 1.0
 
         # Projection constant - distance to projection plane
         @projection = HALF_WIDTH / Math.tan(FOV * Math::PI / 360.0)
@@ -85,13 +104,17 @@ module Doom
         # 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
+          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)
 
+        # Per-sprite clip buffers, reset (not reallocated) for each draw_sprite call
+        @sprite_clipbot = Array.new(SCREEN_WIDTH, -2)
+        @sprite_cliptop = Array.new(SCREEN_WIDTH, -2)
+
         # Sprite clip arrays (copy of wall clips for sprite clipping)
         @sprite_ceiling_clip = Array.new(SCREEN_WIDTH, -1)
         @sprite_floor_clip = Array.new(SCREEN_WIDTH, SCREEN_HEIGHT)
@@ -104,9 +127,10 @@ module Doom
         @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, :framebuffer
+      attr_reader :framebuffer, :player_x, :player_y, :player_z, :player_angle, :sin_angle, :cos_angle, :wad, :map,
+                  :textures, :palette, :colormap, :flats, :sprites, :animations
       attr_writer :hidden_things, :combat, :monster_ai, :leveltime
+      attr_accessor :players, :view_player, :skip_background_fill
 
       # Diagnostic: returns info about all sprites and why they are/aren't visible
       def sprite_diagnostics
@@ -124,7 +148,7 @@ module Doom
           info[:view_y] = view_y.round(1)
 
           if view_y <= 0
-            info[:status] = "behind_player"
+            info[:status] = 'behind_player'
             results << info
             next
           end
@@ -139,7 +163,7 @@ module Doom
           angle_to_thing = Math.atan2(dy, dx)
           sprite = @sprites.get_rotated(thing.type, angle_to_thing, thing.angle)
           unless sprite
-            info[:status] = "no_sprite_frame"
+            info[:status] = 'no_sprite_frame'
             results << info
             next
           end
@@ -149,20 +173,19 @@ module Doom
           info[:sprite_scale] = sprite_scale.round(3)
 
           if screen_x + sprite_half_width < 0
-            info[:status] = "off_screen_left"
+            info[:status] = 'off_screen_left'
           elsif screen_x - sprite_half_width >= SCREEN_WIDTH
-            info[:status] = "off_screen_right"
+            info[:status] = 'off_screen_right'
           else
             # Check drawseg clipping
-            sprite_left = (screen_x - sprite.left_offset * sprite_scale).to_i
+            sprite_left = (screen_x - (sprite.left_offset * sprite_scale)).to_i
             sprite_right = sprite_left + (sprite.width * sprite_scale).to_i - 1
             x1 = [sprite_left, 0].max
             x2 = [sprite_right, SCREEN_WIDTH - 1].min
 
             sector = @map.sector_at(thing.x, thing.y)
             thing_floor = sector ? sector.floor_height : 0
-            sprite_gz = thing_floor
-            sprite_gzt = thing_floor + sprite.top_offset
+            thing_floor + sprite.top_offset
 
             clipping_segs = []
             @drawsegs.reverse_each do |ds|
@@ -188,7 +211,7 @@ module Doom
             info[:screen_range] = "#{x1}..#{x2}"
             info[:clipping_segs] = clipping_segs.size
             info[:clipping_detail] = clipping_segs
-            info[:status] = "visible"
+            info[:status] = 'visible'
           end
 
           results << info
@@ -196,62 +219,101 @@ module Doom
         results
       end
 
-      def set_player(x, y, z, angle)
-        @player_x = x.to_f
-        @player_y = y.to_f
-        @player_z = z.to_f
-        @player_angle = angle * Math::PI / 180.0
+      # Point the camera at a pose. This is the renderer's real input now that
+      # Game::Player owns the player: game logic mutates the player, and the
+      # camera is aimed once per frame at an interpolated pose. Angle is in
+      # radians here, unlike the older degree-based setters below.
+      def apply_view(x, y, z, angle_radians)
+        @player_x = x
+        @player_y = y
+        @player_z = z
+        @player_angle = angle_radians
+        @sin_angle = Math.sin(angle_radians)
+        @cos_angle = Math.cos(angle_radians)
       end
 
-      def move_to(x, y)
+      def set_player(x, y, z, angle)
         @player_x = x.to_f
         @player_y = y.to_f
-      end
-
-      def set_z(z)
         @player_z = z.to_f
-      end
-
-      def turn(degrees)
-        @player_angle += degrees * Math::PI / 180.0
+        @player_angle = angle * Math::PI / 180.0
+        @sin_angle = Math.sin(@player_angle)
+        @cos_angle = Math.cos(@player_angle)
       end
 
       def render_frame
-        clear_framebuffer
-        reset_clipping
+        if @native_kernel
+          native_wall_pass
+          @drawsegs = []
+        else
+          clear_framebuffer
+          reset_clipping
 
-        @sin_angle = Math.sin(@player_angle)
-        @cos_angle = Math.cos(@player_angle)
+          @sin_angle = Math.sin(@player_angle)
+          @cos_angle = Math.cos(@player_angle)
 
-        # Precompute column angles for floor/ceiling rendering
-        precompute_column_data
+          # Precompute column angles for floor/ceiling rendering
+          precompute_column_data
 
-        # Draw player's sector floor/ceiling as background fallback.
-        # Visplanes (with correct per-sector lighting) overwrite this for sectors
-        # with different properties. This only remains visible at gaps between
-        # same-property sectors where the light level matches anyway.
-        draw_floor_ceiling_background
+          # Draw player's sector floor/ceiling as background fallback.
+          # Visplanes (with correct per-sector lighting) overwrite this for sectors
+          # with different properties. This only remains visible at gaps between
+          # same-property sectors where the light level matches anyway.
+          draw_floor_ceiling_background
 
-        # Initialize visplanes for tracking visible floor/ceiling spans
-        @visplanes = []
-        @visplane_hash = {}  # Hash for O(1) lookup by (height, texture, light_level, is_ceiling)
+          # 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 = []
+          # Initialize drawsegs for sprite clipping
+          @drawsegs = []
 
-        # Render walls via BSP traversal
-        render_bsp_node(@map.nodes.size - 1)
+          # Render walls via BSP traversal
+          render_bsp_node(@map.nodes.size - 1)
 
-        # Draw visplanes for sectors different from background
-        draw_all_visplanes
+          # Draw visplanes for sectors different from background
+          draw_all_visplanes
+        end
 
         # 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
+        # R_DrawMasked: render sprites and masked middle textures interleaved
+        draw_masked if @sprites
+      end
+
+      # Wall/floor/ceiling/sky rasterisation through the spinel_native-compiled
+      # port of this renderer's hot path. Fills @framebuffer plus the clip rows
+      # the Ruby sprite pass reads. Falls back to the Ruby path if the kernel
+      # cannot be built (e.g. no spinel compiler available).
+      def native_wall_pass
+        @sn ||= build_native_renderer
+        unless @sn
+          @native_kernel = false
+          return render_frame
+        end
+        # The sprite pass (kept in Ruby) transforms things with @sin_angle /
+        # @cos_angle, so they must be set for the current frame even though the
+        # native kernel computes its own trig internally.
+        @sin_angle = Math.sin(@player_angle)
+        @cos_angle = Math.cos(@player_angle)
+        fb = @sn.render_at(@player_x, @player_y, @player_z, @player_angle)
+        @framebuffer.replace(fb)
+        @ceiling_clip.replace(@sn.ceiling_clip)
+        @floor_clip.replace(@sn.floor_clip)
+        @wall_depth.replace(@sn.wall_depth)
+      end
+
+      def build_native_renderer
+        # Dynamic form so the spinel AOT compiler ignores this require (it pulls
+        # in the spinel_native gem, irrelevant to an AOT build); CRuby is unaffected.
+        send(:require_relative, "spinel_native_renderer")
+        SpinelNativeRenderer.new(@map, @palette, @colormap, @textures, @flats_array)
+      rescue StandardError, LoadError => e
+        warn "[doom] spinel_native renderer unavailable, using Ruby renderer (#{e.message.lines.first.to_s.strip})"
+        nil
       end
 
       # Precompute column-based data for floor/ceiling rendering (R_InitLightTables-like)
@@ -269,6 +331,8 @@ module Doom
       end
 
       def draw_floor_ceiling_background
+        return if @skip_background_fill
+
         player_sector = @map.sector_at(@player_x, @player_y)
         return unless player_sector
 
@@ -293,7 +357,7 @@ module Doom
       def render_visplane_spans(plane)
         return if plane.minx > plane.maxx
 
-        spanstart = Array.new(SCREEN_HEIGHT)  # Track where each row's span started
+        spanstart = Array.new(SCREEN_HEIGHT) # Track where each row's span started
 
         # Process columns left to right
         ((plane.minx)..(plane.maxx + 1)).each do |x|
@@ -301,9 +365,10 @@ module Doom
           if x <= plane.maxx
             t2 = plane.top[x]
             b2 = plane.bottom[x]
-            t2 = SCREEN_HEIGHT if t2 > b2  # Invalid = empty
+            t2 = SCREEN_HEIGHT if t2 > b2 # Invalid = empty
           else
-            t2, b2 = SCREEN_HEIGHT, -1  # Sentinel for final column
+            t2 = SCREEN_HEIGHT
+            b2 = -1 # Sentinel for final column
           end
 
           # Get previous column bounds
@@ -312,7 +377,8 @@ module Doom
             b1 = plane.bottom[x - 1]
             t1 = SCREEN_HEIGHT if t1 > b1
           else
-            t1, b1 = SCREEN_HEIGHT, -1
+            t1 = SCREEN_HEIGHT
+            b1 = -1
           end
 
           # Close spans that ended (visible in prev column, not in current)
@@ -329,10 +395,10 @@ module Doom
           end
 
           # Open new spans (visible in current, not started yet)
-          if t2 < SCREEN_HEIGHT
-            (t2..b2).each do |y|
-              spanstart[y] ||= x
-            end
+          next unless t2 < SCREEN_HEIGHT
+
+          (t2..b2).each do |y|
+            spanstart[y] ||= x
           end
         end
       end
@@ -377,9 +443,9 @@ module Doom
         x = x1
         while x <= x2
           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_pixels[tex_y * 64 + tex_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_pixels[(tex_y * 64) + tex_x]
           framebuffer[row_offset + x] = cmap[color]
           x += 1
         end
@@ -390,7 +456,7 @@ module Doom
       # Chocolate Doom: skytexturemid = SCREENHEIGHT/2 = 100 (for 200px screen).
       # Scale factor: our 240px screen maps to DOOM's 200px sky coordinates.
       SKY_TEXTUREMID = 100.0
-      SKY_YSCALE = 200.0 / SCREEN_HEIGHT  # 0.833 - maps our pixels to DOOM's 200px space
+      SKY_YSCALE = 200.0 / SCREEN_HEIGHT # 0.833 - maps our pixels to DOOM's 200px space
       # Chocolate Doom: ANGLETOSKYSHIFT=22 gives 4 sky repetitions per 360 degrees.
       # Full circle (2pi) * 512/pi = 1024 columns, masked to 256 = 4 repetitions.
       SKY_XSCALE = 512.0 / Math::PI
@@ -427,9 +493,9 @@ module Doom
           # Sky Y: texel = skytexturemid + (y - centery) * scale
           # Maps texel 0 to screen top, texel 100 to horizon (1:1 for DOOM's 200px)
           (y1..y2).each do |y|
-            tex_y = (SKY_TEXTUREMID + (y - HALF_HEIGHT) * SKY_YSCALE).to_i % sky_height
+            tex_y = (SKY_TEXTUREMID + ((y - HALF_HEIGHT) * SKY_YSCALE)).to_i % sky_height
             color = column[tex_y]
-            framebuffer[y * SCREEN_WIDTH + x] = color
+            framebuffer[(y * SCREEN_WIDTH) + x] = color
           end
         end
       end
@@ -475,13 +541,14 @@ module Doom
         overlap = false
         (intrl..intrh).each do |x|
           next if x < 0 || x >= SCREEN_WIDTH
+
           if plane.top[x] <= plane.bottom[x]
             overlap = true
             break
           end
         end
 
-        if !overlap
+        unless overlap
           # No overlap - reuse same visplane with expanded range
           plane.minx = unionl if unionl < plane.minx
           plane.maxx = unionh if unionh > plane.maxx
@@ -551,7 +618,7 @@ module Doom
               if is_sky && sky_texture
                 sky_w = sky_texture.width
                 sky_h = sky_texture.height
-                sky_y = (SKY_TEXTUREMID + (y - HALF_HEIGHT) * SKY_YSCALE).to_i % sky_h
+                sky_y = (SKY_TEXTUREMID + ((y - HALF_HEIGHT) * SKY_YSCALE)).to_i % sky_h
                 x = 0
                 while x < SCREEN_WIDTH
                   column_angle = player_angle - Math.atan2(x - HALF_WIDTH, projection)
@@ -564,9 +631,9 @@ module Doom
                 x = 0
                 while x < SCREEN_WIDTH
                   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_pixels[tex_y * 64 + tex_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_pixels[(tex_y * 64) + tex_x]
                   framebuffer[row_offset + x] = cmap[color]
                   x += 1
                 end
@@ -591,9 +658,9 @@ module Doom
                 x = 0
                 while x < SCREEN_WIDTH
                   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_pixels[tex_y * 64 + tex_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_pixels[(tex_y * 64) + tex_x]
                   framebuffer[row_offset + x] = cmap[color]
                   x += 1
                 end
@@ -682,6 +749,7 @@ module Doom
         x = min_sx
         while x <= max_sx
           return true if @ceiling_clip[x] < @floor_clip[x] - 1
+
           x += 1
         end
 
@@ -711,32 +779,28 @@ module Doom
 
         # Create floor visplane if floor is visible (below eye level)
         # Matches Chocolate Doom: if (frontsector->floorheight < viewz)
-        if @current_sector.floor_height < @player_z
-          @current_floor_plane = find_or_create_visplane(
-            @current_sector,
-            @current_sector.floor_height,
-            @current_sector.floor_texture,
-            @current_sector.light_level,
-            false
-          )
-        else
-          @current_floor_plane = nil
-        end
+        @current_floor_plane = if @current_sector.floor_height < @player_z
+                                 find_or_create_visplane(
+                                   @current_sector,
+                                   @current_sector.floor_height,
+                                   @current_sector.floor_texture,
+                                   @current_sector.light_level,
+                                   false
+                                 )
+                               end
 
         # Create ceiling visplane if ceiling is visible (above eye level or sky)
         # Matches Chocolate Doom: if (frontsector->ceilingheight > viewz || frontsector->ceilingpic == skyflatnum)
         is_sky = @current_sector.ceiling_texture == 'F_SKY1'
-        if @current_sector.ceiling_height > @player_z || is_sky
-          @current_ceiling_plane = find_or_create_visplane(
-            @current_sector,
-            @current_sector.ceiling_height,
-            @current_sector.ceiling_texture,
-            @current_sector.light_level,
-            true
-          )
-        else
-          @current_ceiling_plane = nil
-        end
+        @current_ceiling_plane = if @current_sector.ceiling_height > @player_z || is_sky
+                                   find_or_create_visplane(
+                                     @current_sector,
+                                     @current_sector.ceiling_height,
+                                     @current_sector.ceiling_texture,
+                                     @current_sector.light_level,
+                                     true
+                                   )
+                                 end
 
         # Process all segs in this subsector
         subsector.seg_count.times do |i|
@@ -764,11 +828,11 @@ module Doom
             return
           elsif y1 < near
             t = (near - y1) / (y2 - y1)
-            x1 = x1 + t * (x2 - x1)
+            x1 += (t * (x2 - x1))
             y1 = near
           elsif y2 < near
             t = (near - y1) / (y2 - y1)
-            x2 = x1 + t * (x2 - x1)
+            x2 = x1 + (t * (x2 - x1))
             y2 = near
           end
         end
@@ -812,7 +876,7 @@ module Doom
         # Calculate seg length for texture mapping
         seg_v1 = @map.vertices[seg.v1]
         seg_v2 = @map.vertices[seg.v2]
-        seg_length = Math.sqrt((seg_v2.x - seg_v1.x)**2 + (seg_v2.y - seg_v1.y)**2)
+        seg_length = Math.sqrt(((seg_v2.x - seg_v1.x)**2) + ((seg_v2.y - seg_v1.y)**2))
 
         draw_seg_range(x1i, x2i, sx1, sx2, y1, y2, sector, back_sector, sidedef, linedef, seg, seg_length)
       end
@@ -824,8 +888,8 @@ module Doom
 
         # Rotate - transform world to view space
         # View space: +Y forward (in direction of angle), +X is right
-        x = dx * @sin_angle - dy * @cos_angle
-        y = dx * @cos_angle + dy * @sin_angle
+        x = (dx * @sin_angle) - (dy * @cos_angle)
+        y = (dx * @cos_angle) + (dy * @sin_angle)
 
         [x, y]
       end
@@ -878,16 +942,16 @@ module Doom
         cos_a = @cos_angle
         proj = @projection
 
-        c1 = cos_a * proj - sin_a * HALF_WIDTH
-        c2 = sin_a * proj + cos_a * HALF_WIDTH
+        c1 = (cos_a * proj) - (sin_a * HALF_WIDTH)
+        c2 = (sin_a * proj) + (cos_a * HALF_WIDTH)
 
         # denom(x) = seg_dy * ray_dx - seg_dx * ray_dy = A * x + B
-        tex_a = seg_dy * sin_a + seg_dx * cos_a
-        tex_b = seg_dy * c1 - seg_dx * c2
+        tex_a = (seg_dy * sin_a) + (seg_dx * cos_a)
+        tex_b = (seg_dy * c1) - (seg_dx * c2)
 
         # numer(x) = py * ray_dx - px * ray_dy = E * x + F
-        tex_e = py * sin_a + px * cos_a
-        tex_f = py * c1 - px * c2
+        tex_e = (py * sin_a) + (px * cos_a)
+        tex_f = (py * c1) - (px * c2)
 
         tex_offset = seg.offset + sidedef.x_offset
 
@@ -924,24 +988,39 @@ module Doom
           tsilheight = -Float::INFINITY
         end
 
-        # Check planes for this seg range (R_CheckPlane equivalent)
-        # This may create new visplanes if column ranges would overlap
-        if @current_floor_plane
-          @current_floor_plane = check_plane(@current_floor_plane, x1, x2)
-        end
-        if @current_ceiling_plane
-          @current_ceiling_plane = check_plane(@current_ceiling_plane, x1, x2)
+        # Detect masked middle texture (grates, bars, fences)
+        has_masked = false
+        @current_masked_cols = nil
+        if back_sector && sidedef
+          mid_tex = sidedef.middle_texture
+          if mid_tex && mid_tex != '-' && !mid_tex.empty?
+            has_masked = true
+            @current_masked_cols = Array.new(x2 - x1 + 1)
+            # Force silhouette so sprites get clipped against this seg
+            if (silhouette & SIL_TOP) == 0
+              silhouette |= SIL_TOP
+              tsilheight = -Float::INFINITY
+            end
+            if (silhouette & SIL_BOTTOM) == 0
+              silhouette |= SIL_BOTTOM
+              bsilheight = Float::INFINITY
+            end
+          end
         end
 
+        # Check planes for this seg range (R_CheckPlane equivalent)
+        @current_floor_plane = check_plane(@current_floor_plane, x1, x2) if @current_floor_plane
+        @current_ceiling_plane = check_plane(@current_ceiling_plane, x1, x2) if @current_ceiling_plane
+
         (x1..x2).each do |x|
           next if @ceiling_clip[x] >= @floor_clip[x] - 1
 
           # Screen-space interpolation for distance
-          t = sx2 != sx1 ? (x - sx1) / (sx2 - sx1) : 0
+          t = sx2 == sx1 ? 0 : (x - sx1) / (sx2 - sx1)
           t = t.clamp(0.0, 1.0)
 
           if dist1 > 0 && dist2 > 0
-            inv_dist = (1.0 - t) / dist1 + t / dist2
+            inv_dist = ((1.0 - t) / dist1) + (t / dist2)
             dist = 1.0 / inv_dist
           else
             dist = dist1 > 0 ? dist1 : dist2
@@ -949,13 +1028,13 @@ module Doom
 
           # Ray-seg intersection for texture column
           # s = (E * x + F) / (A * x + B) gives position along seg in world units
-          denom = tex_a * x + tex_b
-          if denom.abs < 0.001
-            s = 0.0
-          else
-            s = (tex_e * x + tex_f) / denom
-          end
-          tex_col = (tex_offset + s * seg_length).to_i
+          denom = (tex_a * x) + tex_b
+          s = if denom.abs < 0.001
+                0.0
+              else
+                ((tex_e * x) + tex_f) / denom
+              end
+          tex_col = (tex_offset + (s * seg_length)).to_i
 
           # Skip if too close
           next if dist < 1
@@ -971,198 +1050,207 @@ module Doom
           # Chocolate Doom rounds ceiling UP and floor DOWN to avoid 1-pixel gaps:
           #   yl = (topfrac+HEIGHTUNIT-1)>>HEIGHTBITS  (ceil for front ceiling)
           #   yh = bottomfrac>>HEIGHTBITS              (floor for front floor)
-          front_ceil_y = (HALF_HEIGHT - front_ceil * scale).ceil
-          front_floor_y = (HALF_HEIGHT - front_floor * scale).to_i
+          front_ceil_y = (HALF_HEIGHT - (front_ceil * scale)).ceil
+          front_floor_y = (HALF_HEIGHT - (front_floor * scale)).to_i
 
           # Clamp to current clip bounds
           ceil_y = [front_ceil_y, @ceiling_clip[x] + 1].max
           floor_y = [front_floor_y, @floor_clip[x] - 1].min
 
           if back_sector
-            # Two-sided line
-            back_floor = back_sector.floor_height - @player_z
-            back_ceil = back_sector.ceiling_height - @player_z
-
-            # Chocolate Doom rounding:
-            #   pixhigh>>HEIGHTBITS (truncate for back ceiling / upper wall end)
-            #   (pixlow+HEIGHTUNIT-1)>>HEIGHTBITS (ceil for back floor / lower wall start)
-            back_ceil_y = (HALF_HEIGHT - back_ceil * scale).to_i
-            back_floor_y = (HALF_HEIGHT - back_floor * scale).ceil
-
-            # Determine visible ceiling/floor boundaries (the opening between sectors)
-            # high_ceil = top of the opening on screen (max Y = lower world ceiling)
-            # low_floor = bottom of the opening on screen (min Y = higher world floor)
-            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
-
-            both_sky = sector.ceiling_texture == 'F_SKY1' && back_sector.ceiling_texture == 'F_SKY1'
-
-            # Determine whether to mark ceiling/floor visplanes.
-            # Match Chocolate Doom: only mark when properties differ, plus force
-            # for closed doors. The background fill covers same-property gaps.
-            # Chocolate Doom sky hack: "worldtop = worldhigh" makes the front
-            # ceiling equal to the back ceiling when both are sky. This prevents
-            # the low sky ceiling from clipping walls in adjacent sectors.
-            effective_front_ceil = both_sky ? back_sector.ceiling_height : sector.ceiling_height
-
-            if closed_door
-              should_mark_ceiling = true
-              should_mark_floor = true
-            else
-              should_mark_ceiling = effective_front_ceil != back_sector.ceiling_height ||
-                                    sector.ceiling_texture != back_sector.ceiling_texture ||
-                                    sector.light_level != back_sector.light_level
-              should_mark_floor = sector.floor_height != back_sector.floor_height ||
-                                  sector.floor_texture != back_sector.floor_texture ||
-                                  sector.light_level != back_sector.light_level
-            end
+            draw_two_sided_seg_column(x, x1, ceil_y, floor_y, scale, dist, tex_col,
+                                      sector, back_sector, sidedef, linedef)
+          else
+            draw_one_sided_seg_column(x, ceil_y, floor_y, scale, dist, tex_col,
+                                      sector, sidedef, linedef)
+          end
+        end
 
-            # Mark ceiling visplane
-            if @current_ceiling_plane && should_mark_ceiling
-              mark_top = @ceiling_clip[x] + 1
-              mark_bottom = ceil_y - 1
-              mark_bottom = [@floor_clip[x] - 1, mark_bottom].min
-              if mark_top <= mark_bottom
-                @current_ceiling_plane.mark(x, mark_top, mark_bottom)
-              end
-            end
+        # Save drawseg for sprite clipping and masked rendering
+        if silhouette != SIL_NONE || has_masked
+          sprtopclip = @ceiling_clip[x1..x2].dup
+          sprbottomclip = @floor_clip[x1..x2].dup
+          scalestep = x2 > x1 ? (scale2 - scale1) / (x2 - x1) : 0
 
-            # Mark floor visplane
-            if @current_floor_plane && should_mark_floor
-              mark_top = floor_y + 1
-              mark_bottom = @floor_clip[x] - 1
-              mark_top = [@ceiling_clip[x] + 1, mark_top].max
-              if mark_top <= mark_bottom
-                @current_floor_plane.mark(x, mark_top, mark_bottom)
-              end
-            end
+          drawseg = Drawseg.new(
+            x1, x2,
+            scale1, scale2, scalestep,
+            silhouette,
+            bsilheight, tsilheight,
+            sprtopclip, sprbottomclip,
+            seg,
+            has_masked ? @current_masked_cols : nil,
+            sector, back_sector, sidedef,
+            dist1, dist2, sx1.to_f, sx2.to_f
+          )
+          @drawsegs << drawseg
+        end
+        @current_masked_cols = nil
+      end
 
-            # Upper wall (ceiling step down) - skip if both sectors have sky
-            if !both_sky && sector.ceiling_height > back_sector.ceiling_height
-              if linedef.upper_unpegged?
-                upper_tex_y = sidedef.y_offset
-              else
-                texture = @textures[sidedef.upper_texture]
-                tex_height = texture ? texture.height : 128
-                upper_tex_y = sidedef.y_offset + back_sector.ceiling_height - sector.ceiling_height + tex_height
-              end
-              draw_wall_column_ex(x, ceil_y, back_ceil_y, sidedef.upper_texture, dist,
-                                  sector.light_level, tex_col, upper_tex_y, scale, sector.ceiling_height, back_sector.ceiling_height)
-            end
+      # One screen column of a two-sided seg: mark the ceiling/floor visplanes
+      # of the opening between the two sectors, draw the upper and lower wall
+      # steps, remember the masked-middle column, and tighten the clip bounds.
+      def draw_two_sided_seg_column(x, x1, ceil_y, floor_y, scale, dist, tex_col,
+                                    sector, back_sector, sidedef, linedef)
+        back_floor = back_sector.floor_height - @player_z
+        back_ceil = back_sector.ceiling_height - @player_z
+
+        # Chocolate Doom rounding:
+        #   pixhigh>>HEIGHTBITS (truncate for back ceiling / upper wall end)
+        #   (pixlow+HEIGHTUNIT-1)>>HEIGHTBITS (ceil for back floor / lower wall start)
+        back_ceil_y = (HALF_HEIGHT - (back_ceil * scale)).to_i
+        back_floor_y = (HALF_HEIGHT - (back_floor * scale)).ceil
+
+        # 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
+
+        both_sky = sector.ceiling_texture == 'F_SKY1' && back_sector.ceiling_texture == 'F_SKY1'
+
+        # Determine whether to mark ceiling/floor visplanes.
+        # Match Chocolate Doom: only mark when properties differ, plus force
+        # for closed doors. The background fill covers same-property gaps.
+        # Chocolate Doom sky hack: "worldtop = worldhigh" makes the front
+        # ceiling equal to the back ceiling when both are sky. This prevents
+        # the low sky ceiling from clipping walls in adjacent sectors.
+        effective_front_ceil = both_sky ? back_sector.ceiling_height : sector.ceiling_height
+
+        if closed_door
+          should_mark_ceiling = true
+          should_mark_floor = true
+        else
+          should_mark_ceiling = effective_front_ceil != back_sector.ceiling_height ||
+                                sector.ceiling_texture != back_sector.ceiling_texture ||
+                                sector.light_level != back_sector.light_level
+          should_mark_floor = sector.floor_height != back_sector.floor_height ||
+                              sector.floor_texture != back_sector.floor_texture ||
+                              sector.light_level != back_sector.light_level
+        end
 
-            # Lower wall (floor step up)
-            if sector.floor_height < back_sector.floor_height
-              if linedef.lower_unpegged?
-                lower_tex_y = sidedef.y_offset + sector.ceiling_height - back_sector.floor_height
-              else
-                lower_tex_y = sidedef.y_offset
-              end
-              draw_wall_column_ex(x, back_floor_y, floor_y, sidedef.lower_texture, dist,
-                                  sector.light_level, tex_col, lower_tex_y, scale, back_sector.floor_height, sector.floor_height)
-            end
+        # Mark ceiling visplane
+        if @current_ceiling_plane && should_mark_ceiling
+          mark_top = @ceiling_clip[x] + 1
+          mark_bottom = ceil_y - 1
+          mark_bottom = [@floor_clip[x] - 1, mark_bottom].min
+          @current_ceiling_plane.mark(x, mark_top, mark_bottom) if mark_top <= mark_bottom
+        end
 
-            # Update clip bounds
-            if closed_door
-              @wall_depth[x] = [@wall_depth[x], dist].min
-              @ceiling_clip[x] = SCREEN_HEIGHT
-              @floor_clip[x] = -1
-            else
-              # Ceiling clip (uses effective_front_ceil for sky hack)
-              if effective_front_ceil > back_sector.ceiling_height
-                @ceiling_clip[x] = [back_ceil_y, @ceiling_clip[x]].max
-              elsif effective_front_ceil < back_sector.ceiling_height
-                @ceiling_clip[x] = [ceil_y - 1, @ceiling_clip[x]].max
-              elsif sector.ceiling_texture != back_sector.ceiling_texture ||
-                    sector.light_level != back_sector.light_level
-                @ceiling_clip[x] = [ceil_y - 1, @ceiling_clip[x]].max
-              end
+        # Mark floor visplane
+        if @current_floor_plane && should_mark_floor
+          mark_top = floor_y + 1
+          mark_bottom = @floor_clip[x] - 1
+          mark_top = [@ceiling_clip[x] + 1, mark_top].max
+          @current_floor_plane.mark(x, mark_top, mark_bottom) if mark_top <= mark_bottom
+        end
 
-              # Floor clip
-              if sector.floor_height < back_sector.floor_height
-                @floor_clip[x] = [back_floor_y, @floor_clip[x]].min
-              elsif sector.floor_height > back_sector.floor_height
-                # Chocolate Doom: else if (markfloor) floorclip = yh + 1
-                @floor_clip[x] = [floor_y + 1, @floor_clip[x]].min
-              elsif sector.floor_texture != back_sector.floor_texture ||
-                    sector.light_level != back_sector.light_level
-                @floor_clip[x] = [floor_y + 1, @floor_clip[x]].min
-              end
-            end
+        # Upper wall (ceiling step down) - skip if both sectors have sky
+        if !both_sky && sector.ceiling_height > back_sector.ceiling_height
+          if linedef.upper_unpegged?
+            upper_tex_y = sidedef.y_offset
           else
-            # One-sided (solid) wall
-            # Mark ceiling visplane (from previous clip to wall's ceiling)
-            # Clamp to floor_clip to prevent ceiling bleeding through portal openings
-            if @current_ceiling_plane
-              mark_top = @ceiling_clip[x] + 1
-              mark_bottom = [ceil_y - 1, @floor_clip[x] - 1].min
-              if mark_top <= mark_bottom
-                @current_ceiling_plane.mark(x, mark_top, mark_bottom)
-              end
-            end
+            texture = @textures[sidedef.upper_texture]
+            tex_height = texture ? texture.height : 128
+            upper_tex_y = sidedef.y_offset + back_sector.ceiling_height - sector.ceiling_height + tex_height
+          end
+          draw_wall_column_ex(x, ceil_y, back_ceil_y, sidedef.upper_texture, dist,
+                              sector.light_level, tex_col, upper_tex_y, scale, sector.ceiling_height)
+        end
 
-            # Mark floor visplane (from wall's floor to previous floor clip)
-            # Clamp to ceiling_clip to prevent floor bleeding through portal openings
-            if @current_floor_plane
-              mark_top = [floor_y + 1, @ceiling_clip[x] + 1].max
-              mark_bottom = @floor_clip[x] - 1
-              if mark_top <= mark_bottom
-                @current_floor_plane.mark(x, mark_top, mark_bottom)
-              end
-            end
+        # Lower wall (floor step up)
+        if sector.floor_height < back_sector.floor_height
+          lower_tex_y = if linedef.lower_unpegged?
+                          sidedef.y_offset + sector.ceiling_height - back_sector.floor_height
+                        else
+                          sidedef.y_offset
+                        end
+          draw_wall_column_ex(x, back_floor_y, floor_y, sidedef.lower_texture, dist,
+                              sector.light_level, tex_col, lower_tex_y, scale, back_sector.floor_height)
+        end
 
-            # Draw wall (from clipped ceiling to clipped floor)
-            # Middle texture Y offset depends on DONTPEGBOTTOM flag
-            # With DONTPEGBOTTOM: texture bottom aligns with floor
-            # Without: texture top aligns with ceiling
-            if linedef.lower_unpegged?
-              texture = @textures[sidedef.middle_texture]
-              tex_height = texture ? texture.height : 128
-              mid_tex_y = sidedef.y_offset + tex_height - (sector.ceiling_height - sector.floor_height)
-            else
-              mid_tex_y = sidedef.y_offset
-            end
-            draw_wall_column_ex(x, ceil_y, floor_y, sidedef.middle_texture, dist,
-                                sector.light_level, tex_col, mid_tex_y, scale, sector.ceiling_height, sector.floor_height)
+        # Store masked texture column for deferred rendering (grates, bars)
+        @current_masked_cols[x - x1] = tex_col if @current_masked_cols
 
-            # Track wall depth for sprite clipping (solid wall occludes this column)
-            @wall_depth[x] = [@wall_depth[x], dist].min
+        # Update clip bounds
+        if closed_door
+          @wall_depth[x] = [@wall_depth[x], dist].min
+          @ceiling_clip[x] = SCREEN_HEIGHT
+          @floor_clip[x] = -1
+        else
+          # Ceiling clip (uses effective_front_ceil for sky hack)
+          if effective_front_ceil > back_sector.ceiling_height
+            @ceiling_clip[x] = [back_ceil_y, @ceiling_clip[x]].max
+          elsif effective_front_ceil < back_sector.ceiling_height
+            @ceiling_clip[x] = [ceil_y - 1, @ceiling_clip[x]].max
+          elsif sector.ceiling_texture != back_sector.ceiling_texture ||
+                sector.light_level != back_sector.light_level
+            @ceiling_clip[x] = [ceil_y - 1, @ceiling_clip[x]].max
+          end
 
-            # Fully occluded
-            @ceiling_clip[x] = SCREEN_HEIGHT
-            @floor_clip[x] = -1
+          # Floor clip
+          if sector.floor_height < back_sector.floor_height
+            @floor_clip[x] = [back_floor_y, @floor_clip[x]].min
+          elsif sector.floor_height > back_sector.floor_height
+            # Chocolate Doom: else if (markfloor) floorclip = yh + 1
+            @floor_clip[x] = [floor_y + 1, @floor_clip[x]].min
+          elsif sector.floor_texture != back_sector.floor_texture ||
+                sector.light_level != back_sector.light_level
+            @floor_clip[x] = [floor_y + 1, @floor_clip[x]].min
           end
         end
+      end
 
-        # Save drawseg for sprite clipping (after columns are rendered)
-        # Copy the clip arrays for the segment's screen range
-        if silhouette != SIL_NONE
-          sprtopclip = @ceiling_clip[x1..x2].dup
-          sprbottomclip = @floor_clip[x1..x2].dup
+      # One screen column of a one-sided (solid) wall: mark the ceiling and
+      # floor visplanes down to the wall, draw the full-height middle texture,
+      # and fully occlude the column for anything behind it.
+      def draw_one_sided_seg_column(x, ceil_y, floor_y, scale, dist, tex_col,
+                                    sector, sidedef, linedef)
+        # Mark ceiling visplane (from previous clip to wall's ceiling)
+        # Clamp to floor_clip to prevent ceiling bleeding through portal openings
+        if @current_ceiling_plane
+          mark_top = @ceiling_clip[x] + 1
+          mark_bottom = [ceil_y - 1, @floor_clip[x] - 1].min
+          @current_ceiling_plane.mark(x, mark_top, mark_bottom) if mark_top <= mark_bottom
+        end
 
-          drawseg = Drawseg.new(
-            x1, x2,
-            scale1, scale2,
-            silhouette,
-            bsilheight, tsilheight,
-            sprtopclip, sprbottomclip,
-            seg
-          )
-          @drawsegs << drawseg
+        # Mark floor visplane (from wall's floor to previous floor clip)
+        # Clamp to ceiling_clip to prevent floor bleeding through portal openings
+        if @current_floor_plane
+          mark_top = [floor_y + 1, @ceiling_clip[x] + 1].max
+          mark_bottom = @floor_clip[x] - 1
+          @current_floor_plane.mark(x, mark_top, mark_bottom) if mark_top <= mark_bottom
         end
+
+        # Draw wall (from clipped ceiling to clipped floor)
+        # Middle texture Y offset depends on DONTPEGBOTTOM flag
+        # With DONTPEGBOTTOM: texture bottom aligns with floor
+        # Without: texture top aligns with ceiling
+        if linedef.lower_unpegged?
+          texture = @textures[sidedef.middle_texture]
+          tex_height = texture ? texture.height : 128
+          mid_tex_y = sidedef.y_offset + tex_height - (sector.ceiling_height - sector.floor_height)
+        else
+          mid_tex_y = sidedef.y_offset
+        end
+        draw_wall_column_ex(x, ceil_y, floor_y, sidedef.middle_texture, dist,
+                            sector.light_level, tex_col, mid_tex_y, scale, sector.ceiling_height)
+
+        # Track wall depth for sprite clipping (solid wall occludes this column)
+        @wall_depth[x] = [@wall_depth[x], dist].min
+
+        # Fully occluded
+        @ceiling_clip[x] = SCREEN_HEIGHT
+        @floor_clip[x] = -1
       end
 
       # Wall column drawing with proper texture mapping
       # tex_col: texture column (X coordinate in texture)
       # tex_y_start: starting Y coordinate in texture (accounts for pegging)
       # scale: projection scale for this column (projection / distance)
-      # world_top, world_bottom: world heights of this wall section
-      def draw_wall_column_ex(x, y1, y2, texture_name, dist, light_level, tex_col, tex_y_start, scale, world_top, world_bottom)
+      # world_top: world height of the top of this wall section
+      def draw_wall_column_ex(x, y1, y2, texture_name, dist, light_level, tex_col, tex_y_start, scale, world_top)
         return if y1 > y2
         return if texture_name.nil? || texture_name.empty? || texture_name == '-'
 
@@ -1193,10 +1281,10 @@ module Doom
         tex_step = 1.0 / scale
 
         # Calculate where the unclipped wall top would be on screen
-        unclipped_y1 = HALF_HEIGHT - (world_top - @player_z) * scale
+        unclipped_y1 = HALF_HEIGHT - ((world_top - @player_z) * scale)
 
         # Adjust tex_y_start for any clipping at the top
-        tex_y_at_y1 = tex_y_start + (y1 - unclipped_y1) * tex_step
+        tex_y_at_y1 = tex_y_start + ((y1 - unclipped_y1) * tex_step)
 
         # Clamp to screen bounds
         y1 = 0 if y1 < 0
@@ -1206,10 +1294,10 @@ 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_y_at_y1 + (screen_offset * tex_step)).to_i % tex_height
 
           color = column[tex_y]
-          framebuffer[y * SCREEN_WIDTH + x] = cmap[color]
+          framebuffer[(y * SCREEN_WIDTH) + x] = cmap[color] if color
           y += 1
         end
       end
@@ -1307,12 +1395,23 @@ module Doom
           # Get sprite: death frame > walking frame > idle frame
           if @combat && @combat.dead?(thing_idx)
             sprite = @combat.death_sprite(thing_idx, thing.type, angle_to_thing, thing.angle)
+            next unless sprite # Barrel disappeared after explosion
           elsif @monster_ai
-            mon = @monster_ai.monsters.find { |m| m.thing_idx == thing_idx }
+            mon = @monster_ai.monster_by_thing_idx[thing_idx]
             if mon && mon.active
-              # Walking animation: cycle through frames A-D based on leveltime
-              walk_frame = %w[A B C D][@leveltime / 4 % 4]
-              sprite = @sprites.get_frame(thing.type, walk_frame, angle_to_thing, thing.angle)
+              if mon.attacking
+                # Attack animation: show attack frames (E, F, G...)
+                prefix = @sprites.prefix_for(thing.type)
+                atk_frames = Game::MonsterAI::ATTACK_FRAMES[prefix]
+                if atk_frames
+                  frame_idx = (mon.attack_frame_tic / Game::MonsterAI::ATTACK_FRAME_TICS).clamp(0, atk_frames.size - 1)
+                  sprite = @sprites.get_frame(thing.type, atk_frames[frame_idx], angle_to_thing, thing.angle)
+                end
+              else
+                # Walking animation: cycle through frames A-D
+                walk_frame = %w[A B C D][@leveltime / 4 % 4]
+                sprite = @sprites.get_frame(thing.type, walk_frame, angle_to_thing, thing.angle)
+              end
             end
             sprite ||= @sprites.get_rotated(thing.type, angle_to_thing, thing.angle)
           else
@@ -1331,50 +1430,287 @@ module Doom
           visible_sprites << VisibleSprite.new(thing, sprite, view_x, view_y, dist, screen_x)
         end
 
+        collect_player_sprites(visible_sprites)
+
         # Sort by distance (back to front for proper overdraw)
         visible_sprites.sort_by! { |s| -s.dist }
 
-        # Draw each sprite
+        # Draw each sprite with drawseg interleaving
         visible_sprites.each do |vs|
-          draw_sprite(vs)
+          draw_sprite_with_masking(vs)
+        end
+
+        # Draw remaining masked segs not triggered by sprites
+        @drawsegs.reverse_each do |ds|
+          next unless ds.maskedtexturecol
+
+          render_masked_seg_range(ds, ds.x1, ds.x2)
         end
 
-        # Draw projectiles and explosions
-        render_projectiles if @combat
+        # Draw projectiles, explosions, and bullet puffs
+        return unless @combat
+
+        render_projectiles
+        render_puffs
+      end
+
+      # Chocolate Doom R_DrawMasked: interleave sprites with masked drawsegs
+      def draw_masked
+        render_sprites
       end
 
+      # Other players, drawn with the PLAY sprites. They join the same
+      # distance-sorted list as map things rather than being drawn afterwards,
+      # so they occlude and are occluded correctly.
+      PLAYER_SPRITE_PREFIX = 'PLAY'
+      PLAYER_WALK_FRAMES = %w[A B C D].freeze
+      PLAYER_DEATH_FRAMES = %w[H I J K L M N].freeze
+      PLAYER_DEATH_FRAME_TICS = 6
+      PLAYER_ATTACK_FRAME = 'E'
+      PLAYER_MOVING_SPEED = 1.0 # units/sec below which a player reads as still
+
+      def collect_player_sprites(visible_sprites)
+        return if @players.nil? || @players.empty?
+
+        @players.each do |player|
+          # Never draw the player whose eyes we are looking through.
+          next if player.equal?(@view_player)
+
+          view_x, view_y = transform_point(player.x, player.y)
+          next if view_y <= 0
+
+          angle_to_player = Math.atan2(player.y - @player_y, player.x - @player_x)
+          sprite = player_sprite(player, angle_to_player)
+          next unless sprite
+
+          screen_x = HALF_WIDTH + (view_x * @projection / view_y)
+          sprite_half_width = (sprite.width * @projection / view_y / 2).to_i
+          next if screen_x + sprite_half_width < 0
+          next if screen_x - sprite_half_width >= SCREEN_WIDTH
+
+          # z is the player's eye height; the sprite is anchored at the feet.
+          feet_z = player.z - Game::PlayerState::VIEWHEIGHT
+          stub = ProjectileStub.new(player.x, player.y, 0, 0, 0, feet_z)
+          visible_sprites << VisibleSprite.new(stub, sprite, view_x, view_y, view_y, screen_x)
+        end
+      end
+
+      def player_sprite(player, angle_to_player)
+        state = player.state
+        facing = player.angle * 180.0 / Math::PI
+
+        if state.dead
+          idx = (state.death_tic / PLAYER_DEATH_FRAME_TICS).clamp(0, PLAYER_DEATH_FRAMES.size - 1)
+          frame = PLAYER_DEATH_FRAMES[idx]
+        elsif state.attacking
+          frame = PLAYER_ATTACK_FRAME
+        elsif Math.hypot(player.momx, player.momy) > PLAYER_MOVING_SPEED
+          frame = PLAYER_WALK_FRAMES[@leveltime / 4 % PLAYER_WALK_FRAMES.size]
+        else
+          frame = PLAYER_WALK_FRAMES.first
+        end
+
+        @sprites.get_frame_rotated(PLAYER_SPRITE_PREFIX, frame, angle_to_player, facing)
+      end
+
+      # Draw sprite, rendering masked drawsegs behind it first (R_DrawSprite)
+      def draw_sprite_with_masking(spr)
+        sprite_scale = @projection / spr.dist
+
+        # Scan drawsegs newest to oldest (nearest to farthest)
+        @drawsegs.reverse_each do |ds|
+          next if ds.x1 > spr.screen_x.to_i + spr.sprite.width || ds.x2 < spr.screen_x.to_i - spr.sprite.width
+          next if ds.silhouette == SIL_NONE && ds.maskedtexturecol.nil?
+
+          ds_max_scale = [ds.scale1, ds.scale2].max
+          [ds.scale1, ds.scale2].min
+
+          # Is the drawseg behind the sprite?
+          next unless ds_max_scale < sprite_scale
+
+          # Draw masked texture behind the sprite
+          if ds.maskedtexturecol
+            r1 = [ds.x1, spr.screen_x.to_i - spr.sprite.width].max
+            r2 = [ds.x2, spr.screen_x.to_i + spr.sprite.width].min
+            render_masked_seg_range(ds, r1, r2)
+          end
+          next # Don't clip against things behind
+        end
+
+        draw_sprite(spr)
+      end
+
+      # Chocolate Doom R_RenderMaskedSegRange
+      def render_masked_seg_range(ds, rx1, rx2)
+        return unless ds.maskedtexturecol
+        return unless ds.sidedef
+
+        mid_tex_name = ds.sidedef.middle_texture
+        return if mid_tex_name.nil? || mid_tex_name == '-' || mid_tex_name.empty?
+
+        texture = @textures[anim_texture(mid_tex_name)]
+        return unless texture
+
+        front = ds.frontsector
+        back = ds.backsector
+        return unless front && back
+
+        # Texture anchoring (matching Chocolate Doom)
+        if ds.curline && @map.linedefs[ds.curline.linedef].lower_unpegged?
+          higher_floor = [front.floor_height, back.floor_height].max
+          dc_texturemid = higher_floor + texture.height - @player_z
+        else
+          lower_ceiling = [front.ceiling_height, back.ceiling_height].min
+          dc_texturemid = lower_ceiling - @player_z
+        end
+        dc_texturemid += ds.sidedef.y_offset
+
+        light_level = front.light_level
+
+        # Iterate columns
+        rx1 = [rx1, ds.x1].max
+        rx2 = [rx2, ds.x2].min
+
+        (rx1..rx2).each do |x|
+          col_idx = x - ds.x1
+          next if col_idx < 0 || col_idx >= ds.maskedtexturecol.size
+
+          tex_col = ds.maskedtexturecol[col_idx]
+          next unless tex_col # nil = already drawn or empty
+
+          # Per-column distance using same 1/z interpolation as wall renderer
+          if ds.dist1 && ds.dist2 && ds.dist1 > 0 && ds.dist2 > 0 && ds.sx2 != ds.sx1
+            t = ((x - ds.sx1) / (ds.sx2 - ds.sx1)).clamp(0.0, 1.0)
+            inv_dist = ((1.0 - t) / ds.dist1) + (t / ds.dist2)
+            col_dist = 1.0 / inv_dist
+          else
+            col_dist = ds.dist1 || 1.0
+          end
+          next if col_dist < 1
+
+          spryscale = @projection / col_dist
+          spryscale = [spryscale, 64.0].min
+
+          # Screen Y of texture top
+          sprtopscreen = HALF_HEIGHT - (dc_texturemid * spryscale)
+
+          # Get clip bounds from drawseg
+          clip_idx = x - ds.x1
+          mceilingclip = ds.sprtopclip[clip_idx]
+          mfloorclip = ds.sprbottomclip[clip_idx]
+
+          # Calculate column draw range
+          tex_x = tex_col.to_i % texture.width
+          column = texture.column_pixels(tex_x)
+          next unless column
+
+          iscale = 1.0 / spryscale
+
+          light = calculate_light(light_level, col_dist)
+          cmap = @colormap.maps[light]
+
+          # Draw each non-nil run of pixels (transparency)
+          tex_height = texture.height
+          y_start = nil
+          (0..tex_height).each do |ty|
+            color = ty < tex_height ? column[ty] : nil
+            if color
+              y_start ||= ty
+            elsif y_start
+              # Draw run from y_start to ty-1
+              top_y = (sprtopscreen + (y_start * spryscale)).to_i
+              bot_y = (sprtopscreen + (ty * spryscale)).to_i - 1
+              top_y = [top_y, mceilingclip + 1].max
+              bot_y = [bot_y, mfloorclip - 1].min
+
+              if top_y <= bot_y
+                top_y = [top_y, 0].max
+                bot_y = [bot_y, SCREEN_HEIGHT - 1].min
+                tex_frac = y_start + ((top_y - (sprtopscreen + (y_start * spryscale))) * iscale)
+                y = top_y
+                while y <= bot_y
+                  t = (tex_frac.to_i % tex_height)
+                  c = column[t]
+                  @framebuffer[(y * SCREEN_WIDTH) + x] = cmap[c] if c
+                  tex_frac += iscale
+                  y += 1
+                end
+              end
+              y_start = nil
+            end
+          end
+
+          # Mark column as drawn
+          ds.maskedtexturecol[col_idx] = nil
+        end
+      end
+
+      # Stub for projectiles/explosions that carries a z height
+      ProjectileStub = Struct.new(:x, :y, :angle, :type, :flags, :z)
+
       def render_projectiles
-        # Render rockets in flight
+        # Render all projectiles in flight
         @combat.projectiles.each do |proj|
           view_x, view_y = transform_point(proj.x, proj.y)
           next if view_y <= 0
 
-          # Rocket has rotations 1-8 based on travel direction relative to viewer
+          prefix = proj.sprite_prefix || 'MISL'
+
+          # Try rotation-based sprite first (rockets, baron fireballs)
           rocket_angle = Math.atan2(proj.dy, proj.dx)
           viewer_angle = Math.atan2(proj.y - @player_y, proj.x - @player_x)
           angle_diff = (viewer_angle - rocket_angle) % (2 * Math::PI)
-          rotation = ((angle_diff + Math::PI / 8) / (Math::PI / 4)).to_i % 8 + 1
-          rocket_sprite = @sprites.send(:load_sprite_frame, 'MISL', 'A', rotation)
-          next unless rocket_sprite
+          rotation = (((angle_diff + (Math::PI / 8)) / (Math::PI / 4)).to_i % 8) + 1
+
+          # Animate flight: cycle A/B frames
+          flight_frame = %w[A B][@leveltime / 4 % 2]
+          proj_sprite = @sprites.send(:load_sprite_frame, prefix, flight_frame, rotation)
+          proj_sprite ||= @sprites.send(:load_sprite_frame, prefix, flight_frame, 0)
+          proj_sprite ||= @sprites.send(:load_sprite_frame, prefix, 'A', 0)
+          next unless proj_sprite
 
           screen_x = HALF_WIDTH + (view_x * @projection / view_y)
-          thing_stub = Map::Thing.new(proj.x, proj.y, 0, 0, 0)
-          visible = VisibleSprite.new(thing_stub, rocket_sprite, view_x, view_y, view_y, screen_x)
+          stub = ProjectileStub.new(proj.x, proj.y, 0, 0, 0, proj.z)
+          visible = VisibleSprite.new(stub, proj_sprite, view_x, view_y, view_y, screen_x)
           draw_sprite(visible)
         end
 
-        # Render explosions (frames B, C, D - all rotation 0)
+        # Render explosions at projectile height
         @combat.explosions.each do |expl|
           view_x, view_y = transform_point(expl[:x], expl[:y])
           next if view_y <= 0
+
           elapsed = (@combat.instance_variable_get(:@tic) - expl[:tic])
           frame_idx = (elapsed / 4).clamp(0, 2)
-          frame_letter = %w[B C D][frame_idx]
-          expl_sprite = @sprites.send(:load_sprite_frame, 'MISL', frame_letter, 0)
+
+          prefix = expl[:sprite] || 'MISL'
+          frame_letter = prefix == 'MISL' ? %w[B C D][frame_idx] : %w[C D E][frame_idx]
+
+          expl_sprite = @sprites.send(:load_sprite_frame, prefix, frame_letter, 0)
           next unless expl_sprite
+
           screen_x = HALF_WIDTH + (view_x * @projection / view_y)
-          thing_stub = Map::Thing.new(expl[:x], expl[:y], 0, 0, 0)
-          visible = VisibleSprite.new(thing_stub, expl_sprite, view_x, view_y, view_y, screen_x)
+          expl_z = expl[:z] || @player_z
+          stub = ProjectileStub.new(expl[:x], expl[:y], 0, 0, 0, expl_z)
+          visible = VisibleSprite.new(stub, expl_sprite, view_x, view_y, view_y, screen_x)
+          draw_sprite(visible)
+        end
+      end
+
+      def render_puffs
+        @combat.puffs.each do |puff|
+          view_x, view_y = transform_point(puff[:x], puff[:y])
+          next if view_y <= 0
+
+          elapsed = @combat.instance_variable_get(:@tic) - puff[:tic]
+          frame_idx = (elapsed / 3).clamp(0, 3)
+          frame_letter = %w[A B C D][frame_idx]
+          puff_sprite = @sprites.send(:load_sprite_frame, 'PUFF', frame_letter, 0)
+          next unless puff_sprite
+
+          screen_x = HALF_WIDTH + (view_x * @projection / view_y)
+          stub = ProjectileStub.new(puff[:x], puff[:y], 0, 0, 0, puff[:z])
+          visible = VisibleSprite.new(stub, puff_sprite, view_x, view_y, view_y, screen_x)
           draw_sprite(visible)
         end
       end
@@ -1400,7 +1736,7 @@ module Doom
         light = calculate_light(light_level, dist)
 
         # Sprite screen bounds
-        sprite_left = (screen_x - sprite.left_offset * sprite_scale).to_i
+        sprite_left = (screen_x - (sprite.left_offset * sprite_scale)).to_i
         sprite_right = sprite_left + sprite_screen_width - 1
 
         # Clamp to screen
@@ -1408,14 +1744,26 @@ module Doom
         x2 = [sprite_right, SCREEN_WIDTH - 1].min
         return if x1 > x2
 
-        # Calculate sprite world Z positions
+        # Calculate sprite world Z positions (matching Chocolate Doom R_ProjectSprite)
+        # gzt = mobj->z + spritetopoffset (top of sprite)
+        # gz = gzt - spriteheight (bottom of sprite, 1:1 pixel:unit)
         thing_floor = sector ? sector.floor_height : 0
-        sprite_gz = thing_floor  # bottom of sprite in world Z
-        sprite_gzt = thing_floor + sprite.top_offset  # top of sprite in world Z
-
-        # Initialize per-column clip arrays (-2 = not yet clipped)
-        clipbot = Array.new(SCREEN_WIDTH, -2)
-        cliptop = Array.new(SCREEN_WIDTH, -2)
+        base_z = if thing.is_a?(ProjectileStub) && thing.z
+                   thing.z
+                 else
+                   thing_floor
+                 end
+        sprite_gzt = base_z + sprite.top_offset
+        sprite_gz = sprite_gzt - sprite.height
+
+        # Reuse per-frame clip buffers (-2 = not yet clipped). Only reset the
+        # range we'll touch ([x1, x2]); leftover values past x2 are ignored.
+        clipbot = @sprite_clipbot
+        cliptop = @sprite_cliptop
+        x1.upto(x2) do |i|
+          clipbot[i] = -2
+          cliptop[i] = -2
+        end
 
         # Scan drawsegs from back to front for obscuring segs
         @drawsegs.reverse_each do |ds|
@@ -1447,26 +1795,22 @@ module Doom
           silhouette = ds.silhouette
 
           # If sprite bottom is at or above the bottom silhouette height, don't clip bottom
-          if sprite_gz >= ds.bsilheight
-            silhouette &= ~SIL_BOTTOM
-          end
+          silhouette &= ~SIL_BOTTOM if sprite_gz >= ds.bsilheight
 
           # If sprite top is at or below the top silhouette height, don't clip top
-          if sprite_gzt <= ds.tsilheight
-            silhouette &= ~SIL_TOP
-          end
+          silhouette &= ~SIL_TOP if sprite_gzt <= ds.tsilheight
 
           # Apply clipping for each column in the overlap
           (r1..r2).each do |x|
             # Index into drawseg's clip arrays (0-based from ds.x1)
             ds_idx = x - ds.x1
 
-            if (silhouette & SIL_BOTTOM) != 0 && clipbot[x] == -2
-              clipbot[x] = ds.sprbottomclip[ds_idx] if ds.sprbottomclip && ds_idx < ds.sprbottomclip.length
+            if (silhouette & SIL_BOTTOM) != 0 && clipbot[x] == -2 && ds.sprbottomclip && ds_idx < ds.sprbottomclip.length
+              clipbot[x] = ds.sprbottomclip[ds_idx]
             end
 
-            if (silhouette & SIL_TOP) != 0 && cliptop[x] == -2
-              cliptop[x] = ds.sprtopclip[ds_idx] if ds.sprtopclip && ds_idx < ds.sprtopclip.length
+            if (silhouette & SIL_TOP) != 0 && cliptop[x] == -2 && ds.sprtopclip && ds_idx < ds.sprtopclip.length
+              cliptop[x] = ds.sprtopclip[ds_idx]
             end
           end
         end
@@ -1477,11 +1821,21 @@ module Doom
           cliptop[x] = -1 if cliptop[x] == -2
         end
 
+        # The native wall pass emits no drawsegs (the silhouette bookkeeping is
+        # not ported), so the drawseg loop above clipped nothing and sprites
+        # would draw over the walls in front of them. Occlude, per column, any
+        # sprite that sits behind the nearest solid wall recorded by the wall
+        # pass -- the common case (a monster behind a wall or the far background).
+        if @native_kernel
+          swd = @sprite_wall_depth
+          (x1..x2).each { |x| cliptop[x] = SCREEN_HEIGHT if swd[x] < dist }
+        end
+
         # Calculate sprite screen Y positions
         sprite_top_world = sprite_gzt - @player_z
         sprite_bottom_world = sprite_gz - @player_z
-        sprite_top_screen = (HALF_HEIGHT - sprite_top_world * sprite_scale).to_i
-        sprite_bottom_screen = (HALF_HEIGHT - sprite_bottom_world * sprite_scale).to_i
+        sprite_top_screen = (HALF_HEIGHT - (sprite_top_world * sprite_scale)).to_i
+        sprite_bottom_screen = (HALF_HEIGHT - (sprite_bottom_world * sprite_scale)).to_i
 
         # Cache for inner loop
         framebuffer = @framebuffer
@@ -1519,7 +1873,7 @@ module Doom
             next unless color
 
             # Apply lighting and write directly to framebuffer
-            framebuffer[y * SCREEN_WIDTH + x] = cmap[color]
+            framebuffer[(y * SCREEN_WIDTH) + x] = cmap[color]
           end
         end
       end