doom 0.8.0 → 0.11.0

data/lib/doom/render/renderer.rb

@@ -19,11 +19,11 @@ module Doom
     Drawseg = Struct.new(:x1, :x2, :scale1, :scale2, :scalestep,
                          :silhouette, :bsilheight, :tsilheight,
                          :sprtopclip, :sprbottomclip,
-                         :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
+                         :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
@@ -43,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
@@ -55,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)
 
@@ -77,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)
@@ -89,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)
@@ -108,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
@@ -128,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
@@ -143,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
@@ -153,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|
@@ -192,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
@@ -200,54 +219,61 @@ 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)
@@ -258,6 +284,38 @@ module Doom
         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)
       # Cached: only recomputes sin/cos when player angle changes
       def precompute_column_data
@@ -273,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
 
@@ -297,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|
@@ -305,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
@@ -316,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)
@@ -333,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
@@ -381,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
@@ -394,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
@@ -431,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
@@ -479,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
@@ -555,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)
@@ -568,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
@@ -595,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
@@ -686,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
 
@@ -715,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|
@@ -768,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
@@ -816,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
@@ -828,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
@@ -882,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
 
@@ -949,22 +1009,18 @@ module Doom
         end
 
         # Check planes for this seg range (R_CheckPlane equivalent)
-        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)
-        end
+        @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
@@ -972,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
@@ -994,176 +1050,19 @@ 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
-
-            # 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
-
-            # 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
-
-            # 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
-
-            # 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
-
-            # Store masked texture column for deferred rendering (grates, bars)
-            if @current_masked_cols
-              @current_masked_cols[x - x1] = tex_col
-            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
-
-              # 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
+            draw_two_sided_seg_column(x, x1, ceil_y, floor_y, scale, dist, tex_col,
+                                      sector, back_sector, sidedef, linedef)
           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
-
-            # 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
-
-            # 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)
-
-            # 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
+            draw_one_sided_seg_column(x, ceil_y, floor_y, scale, dist, tex_col,
+                                      sector, sidedef, linedef)
           end
         end
 
@@ -1171,7 +1070,7 @@ module Doom
         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
+          scalestep = x2 > x1 ? (scale2 - scale1) / (x2 - x1) : 0
 
           drawseg = Drawseg.new(
             x1, x2,
@@ -1189,127 +1088,173 @@ module Doom
         @current_masked_cols = nil
       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)
-        return if y1 > y2
-        return if texture_name.nil? || texture_name.empty? || texture_name == '-'
-
-        # Clip to visible range (ceiling_clip/floor_clip)
-        clip_top = @ceiling_clip[x] + 1
-        clip_bottom = @floor_clip[x] - 1
-        y1 = [y1, clip_top].max
-        y2 = [y2, clip_bottom].min
-        return if y1 > y2
-
-        texture = @textures[anim_texture(texture_name)]
-        return unless texture
-
-        light = calculate_light(light_level, dist)
-        cmap = @colormap.maps[light]
-        framebuffer = @framebuffer
-        tex_width = texture.width
-        tex_height = texture.height
-
-        # Texture X coordinate (wrap around texture width)
-        tex_x = tex_col.to_i % tex_width
+      # 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
 
-        # Get the column of pixels
-        column = texture.column_pixels(tex_x)
-        return unless column
+        # 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
 
-        # Texture step per screen pixel
-        tex_step = 1.0 / scale
+        # 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
 
-        # Calculate where the unclipped wall top would be on screen
-        unclipped_y1 = HALF_HEIGHT - (world_top - @player_z) * scale
+        # 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)
+        end
 
-        # Adjust tex_y_start for any clipping at the top
-        tex_y_at_y1 = tex_y_start + (y1 - unclipped_y1) * tex_step
+        # 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
 
-        # Clamp to screen bounds
-        y1 = 0 if y1 < 0
-        y2 = SCREEN_HEIGHT - 1 if y2 >= SCREEN_HEIGHT
+        # Store masked texture column for deferred rendering (grates, bars)
+        @current_masked_cols[x - x1] = tex_col if @current_masked_cols
 
