doom 0.3.0 → 0.5.0

data/lib/doom/render/renderer.rb

@@ -18,7 +18,12 @@ module Doom
     # Matches Chocolate Doom's drawseg_t structure
     Drawseg = Struct.new(:x1, :x2, :scale1, :scale2,
                          :silhouette, :bsilheight, :tsilheight,
-                         :sprtopclip, :sprbottomclip)
+                         :sprtopclip, :sprbottomclip,
+                         :curline)  # seg for point-on-side test
+
+    # VisibleSprite stores sprite data for sorting and rendering
+    # Struct is faster than Hash for fixed-field data
+    VisibleSprite = Struct.new(:thing, :sprite, :view_x, :view_y, :dist, :screen_x)
 
     # Visplane stores floor/ceiling rendering info for a sector
     # Matches Chocolate Doom's visplane_t structure from r_plane.c
@@ -48,7 +53,7 @@ module Doom
     class Renderer
       attr_reader :framebuffer
 
-      def initialize(wad, map, textures, palette, colormap, flats, sprites = nil)
+      def initialize(wad, map, textures, palette, colormap, flats, sprites = nil, animations = nil)
         @wad = wad
         @map = map
         @textures = textures
@@ -56,6 +61,9 @@ module Doom
         @colormap = colormap
         @flats = flats.to_h { |f| [f.name, f] }
         @sprites = sprites
+        @animations = animations
+        @hidden_things = nil
+        @combat = nil
 
         @framebuffer = Array.new(SCREEN_WIDTH * SCREEN_HEIGHT, 0)
 
@@ -67,6 +75,17 @@ module Doom
         # Projection constant - distance to projection plane
         @projection = HALF_WIDTH / Math.tan(FOV * Math::PI / 360.0)
 
+        # Precomputed column data (cached based on player angle)
+        @column_cos = Array.new(SCREEN_WIDTH)
+        @column_sin = Array.new(SCREEN_WIDTH)
+        @cached_player_angle = nil
+
+        # Column distance scale is constant (doesn't depend on player angle)
+        @column_distscale = Array.new(SCREEN_WIDTH) do |x|
+          dx = x - HALF_WIDTH
+          Math.sqrt(dx * dx + @projection * @projection) / @projection
+        end
+
         # Clipping arrays
         @ceiling_clip = Array.new(SCREEN_WIDTH, -1)
         @floor_clip = Array.new(SCREEN_WIDTH, SCREEN_HEIGHT)
@@ -77,9 +96,103 @@ module Doom
 
         # Wall depth array - tracks distance to nearest wall at each column
         @wall_depth = Array.new(SCREEN_WIDTH, Float::INFINITY)
+        @sprite_wall_depth = Array.new(SCREEN_WIDTH, Float::INFINITY)
+
+        # Preallocated y_slope arrays for floor/ceiling rendering (avoids per-frame allocation)
+        @y_slope_ceil = Array.new(HALF_HEIGHT + 1, 0.0)
+        @y_slope_floor = Array.new(HALF_HEIGHT + 1, 0.0)
       end
 
