doom 0.4.0 → 0.6.0

data/lib/doom/render/renderer.rb

@@ -53,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
@@ -61,6 +61,11 @@ module Doom
         @colormap = colormap
         @flats = flats.to_h { |f| [f.name, f] }
         @sprites = sprites
+        @animations = animations
+        @hidden_things = nil
+        @combat = nil
+        @monster_ai = nil
+        @leveltime = 0
 
         @framebuffer = Array.new(SCREEN_WIDTH * SCREEN_HEIGHT, 0)
 
@@ -100,7 +105,96 @@ module Doom
         @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, :monster_ai, :leveltime
+
+      # 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
@@ -132,7 +226,10 @@ 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
@@ -244,7 +341,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)
@@ -270,6 +367,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
@@ -281,13 +379,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]
+          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
@@ -295,8 +402,8 @@ module Doom
         framebuffer = @framebuffer
         player_angle = @player_angle
         projection = @projection
-        sky_width_mask = sky_texture.width - 1    # Power-of-2 textures: & is faster than %
-        sky_height_mask = sky_texture.height - 1
+        sky_width = sky_texture.width
+        sky_height = sky_texture.height
 
         # Clamp to screen bounds
         minx = [plane.minx, 0].max
@@ -311,14 +418,17 @@ 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 & sky_width_mask
+          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_mask]
+            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
@@ -410,8 +520,10 @@ 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
@@ -437,13 +549,13 @@ module Doom
               row_offset = y * SCREEN_WIDTH
 
               if is_sky && sky_texture
-                sky_height_mask = sky_texture.height - 1
-                sky_width_mask = sky_texture.width - 1
-                sky_y = y & sky_height_mask
+                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 & sky_width_mask
+                  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
@@ -454,7 +566,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]
+                  color = ceil_pixels[tex_y * 64 + tex_x]
                   framebuffer[row_offset + x] = cmap[color]
                   x += 1
                 end
@@ -481,7 +593,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]
+                  color = floor_pixels[tex_y * 64 + tex_x]
                   framebuffer[row_offset + x] = cmap[color]
                   x += 1
                 end
@@ -494,6 +606,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
@@ -515,11 +636,56 @@ 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)
@@ -694,10 +860,37 @@ module Doom
       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
@@ -743,11 +936,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
@@ -755,18 +947,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
@@ -779,7 +968,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
@@ -791,8 +983,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)
@@ -806,12 +1001,29 @@ module Doom
             closed_door = back_sector.ceiling_height <= sector.floor_height ||
                           back_sector.floor_height >= sector.ceiling_height
 
-            # Mark ceiling visplane - mark front sector's ceiling for two-sided lines
-            # Matches Chocolate Doom: mark from ceilingclip+1 to yl-1 (front ceiling)
-            # (yl is clamped to ceilingclip+1, so we use ceil_y which is already clamped)
-            should_mark_ceiling = sector.ceiling_height != back_sector.ceiling_height ||
-                                  sector.ceiling_texture != back_sector.ceiling_texture ||
+            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
@@ -821,12 +1033,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
@@ -836,11 +1043,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
@@ -848,70 +1052,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
+            # Update clip bounds
             if closed_door
-              # Closed door - fully occlude this column
               @wall_depth[x] = [@wall_depth[x], dist].min
               @ceiling_clip[x] = SCREEN_HEIGHT
               @floor_clip[x] = -1
             else
-              # Ceiling clip increases (moves down) as ceiling is marked
-              if sector.ceiling_height > back_sector.ceiling_height
-                # Upper wall drawn - clip ceiling to back ceiling
+              # Ceiling clip (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 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;
+              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
+              # Floor clip
               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;
+                # 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)
@@ -971,17 +1173,17 @@ 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)
         cmap = @colormap.maps[light]
         framebuffer = @framebuffer
-        tex_width_mask = texture.width - 1   # For power-of-2 textures: & mask is faster than %
-        tex_height_mask = texture.height - 1
+        tex_width = texture.width
+        tex_height = texture.height
 
-        # Texture X coordinate (wrap around texture width using bitwise AND)
-        tex_x = tex_col.to_i & tex_width_mask
+        # 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)
@@ -1004,7 +1206,7 @@ module Doom
         y = y1
         while y <= y2
           screen_offset = y - y1
-          tex_y = (tex_y_at_y1 + screen_offset * tex_step).to_i & tex_height_mask
+          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]
@@ -1081,7 +1283,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)
 
@@ -1099,8 +1304,20 @@ 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: 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)
+          elsif @monster_ai
+            mon = @monster_ai.monsters.find { |m| m.thing_idx == thing_idx }
+            if mon && mon.active
+              # Walking animation: cycle through frames A-D based on leveltime
+              walk_frame = %w[A B C D][@leveltime / 4 % 4]
+              sprite = @sprites.get_frame(thing.type, walk_frame, angle_to_thing, thing.angle)
+            end
+            sprite ||= @sprites.get_rotated(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
@@ -1121,6 +1338,45 @@ module Doom
         visible_sprites.each do |vs|
           draw_sprite(vs)
         end
+
+        # Draw projectiles and explosions
+        render_projectiles if @combat
+      end
+
+      def render_projectiles
+        # Render rockets in flight
+        @combat.projectiles.each do |proj|
+          view_x, view_y = transform_point(proj.x, proj.y)
+          next if view_y <= 0
+
+          # Rocket has rotations 1-8 based on travel direction relative to viewer
+          rocket_angle = Math.atan2(proj.dy, proj.dx)
+          viewer_angle = Math.atan2(proj.y - @player_y, proj.x - @player_x)
+          angle_diff = (viewer_angle - rocket_angle) % (2 * Math::PI)
+          rotation = ((angle_diff + Math::PI / 8) / (Math::PI / 4)).to_i % 8 + 1
+          rocket_sprite = @sprites.send(:load_sprite_frame, 'MISL', 'A', rotation)
+          next unless rocket_sprite
+
+          screen_x = HALF_WIDTH + (view_x * @projection / view_y)
+          thing_stub = Map::Thing.new(proj.x, proj.y, 0, 0, 0)
+          visible = VisibleSprite.new(thing_stub, rocket_sprite, view_x, view_y, view_y, screen_x)
+          draw_sprite(visible)
+        end
+
+        # Render explosions (frames B, C, D - all rotation 0)
+        @combat.explosions.each do |expl|
+          view_x, view_y = transform_point(expl[:x], expl[:y])
+          next if view_y <= 0
+          elapsed = (@combat.instance_variable_get(:@tic) - expl[:tic])
+          frame_idx = (elapsed / 4).clamp(0, 2)
+          frame_letter = %w[B C D][frame_idx]
+          expl_sprite = @sprites.send(:load_sprite_frame, 'MISL', frame_letter, 0)
+          next unless expl_sprite
+          screen_x = HALF_WIDTH + (view_x * @projection / view_y)
+          thing_stub = Map::Thing.new(expl[:x], expl[:y], 0, 0, 0)
+          visible = VisibleSprite.new(thing_stub, expl_sprite, view_x, view_y, view_y, screen_x)
+          draw_sprite(visible)
+        end
       end
 
       def draw_sprite(vs)