-        # Draw wall column using while loop
-        y = y1
-        while y <= y2
-          screen_offset = y - y1
-          tex_y = (tex_y_at_y1 + screen_offset * tex_step).to_i % tex_height
+        # 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
 
-          color = column[tex_y]
-          framebuffer[y * SCREEN_WIDTH + x] = cmap[color] if color
-          y += 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
 
-      # Cache which textures have transparent pixels
-      def texture_has_transparency?(texture)
-        @transparency_cache ||= {}
-        name = texture.name
-        return @transparency_cache[name] if @transparency_cache.key?(name)
-        @transparency_cache[name] = texture.width.times.any? do |x|
-          col = texture.column_pixels(x)
-          col&.any?(&:nil?)
+      # 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
-      end
 
-      # Draw a deferred masked column using per-drawseg clip values saved at BSP time
-      def draw_wall_column_masked_deferred(md)
-        x = md[:x]
-        tex_name = md[:tex]
-        return if tex_name.nil? || tex_name.empty? || tex_name == '-'
-
-        # Use saved clips (from BSP time, before far walls closed them)
-        # AND final sprite clips (to prevent far grates drawing over near walls)
-        # Take the tightest combination of both
-        y1 = [md[:clip_top] + 1, @sprite_ceiling_clip[x] + 1, md[:y1]].max
-        y2 = [md[:clip_bottom] - 1, @sprite_floor_clip[x] - 1, md[:y2]].min
-        return if y1 > y2
-
-        # Depth test: far grate behind a near solid wall
-        return if md[:dist] > @sprite_wall_depth[x]
-
-        texture = @textures[anim_texture(tex_name)]
-        return unless texture
-
-        light = calculate_light(md[:light], md[:dist])
-        cmap = @colormap.maps[light]
-        framebuffer = @framebuffer
-        tex_width = texture.width
-        tex_height = texture.height
-
-        tex_x = md[:tex_col].to_i % tex_width
-        column = texture.column_pixels(tex_x)
-        return unless column
+        # 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
 
-        scale = md[:scale]
-        tex_step = 1.0 / scale
-        unclipped_y1 = HALF_HEIGHT - (md[:world_top] - @player_z) * scale
-        tex_y_at_y1 = md[:tex_y] + (y1 - unclipped_y1) * tex_step
+        # 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)
 
-        y1 = 0 if y1 < 0
-        y2 = SCREEN_HEIGHT - 1 if y2 >= SCREEN_HEIGHT
+        # Track wall depth for sprite clipping (solid wall occludes this column)
+        @wall_depth[x] = [@wall_depth[x], dist].min
 
-        y = y1
-        while y <= y2
-          screen_offset = y - y1
-          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] if color
-          y += 1
-        end
+        # Fully occluded
+        @ceiling_clip[x] = SCREEN_HEIGHT
+        @floor_clip[x] = -1
       end
 
-      # Draw a masked (transparent) wall column for middle textures on two-sided linedefs.
-      # Unlike draw_wall_column_ex, skips nil pixels (transparent areas).
-      def draw_wall_column_masked(x, y1, y2, texture_name, dist, light_level, tex_col, tex_y_start, scale, world_top)
+      # 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 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 == '-'
 
+        # Clip to visible range (ceiling_clip/floor_clip)
         clip_top = @ceiling_clip[x] + 1
         clip_bottom = @floor_clip[x] - 1
         y1 = [y1, clip_top].max
@@ -1325,26 +1270,34 @@ module Doom
         tex_width = texture.width
         tex_height = texture.height
 
+        # Texture X coordinate (wrap around texture width)
         tex_x = tex_col.to_i % tex_width
+
+        # Get the column of pixels
         column = texture.column_pixels(tex_x)
         return unless column
 
+        # Texture step per screen pixel
         tex_step = 1.0 / scale