-      attr_reader :player_x, :player_y, :player_z, :sin_angle, :cos_angle
+      attr_reader :player_x, :player_y, :player_z, :sin_angle, :cos_angle, :framebuffer
+      attr_writer :hidden_things, :combat
+
+      # Diagnostic: returns info about all sprites and why they are/aren't visible
+      def sprite_diagnostics
+        return [] unless @sprites
+
+        results = []
+        @map.things.each do |thing|
+          prefix = @sprites.prefix_for(thing.type)
+          next unless prefix
+
+          info = { type: thing.type, x: thing.x, y: thing.y, prefix: prefix }
+
+          view_x, view_y = transform_point(thing.x, thing.y)
+          info[:view_x] = view_x.round(1)
+          info[:view_y] = view_y.round(1)
+
+          if view_y <= 0
+            info[:status] = "behind_player"
+            results << info
+            next
+          end
+
+          dist = view_y
+          screen_x = HALF_WIDTH + (view_x * @projection / view_y)
+          info[:screen_x] = screen_x.round(1)
+          info[:dist] = dist.round(1)
+
+          dx = thing.x - @player_x
+          dy = thing.y - @player_y
+          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"
+            results << info
+            next
+          end
+
+          sprite_scale = @projection / dist
+          sprite_half_width = (sprite.width * @projection / dist / 2).to_i
+          info[:sprite_scale] = sprite_scale.round(3)
+
+          if screen_x + sprite_half_width < 0
+            info[:status] = "off_screen_left"
+          elsif screen_x - sprite_half_width >= SCREEN_WIDTH
+            info[:status] = "off_screen_right"
+          else
+            # Check drawseg clipping
+            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
+
+            clipping_segs = []
+            @drawsegs.reverse_each do |ds|
+              next if ds.x1 > x2 || ds.x2 < x1
+              next if ds.silhouette == SIL_NONE
+
+              lowscale = [ds.scale1, ds.scale2].min
+              highscale = [ds.scale1, ds.scale2].max
+
+              if highscale < sprite_scale
+                next
+              elsif lowscale < sprite_scale
+                next unless point_on_seg_side(thing.x, thing.y, ds.curline)
+              end
+
+              clipping_segs << {
+                x1: ds.x1, x2: ds.x2,
+                scale: "#{ds.scale1.round(3)}..#{ds.scale2.round(3)}",
+                sil: ds.silhouette
+              }
+            end
+
+            info[:screen_range] = "#{x1}..#{x2}"
+            info[:clipping_segs] = clipping_segs.size
+            info[:clipping_detail] = clipping_segs
+            info[:status] = "visible"
+          end
+
+          results << info
+        end
+        results
+      end
 
       def set_player(x, y, z, angle)
         @player_x = x.to_f
@@ -111,11 +224,15 @@ module Doom
         # Precompute column angles for floor/ceiling rendering
         precompute_column_data
 
-        # Draw floor/ceiling background first (will be partially overwritten by walls)
+        # 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 drawsegs for sprite clipping
         @drawsegs = []
@@ -126,27 +243,26 @@ module Doom
         # Draw visplanes for sectors different from background
         draw_all_visplanes
 
-        # Save wall clip arrays for sprite clipping
-        @sprite_ceiling_clip = @ceiling_clip.dup
-        @sprite_floor_clip = @floor_clip.dup
-        @sprite_wall_depth = @wall_depth.dup
+        # Save wall clip arrays for sprite clipping (reuse preallocated arrays)
+        @sprite_ceiling_clip.replace(@ceiling_clip)
+        @sprite_floor_clip.replace(@floor_clip)
+        @sprite_wall_depth.replace(@wall_depth)
 
         # Render sprites
         render_sprites if @sprites
       end
 
       # Precompute column-based data for floor/ceiling rendering (R_InitLightTables-like)
+      # Cached: only recomputes sin/cos when player angle changes
       def precompute_column_data
-        @column_cos ||= Array.new(SCREEN_WIDTH)
-        @column_sin ||= Array.new(SCREEN_WIDTH)
-        @column_distscale ||= Array.new(SCREEN_WIDTH)
+        return if @cached_player_angle == @player_angle
+
+        @cached_player_angle = @player_angle
 
         SCREEN_WIDTH.times do |x|
-          dx = x - HALF_WIDTH
-          column_angle = @player_angle - Math.atan2(dx, @projection)
+          column_angle = @player_angle - Math.atan2(x - HALF_WIDTH, @projection)
           @column_cos[x] = Math.cos(column_angle)
           @column_sin[x] = Math.sin(column_angle)
-          @column_distscale[x] = Math.sqrt(dx * dx + @projection * @projection) / @projection
         end
       end
 
@@ -223,7 +339,7 @@ module Doom
       def draw_span(plane, y, x1, x2)
         return if x1.nil? || x1 > x2 || y < 0 || y >= SCREEN_HEIGHT
 
-        flat = @flats[plane.texture]
+        flat = @flats[anim_flat(plane.texture)]
         return unless flat
 
         # Distance from horizon (y=100 for 200-high screen)
@@ -249,6 +365,7 @@ module Doom
         player_x = @player_x
         neg_player_y = -@player_y
         row_offset = y * SCREEN_WIDTH
+        flat_pixels = flat.pixels
 
         # Clamp to screen bounds
         x1 = 0 if x1 < 0
@@ -260,13 +377,22 @@ module Doom
           ray_dist = perp_dist * column_distscale[x]
           tex_x = (player_x + ray_dist * column_cos[x]).to_i & 63
           tex_y = (neg_player_y - ray_dist * column_sin[x]).to_i & 63
-          color = flat[tex_x, tex_y] || 0
+          color = flat_pixels[tex_y * 64 + tex_x]
           framebuffer[row_offset + x] = cmap[color]
           x += 1
         end
       end
 
       # Render sky ceiling as columns (column-based like walls, not spans)
+      # Sky texture mid-point: texel row at screen center.
+      # 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
+      # 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
+
       def draw_sky_plane(plane)
         sky_texture = @textures['SKY1']
         return unless sky_texture
@@ -290,31 +416,31 @@ module Doom
           y1 = 0 if y1 < 0
           y2 = SCREEN_HEIGHT - 1 if y2 >= SCREEN_HEIGHT
 
-          # Sky X based on view angle (wraps around 256 degrees)
+          # Sky X: 4 repetitions per 360 degrees (matching ANGLETOSKYSHIFT=22)
           column_angle = player_angle - Math.atan2(x - HALF_WIDTH, projection)
-          sky_x = ((column_angle * 256 / Math::PI).to_i & 255) % sky_width
+          sky_x = (column_angle * SKY_XSCALE).to_i % sky_width
           column = sky_texture.column_pixels(sky_x)
           next unless column
 
+          # 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|
-            color = column[y % sky_height] || 0
+            tex_y = (SKY_TEXTUREMID + (y - HALF_HEIGHT) * SKY_YSCALE).to_i % sky_height
+            color = column[tex_y]
             framebuffer[y * SCREEN_WIDTH + x] = color
           end
         end
       end
 
       def find_or_create_visplane(sector, height, texture, light_level, is_ceiling)
-        # Find existing visplane with matching properties
-        plane = @visplanes.find do |vp|
-          vp.height == height &&
-          vp.texture == texture &&
-          vp.light_level == light_level &&
-          vp.is_ceiling == is_ceiling
-        end
+        # O(1) hash lookup instead of O(n) linear search
+        key = [height, texture, light_level, is_ceiling]
+        plane = @visplane_hash[key]
 
         unless plane
           plane = Visplane.new(sector, height, texture, light_level, is_ceiling)
           @visplanes << plane
+          @visplane_hash[key] = plane
         end
 
         plane
@@ -371,6 +497,11 @@ module Doom
         new_plane.minx = start_x
         new_plane.maxx = stop_x
         @visplanes << new_plane
+
+        # Update hash to point to the new plane (for subsequent lookups)
+        key = [plane.height, plane.texture, plane.light_level, plane.is_ceiling]
+        @visplane_hash[key] = new_plane
+
         new_plane
       end
 
@@ -387,16 +518,18 @@ module Doom
 
         ceil_height = (default_sector.ceiling_height - @player_z).abs
         floor_height = (default_sector.floor_height - @player_z).abs
-        ceil_flat = @flats[default_sector.ceiling_texture]
-        floor_flat = @flats[default_sector.floor_texture]
+        ceil_flat = @flats[anim_flat(default_sector.ceiling_texture)]
+        floor_flat = @flats[anim_flat(default_sector.floor_texture)]
+        ceil_pixels = ceil_flat&.pixels
+        floor_pixels = floor_flat&.pixels
         is_sky = default_sector.ceiling_texture == 'F_SKY1'
         sky_texture = is_sky ? @textures['SKY1'] : nil
         light_level = default_sector.light_level
         colormap_maps = @colormap.maps
 
-        # Precompute y_slope for each row (perpendicular distance)
-        y_slope_ceil = Array.new(HALF_HEIGHT + 1, 0.0)
-        y_slope_floor = Array.new(HALF_HEIGHT + 1, 0.0)
+        # Compute y_slope for each row (perpendicular distance) - reuse preallocated arrays
+        y_slope_ceil = @y_slope_ceil
+        y_slope_floor = @y_slope_floor
         (1..HALF_HEIGHT).each do |dy|
           y_slope_ceil[dy] = ceil_height * projection / dy.to_f
           y_slope_floor[dy] = floor_height * projection / dy.to_f
@@ -414,14 +547,14 @@ module Doom
               row_offset = y * SCREEN_WIDTH
 
               if is_sky && sky_texture
-                sky_height = sky_texture.height
-                sky_width = sky_texture.width
-                sky_y = y % sky_height
+                sky_w = sky_texture.width
+                sky_h = sky_texture.height
+                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)
-                  sky_x = ((column_angle * 256 / Math::PI).to_i & 255) % sky_width
-                  color = sky_texture.column_pixels(sky_x)[sky_y] || 0
+                  sky_x = (column_angle * SKY_XSCALE).to_i % sky_w
+                  color = sky_texture.column_pixels(sky_x)[sky_y]
                   framebuffer[row_offset + x] = color
                   x += 1
                 end