-        unclipped_y1 = HALF_HEIGHT - (world_top - @player_z) * scale
-        tex_y_at_y1 = tex_y_start + (y1 - unclipped_y1) * tex_step
 
+        # Calculate where the unclipped wall top would be on screen
+        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)
+
+        # Clamp to screen bounds
         y1 = 0 if y1 < 0
         y2 = SCREEN_HEIGHT - 1 if y2 >= SCREEN_HEIGHT
 
+        # Draw wall column using while loop
         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]
-          # Skip transparent pixels (nil in patch data)
-          if color
-            framebuffer[y * SCREEN_WIDTH + x] = cmap[color]
-          end
+          framebuffer[(y * SCREEN_WIDTH) + x] = cmap[color] if color
           y += 1
         end
       end
@@ -1442,7 +1395,7 @@ 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
+            next unless sprite # Barrel disappeared after explosion
           elsif @monster_ai
             mon = @monster_ai.monster_by_thing_idx[thing_idx]
             if mon && mon.active
@@ -1477,6 +1430,8 @@ 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 }
 
@@ -1488,14 +1443,15 @@ module Doom
         # 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, explosions, and bullet puffs
-        if @combat
-          render_projectiles
-          render_puffs
-        end
+        return unless @combat
+
+        render_projectiles
+        render_puffs
       end
 
       # Chocolate Doom R_DrawMasked: interleave sprites with masked drawsegs
@@ -1503,6 +1459,60 @@ module Doom
         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
@@ -1513,18 +1523,18 @@ module Doom
           next if ds.silhouette == SIL_NONE && ds.maskedtexturecol.nil?
 
           ds_max_scale = [ds.scale1, ds.scale2].max
-          ds_min_scale = [ds.scale1, ds.scale2].min
+          [ds.scale1, ds.scale2].min
 
           # Is the drawseg behind the sprite?
-          if 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
+          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)
@@ -1566,22 +1576,23 @@ module Doom
           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
+          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
+            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
+          sprtopscreen = HALF_HEIGHT - (dc_texturemid * spryscale)
 
           # Get clip bounds from drawseg
           clip_idx = x - ds.x1
@@ -1604,23 +1615,23 @@ module Doom
           (0..tex_height).each do |ty|
             color = ty < tex_height ? column[ty] : nil
             if color
-              y_start = ty unless y_start
+              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 = (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
+                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)
+                  t = (tex_frac.to_i % tex_height)
                   c = column[t]
-                  @framebuffer[y * SCREEN_WIDTH + x] = cmap[c] if c
+                  @framebuffer[(y * SCREEN_WIDTH) + x] = cmap[c] if c
                   tex_frac += iscale
                   y += 1
                 end
@@ -1649,7 +1660,7 @@ module Doom
           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
+          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]
@@ -1668,14 +1679,16 @@ module Doom
         @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)
 
           prefix = expl[:sprite] || 'MISL'
-          frame_letter = (prefix == 'MISL') ? %w[B C D][frame_idx] : %w[C D E][frame_idx]
+          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)
           expl_z = expl[:z] || @player_z
           stub = ProjectileStub.new(expl[:x], expl[:y], 0, 0, 0, expl_z)
@@ -1688,11 +1701,13 @@ module Doom
         @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)
@@ -1721,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
@@ -1733,17 +1748,22 @@ module Doom
         # gzt = mobj->z + spritetopoffset (top of sprite)
         # gz = gzt - spriteheight (bottom of sprite, 1:1 pixel:unit)
         thing_floor = sector ? sector.floor_height : 0
-        if thing.is_a?(ProjectileStub) && thing.z
-          base_z = thing.z
-        else
-          base_z = thing_floor
-        end
+        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
 
-        # Initialize per-column clip arrays (-2 = not yet clipped)
-        clipbot = Array.new(SCREEN_WIDTH, -2)
-        cliptop = Array.new(SCREEN_WIDTH, -2)
+        # 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|
@@ -1775,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
@@ -1805,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
@@ -1847,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