@@ -431,7 +564,7 @@ module Doom
                   ray_dist = perp_dist * column_distscale[x]
                   tex_x = (player_x + ray_dist * column_cos[x]).to_i & 63
                   tex_y = (neg_player_y - ray_dist * column_sin[x]).to_i & 63
-                  color = ceil_flat[tex_x, tex_y] || 0
+                  color = ceil_pixels[tex_y * 64 + tex_x]
                   framebuffer[row_offset + x] = cmap[color]
                   x += 1
                 end
@@ -458,7 +591,7 @@ module Doom
                   ray_dist = perp_dist * column_distscale[x]
                   tex_x = (player_x + ray_dist * column_cos[x]).to_i & 63
                   tex_y = (neg_player_y - ray_dist * column_sin[x]).to_i & 63
-                  color = floor_flat[tex_x, tex_y] || 0
+                  color = floor_pixels[tex_y * 64 + tex_x]
                   framebuffer[row_offset + x] = cmap[color]
                   x += 1
                 end
@@ -471,6 +604,15 @@ module Doom
 
       private
 
+      # Translate flat/texture names through animation system
+      def anim_flat(name)
+        @animations ? @animations.translate_flat(name) : name
+      end
+
+      def anim_texture(name)
+        @animations ? @animations.translate_texture(name) : name
+      end
+
       def clear_framebuffer
         @framebuffer.fill(0)
       end
@@ -492,13 +634,58 @@ module Doom
 
         if side == 0
           render_bsp_node(node.child_right)
-          render_bsp_node(node.child_left)
+          back_bbox = node.bbox_left
+          render_bsp_node(node.child_left) if check_bbox(back_bbox)
         else
           render_bsp_node(node.child_left)
-          render_bsp_node(node.child_right)
+          back_bbox = node.bbox_right
+          render_bsp_node(node.child_right) if check_bbox(back_bbox)
         end
       end
 
+      # R_CheckBBox - check if a bounding box is potentially visible.
+      # Projects the bbox corners to screen columns and checks if any
+      # column in that range is not fully occluded.
+      def check_bbox(bbox)
+        # Transform all 4 corners to view space
+        near = 1.0
+        all_in_front = true
+        min_sx = SCREEN_WIDTH
+        max_sx = -1
+
+        [[bbox.left, bbox.bottom], [bbox.right, bbox.bottom],
+         [bbox.left, bbox.top], [bbox.right, bbox.top]].each do |wx, wy|
+          vx, vy = transform_point(wx, wy)
+
+          if vy < near
+            # Any corner behind the near plane - bbox is too close to cull safely
+            all_in_front = false
+          else
+            sx = HALF_WIDTH + (vx * @projection / vy)
+            sx_i = sx.to_i
+            min_sx = sx_i if sx_i < min_sx
+            max_sx = sx_i if sx_i > max_sx
+          end
+        end
+
+        # If any corner is behind the near plane, conservatively assume visible.
+        # Only cull when all 4 corners are cleanly in front and we can check occlusion.
+        return true unless all_in_front
+
+        min_sx = 0 if min_sx < 0
+        max_sx = SCREEN_WIDTH - 1 if max_sx >= SCREEN_WIDTH
+        return false if min_sx > max_sx
+
+        # Check if any column in the range is not fully occluded
+        x = min_sx
+        while x <= max_sx
+          return true if @ceiling_clip[x] < @floor_clip[x] - 1
+          x += 1
+        end
+
+        false
+      end
+
       def point_on_side(x, y, node)
         dx = x - node.x
         dy = y - node.y
@@ -641,11 +828,67 @@ module Doom
         [x, y]
       end
 
+      # Determine which side of a seg a point is on (R_PointOnSegSide from Chocolate Doom)
+      # Returns true if point is on back side, false if on front side
+      def point_on_seg_side(x, y, seg)
+        v1 = @map.vertices[seg.v1]
+        v2 = @map.vertices[seg.v2]
+
+        lx = v1.x
+        ly = v1.y
+        ldx = v2.x - lx
+        ldy = v2.y - ly
+
+        # Handle axis-aligned lines
+        if ldx == 0
+          return x <= lx ? ldy > 0 : ldy < 0
+        end
+        if ldy == 0
+          return y <= ly ? ldx < 0 : ldx > 0
+        end
+
+        dx = x - lx
+        dy = y - ly
+
+        # Cross product to determine side
+        left = ldy * dx
+        right = dy * ldx
+
+        right >= left
+      end
+
       def draw_seg_range(x1, x2, sx1, sx2, dist1, dist2, sector, back_sector, sidedef, linedef, seg, seg_length)
-        # Get seg vertices in world space for texture coordinate calculation
         seg_v1 = @map.vertices[seg.v1]
         seg_v2 = @map.vertices[seg.v2]
 
+        # Precompute ray-seg intersection coefficients for per-column texture mapping.
+        # For screen column x, the view ray direction in world space is:
+        #   ray = (sin_a * dx_col + cos_a * proj, -cos_a * dx_col + sin_a * proj)
+        # where dx_col = x - HALF_WIDTH.
+        # The ray-seg intersection parameter s (position along seg) is:
+        #   s = (E * x + F) / (A * x + B)
+        # where A, B, E, F are precomputed per-seg constants.
+        seg_dx = (seg_v2.x - seg_v1.x).to_f
+        seg_dy = (seg_v2.y - seg_v1.y).to_f
+        px = @player_x - seg_v1.x.to_f
+        py = @player_y - seg_v1.y.to_f
+        sin_a = @sin_angle
+        cos_a = @cos_angle
+        proj = @projection
+
+        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
+
+        # 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_offset = seg.offset + sidedef.x_offset
+
         # Calculate scales for drawseg (scale = projection / distance)
         scale1 = dist1 > 0 ? @projection / dist1 : Float::INFINITY
         scale2 = dist2 > 0 ? @projection / dist2 : Float::INFINITY
@@ -691,11 +934,10 @@ module Doom
         (x1..x2).each do |x|
           next if @ceiling_clip[x] >= @floor_clip[x] - 1
 
-          # Screen-space interpolation factor for distance only
+          # Screen-space interpolation for distance
           t = sx2 != sx1 ? (x - sx1) / (sx2 - sx1) : 0
           t = t.clamp(0.0, 1.0)
 
-          # Perspective-correct interpolation for distance
           if dist1 > 0 && dist2 > 0
             inv_dist = (1.0 - t) / dist1 + t / dist2
             dist = 1.0 / inv_dist
@@ -703,18 +945,15 @@ module Doom
             dist = dist1 > 0 ? dist1 : dist2
           end
 
-          # Texture column using perspective-correct interpolation
-          # tex_col_1 is texture coordinate at seg v1, tex_col_2 at v2
-          tex_col_1 = seg.offset + sidedef.x_offset
-          tex_col_2 = seg.offset + seg_length + sidedef.x_offset
-
-          # Perspective-correct interpolation: interpolate tex/z, then multiply by z
-          if dist1 > 0 && dist2 > 0
-            tex_col = ((tex_col_1 / dist1) * (1.0 - t) + (tex_col_2 / dist2) * t) / inv_dist
+          # 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
-            tex_col = tex_col_1 * (1.0 - t) + tex_col_2 * t
+            s = (tex_e * x + tex_f) / denom
           end
-          tex_col = tex_col.to_i
+          tex_col = (tex_offset + s * seg_length).to_i
 
           # Skip if too close
           next if dist < 1
@@ -727,7 +966,10 @@ module Doom
           front_ceil = sector.ceiling_height - @player_z
 
           # Project to screen Y (Y increases downward on screen)
-          front_ceil_y = (HALF_HEIGHT - front_ceil * scale).to_i
+          # 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
 
           # Clamp to current clip bounds
@@ -739,8 +981,11 @@ module Doom
             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).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)
@@ -748,12 +993,35 @@ module Doom
             high_ceil = [ceil_y, back_ceil_y].max
             low_floor = [floor_y, back_floor_y].min
 
-            # Mark ceiling visplane - mark front sector's ceiling for two-sided lines
-            # Matches Chocolate Doom: mark from ceilingclip+1 to yl-1 (front ceiling)
-            # (yl is clamped to ceilingclip+1, so we use ceil_y which is already clamped)
-            should_mark_ceiling = sector.ceiling_height != back_sector.ceiling_height ||
-                                  sector.ceiling_texture != back_sector.ceiling_texture ||
+            # 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
@@ -763,12 +1031,7 @@ module Doom
               end
             end
 
-            # Mark floor visplane - mark front sector's floor for two-sided lines
-            # Matches Chocolate Doom: mark from yh+1 (front floor) to floorclip-1
-            # (yh is clamped to floorclip-1, so we use floor_y which is already clamped)
-            should_mark_floor = sector.floor_height != back_sector.floor_height ||
-                                sector.floor_texture != back_sector.floor_texture ||
-                                sector.light_level != back_sector.light_level
+            # Mark floor visplane
             if @current_floor_plane && should_mark_floor
               mark_top = floor_y + 1
               mark_bottom = @floor_clip[x] - 1
@@ -778,11 +1041,8 @@ module Doom
               end
             end
 
-            # Upper wall (ceiling step down)
-            if sector.ceiling_height > back_sector.ceiling_height
-              # Upper texture Y offset depends on DONTPEGTOP flag
-              # With DONTPEGTOP: texture top aligns with front ceiling
-              # Without: texture bottom aligns with back ceiling (for doors opening)
+            # 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
@@ -790,63 +1050,68 @@ module Doom
                 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 - 1, sidedef.upper_texture, dist,
+              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)
-              # Note: Upper walls don't fully occlude - sprites can be visible through openings
             end
 
             # Lower wall (floor step up)
             if sector.floor_height < back_sector.floor_height
-              # Lower texture Y offset depends on DONTPEGBOTTOM flag
-              # With DONTPEGBOTTOM: texture bottom aligns with lower floor
-              # Without: texture top aligns with higher floor
               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 + 1, floor_y, sidedef.lower_texture, dist,
+              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)
-              # Note: Lower walls don't fully occlude - sprites can be visible through openings
             end
 
-            # Update clip bounds after marking
-            # Ceiling clip increases (moves down) as ceiling is marked
-            if sector.ceiling_height > back_sector.ceiling_height
-              # Upper wall drawn - clip ceiling to back ceiling
-              @ceiling_clip[x] = [back_ceil_y, @ceiling_clip[x]].max
-            elsif sector.ceiling_height < back_sector.ceiling_height
-              # Ceiling step up - clip to front ceiling
-              @ceiling_clip[x] = [ceil_y, @ceiling_clip[x]].max
-            elsif should_mark_ceiling
-              # Same height but different texture/light - still update clip
-              # Matches Chocolate Doom: if (markceiling) ceilingclip[rw_x] = yl-1;
-              @ceiling_clip[x] = [ceil_y - 1, @ceiling_clip[x]].max
-            end
+            # 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 decreases (moves up) as floor is marked
-            if sector.floor_height < back_sector.floor_height
-              # Lower wall drawn - clip floor to back floor
-              @floor_clip[x] = [back_floor_y, @floor_clip[x]].min
-            elsif sector.floor_height > back_sector.floor_height
-              # Floor step down - clip to front floor to allow back sector to mark later
-              @floor_clip[x] = [floor_y, @floor_clip[x]].min
-            elsif should_mark_floor
-              # Same height but different texture/light - still update clip
-              # Matches Chocolate Doom: if (markfloor) floorclip[rw_x] = yh+1;
-              @floor_clip[x] = [floor_y + 1, @floor_clip[x]].min
+              # Floor clip
+              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
           else
             # One-sided (solid) wall
             # Mark ceiling visplane (from previous clip to wall's ceiling)
-            if @current_ceiling_plane && @ceiling_clip[x] + 1 <= ceil_y - 1
-              @current_ceiling_plane.mark(x, @ceiling_clip[x] + 1, ceil_y - 1)
+            # 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)
-            # Floor is visible BELOW the wall (from floor_y+1 to floor_clip-1)
-            if @current_floor_plane && floor_y + 1 <= @floor_clip[x] - 1
-              @current_floor_plane.mark(x, floor_y + 1, @floor_clip[x] - 1)
+            # 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)
@@ -883,7 +1148,8 @@ module Doom
             scale1, scale2,
             silhouette,
             bsilheight, tsilheight,
-            sprtopclip, sprbottomclip
+            sprtopclip, sprbottomclip,
+            seg
           )
           @drawsegs << drawseg
         end
@@ -905,7 +1171,7 @@ module Doom
         y2 = [y2, clip_bottom].min
         return if y1 > y2
 
-        texture = @textures[texture_name]
+        texture = @textures[anim_texture(texture_name)]
         return unless texture
 
         light = calculate_light(light_level, dist)
@@ -916,7 +1182,6 @@ module Doom
 
         # Texture X coordinate (wrap around texture width)
         tex_x = tex_col.to_i % tex_width
-        tex_x += tex_width if tex_x < 0
 
         # Get the column of pixels
         column = texture.column_pixels(tex_x)
@@ -940,9 +1205,8 @@ module Doom
         while y <= y2
           screen_offset = y - y1
           tex_y = (tex_y_at_y1 + screen_offset * tex_step).to_i % tex_height
-          tex_y += tex_height if tex_y < 0
 
-          color = column[tex_y] || 0
+          color = column[tex_y]
           framebuffer[y * SCREEN_WIDTH + x] = cmap[color]
           y += 1
         end
@@ -1017,7 +1281,10 @@ module Doom
         # Collect visible sprites with their distances
         visible_sprites = []
 
-        @map.things.each do |thing|
+        @map.things.each_with_index do |thing, thing_idx|
+          # Skip picked-up items
+          next if @hidden_things && @hidden_things[thing_idx]
+
           # Check if we have a sprite for this thing type
           next unless @sprites.prefix_for(thing.type)
 
@@ -1035,8 +1302,12 @@ module Doom
           dy = thing.y - @player_y
           angle_to_thing = Math.atan2(dy, dx)
 
-          # Get the correct rotated sprite
-          sprite = @sprites.get_rotated(thing.type, angle_to_thing, thing.angle)
+          # Get sprite - use death frame if monster is dead
+          if @combat && @combat.dead?(thing_idx)
+            sprite = @combat.death_sprite(thing_idx, thing.type, angle_to_thing, thing.angle)
+          else
+            sprite = @sprites.get_rotated(thing.type, angle_to_thing, thing.angle)
+          end
           next unless sprite
 
           # Project to screen X
@@ -1047,18 +1318,11 @@ module Doom
           next if screen_x + sprite_half_width < 0
           next if screen_x - sprite_half_width >= SCREEN_WIDTH
 
-          visible_sprites << {
-            thing: thing,
-            sprite: sprite,
-            view_x: view_x,
-            view_y: view_y,
-            dist: dist,
-            screen_x: screen_x
-          }
+          visible_sprites << VisibleSprite.new(thing, sprite, view_x, view_y, dist, screen_x)
         end
 
         # Sort by distance (back to front for proper overdraw)
-        visible_sprites.sort_by! { |s| -s[:dist] }
+        visible_sprites.sort_by! { |s| -s.dist }
 
         # Draw each sprite
         visible_sprites.each do |vs|
@@ -1067,10 +1331,10 @@ module Doom
       end
 
       def draw_sprite(vs)
-        sprite = vs[:sprite]
-        dist = vs[:dist]
-        screen_x = vs[:screen_x]
-        thing = vs[:thing]
+        sprite = vs.sprite
+        dist = vs.dist
+        screen_x = vs.screen_x
+        thing = vs.thing
 
         # Calculate scale (inverse of distance, used for depth comparison)
         sprite_scale = @projection / dist
@@ -1120,12 +1384,14 @@ module Doom
           lowscale = [ds.scale1, ds.scale2].min
           highscale = [ds.scale1, ds.scale2].max
 
-          # If drawseg is behind sprite, skip (seg must be closer to clip)
+          # Chocolate Doom logic: skip if seg is behind sprite
+          # If highscale < sprite_scale: wall entirely behind sprite
+          # OR if lowscale < sprite_scale AND sprite is on front side of wall
           if highscale < sprite_scale
             next
           elsif lowscale < sprite_scale
-            # Seg partially overlaps in depth - would need point-on-seg test
-            # For simplicity, we'll clip if any part of seg is closer
+            # Partial overlap - check if sprite is in front of the seg
+            next unless point_on_seg_side(thing.x, thing.y, ds.curline)
           end
 
           # Determine which silhouettes apply based on sprite Z
@@ -1208,11 +1474,6 @@ module Doom
           end
         end
       end
-
-      def set_pixel(x, y, color)
-        return if x < 0 || x >= SCREEN_WIDTH || y < 0 || y >= SCREEN_HEIGHT
-        @framebuffer[y * SCREEN_WIDTH + x] = color
-      end
     end
   end
 end