doom 0.5.0 → 0.8.0

data/lib/doom/render/font.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Doom
+  module Render
+    # DOOM's built-in font loaded from STCFN patches (ASCII 33-121).
+    # Uppercase only -- lowercase is auto-uppercased.
+    class Font
+      SPACE_WIDTH = 4
+
+      def initialize(wad, hud_graphics)
+        @chars = {}
+        (33..121).each do |ascii|
+          name = "STCFN%03d" % ascii
+          sprite = hud_graphics.send(:load_graphic, name)
+          @chars[ascii] = sprite if sprite
+        end
+      end
+
+      # Draw text into framebuffer at (x, y). Returns width drawn.
+      def draw_text(framebuffer, text, x, y, screen_width: 320, screen_height: 240)
+        cursor_x = x
+        text.upcase.each_char do |char|
+          if char == ' '
+            cursor_x += SPACE_WIDTH
+            next
+          end
+
+          sprite = @chars[char.ord]
+          next unless sprite
+
+          draw_char(framebuffer, sprite, cursor_x, y, screen_width, screen_height)
+          cursor_x += sprite.width
+        end
+        cursor_x - x
+      end
+
+      # Measure text width without drawing
+      def text_width(text)
+        width = 0
+        text.upcase.each_char do |char|
+          if char == ' '
+            width += SPACE_WIDTH
+            next
+          end
+          sprite = @chars[char.ord]
+          width += sprite.width if sprite
+        end
+        width
+      end
+
+      # Draw text centered horizontally
+      def draw_centered(framebuffer, text, y, screen_width: 320, screen_height: 240)
+        w = text_width(text)
+        x = (screen_width - w) / 2
+        draw_text(framebuffer, text, x, y, screen_width: screen_width, screen_height: screen_height)
+      end
+
+      private
+
+      def draw_char(framebuffer, sprite, x, y, screen_width, screen_height)
+        sprite.width.times do |col_x|
+          sx = x + col_x
+          next if sx < 0 || sx >= screen_width
+
+          col = sprite.column_pixels(col_x)
+          next unless col
+
+          col.each_with_index do |color, col_y|
+            next unless color
+            sy = y + col_y
+            next if sy < 0 || sy >= screen_height
+            framebuffer[sy * screen_width + sx] = color
+          end
+        end
+      end
+    end
+  end
+end

data/lib/doom/render/renderer.rb

@@ -16,10 +16,14 @@ module Doom
 
     # Drawseg stores wall segment info for sprite clipping
     # Matches Chocolate Doom's drawseg_t structure
-    Drawseg = Struct.new(:x1, :x2, :scale1, :scale2,
+    Drawseg = Struct.new(:x1, :x2, :scale1, :scale2, :scalestep,
                          :silhouette, :bsilheight, :tsilheight,
                          :sprtopclip, :sprbottomclip,
-                         :curline)  # seg for point-on-side test
+                         :curline,  # seg for point-on-side test
+                         :maskedtexturecol,  # per-column texture X for masked mid textures
+                         :frontsector, :backsector,  # sectors for masked rendering
+                         :sidedef,  # sidedef for texture lookup
+                         :dist1, :dist2, :sx1, :sx2)  # for per-column distance recomputation
 
     # VisibleSprite stores sprite data for sorting and rendering
     # Struct is faster than Hash for fixed-field data
@@ -64,6 +68,8 @@ module Doom
         @animations = animations
         @hidden_things = nil
         @combat = nil
+        @monster_ai = nil
+        @leveltime = 0
 
         @framebuffer = Array.new(SCREEN_WIDTH * SCREEN_HEIGHT, 0)
 
@@ -104,7 +110,7 @@ module Doom
       end
 
       attr_reader :player_x, :player_y, :player_z, :sin_angle, :cos_angle, :framebuffer
-      attr_writer :hidden_things, :combat
+      attr_writer :hidden_things, :combat, :monster_ai, :leveltime
 
       # Diagnostic: returns info about all sprites and why they are/aren't visible
       def sprite_diagnostics
@@ -248,8 +254,8 @@ module Doom
         @sprite_floor_clip.replace(@floor_clip)
         @sprite_wall_depth.replace(@wall_depth)
 
-        # Render sprites
-        render_sprites if @sprites
+        # R_DrawMasked: render sprites and masked middle textures interleaved
+        draw_masked if @sprites
       end
 
       # Precompute column-based data for floor/ceiling rendering (R_InitLightTables-like)
@@ -922,8 +928,27 @@ module Doom
           tsilheight = -Float::INFINITY
         end
 
+        # Detect masked middle texture (grates, bars, fences)
+        has_masked = false
+        @current_masked_cols = nil
+        if back_sector && sidedef
+          mid_tex = sidedef.middle_texture
+          if mid_tex && mid_tex != '-' && !mid_tex.empty?
+            has_masked = true
+            @current_masked_cols = Array.new(x2 - x1 + 1)
+            # Force silhouette so sprites get clipped against this seg
+            if (silhouette & SIL_TOP) == 0
+              silhouette |= SIL_TOP
+              tsilheight = -Float::INFINITY
+            end
+            if (silhouette & SIL_BOTTOM) == 0
+              silhouette |= SIL_BOTTOM
+              bsilheight = Float::INFINITY
+            end
+          end
+        end
+
         # Check planes for this seg range (R_CheckPlane equivalent)
-        # This may create new visplanes if column ranges would overlap
         if @current_floor_plane
           @current_floor_plane = check_plane(@current_floor_plane, x1, x2)
         end
@@ -1065,6 +1090,11 @@ module Doom
                                   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
@@ -1137,22 +1167,26 @@ module Doom
           end
         end
 
-        # Save drawseg for sprite clipping (after columns are rendered)
-        # Copy the clip arrays for the segment's screen range
-        if silhouette != SIL_NONE
+        # Save drawseg for sprite clipping and masked rendering
+        if silhouette != SIL_NONE || has_masked
           sprtopclip = @ceiling_clip[x1..x2].dup
           sprbottomclip = @floor_clip[x1..x2].dup
+          scalestep = (x2 > x1) ? (scale2 - scale1) / (x2 - x1) : 0
 
           drawseg = Drawseg.new(
             x1, x2,
-            scale1, scale2,
+            scale1, scale2, scalestep,
             silhouette,
             bsilheight, tsilheight,
             sprtopclip, sprbottomclip,
-            seg
+            seg,
+            has_masked ? @current_masked_cols : nil,
+            sector, back_sector, sidedef,
+            dist1, dist2, sx1.to_f, sx2.to_f
           )
           @drawsegs << drawseg
         end
+        @current_masked_cols = nil
       end
 
       # Wall column drawing with proper texture mapping
@@ -1207,7 +1241,110 @@ module Doom
           tex_y = (tex_y_at_y1 + screen_offset * tex_step).to_i % tex_height
 
           color = column[tex_y]
-          framebuffer[y * SCREEN_WIDTH + x] = cmap[color]
+          framebuffer[y * SCREEN_WIDTH + x] = cmap[color] if color
+          y += 1
+        end
+      end
+
+      # 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?)
+        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
+
+        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
+
+        y1 = 0 if y1 < 0
+        y2 = SCREEN_HEIGHT - 1 if y2 >= SCREEN_HEIGHT
+
+        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
+      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)
+        return if y1 > y2
+        return if texture_name.nil? || texture_name.empty? || texture_name == '-'
+
+        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
+
+        tex_x = tex_col.to_i % tex_width
+        column = texture.column_pixels(tex_x)
+        return unless column
+
+        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
+
+        y1 = 0 if y1 < 0
+        y2 = SCREEN_HEIGHT - 1 if y2 >= SCREEN_HEIGHT
+
+        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]
+          # Skip transparent pixels (nil in patch data)
+          if color
+            framebuffer[y * SCREEN_WIDTH + x] = cmap[color]
+          end
           y += 1
         end
       end
@@ -1302,9 +1439,28 @@ module Doom
           dy = thing.y - @player_y
           angle_to_thing = Math.atan2(dy, dx)
 
-          # Get sprite - use death frame if monster is dead
+          # Get sprite: death frame > walking frame > idle frame
           if @combat && @combat.dead?(thing_idx)
             sprite = @combat.death_sprite(thing_idx, thing.type, angle_to_thing, thing.angle)
+            next unless sprite  # Barrel disappeared after explosion
+          elsif @monster_ai
+            mon = @monster_ai.monster_by_thing_idx[thing_idx]
+            if mon && mon.active
+              if mon.attacking
+                # Attack animation: show attack frames (E, F, G...)
+                prefix = @sprites.prefix_for(thing.type)
+                atk_frames = Game::MonsterAI::ATTACK_FRAMES[prefix]
+                if atk_frames
+                  frame_idx = (mon.attack_frame_tic / Game::MonsterAI::ATTACK_FRAME_TICS).clamp(0, atk_frames.size - 1)
+                  sprite = @sprites.get_frame(thing.type, atk_frames[frame_idx], angle_to_thing, thing.angle)
+                end
+              else
+                # Walking animation: cycle through frames A-D
+                walk_frame = %w[A B C D][@leveltime / 4 % 4]
+                sprite = @sprites.get_frame(thing.type, walk_frame, angle_to_thing, thing.angle)
+              end
+            end
+            sprite ||= @sprites.get_rotated(thing.type, angle_to_thing, thing.angle)
           else
             sprite = @sprites.get_rotated(thing.type, angle_to_thing, thing.angle)
           end
@@ -1324,9 +1480,223 @@ module Doom
         # Sort by distance (back to front for proper overdraw)
         visible_sprites.sort_by! { |s| -s.dist }
 
-        # Draw each sprite
+        # Draw each sprite with drawseg interleaving
         visible_sprites.each do |vs|
-          draw_sprite(vs)
+          draw_sprite_with_masking(vs)
+        end
+
+        # Draw remaining masked segs not triggered by sprites
+        @drawsegs.reverse_each do |ds|
+          next unless ds.maskedtexturecol
+          render_masked_seg_range(ds, ds.x1, ds.x2)
+        end
+
+        # Draw projectiles, explosions, and bullet puffs
+        if @combat
+          render_projectiles
+          render_puffs
+        end
+      end
+
+      # Chocolate Doom R_DrawMasked: interleave sprites with masked drawsegs
+      def draw_masked
+        render_sprites
+      end
+
+      # Draw sprite, rendering masked drawsegs behind it first (R_DrawSprite)
+      def draw_sprite_with_masking(spr)
+        sprite_scale = @projection / spr.dist
+
+        # Scan drawsegs newest to oldest (nearest to farthest)
+        @drawsegs.reverse_each do |ds|
+          next if ds.x1 > spr.screen_x.to_i + spr.sprite.width || ds.x2 < spr.screen_x.to_i - spr.sprite.width
+          next if ds.silhouette == SIL_NONE && ds.maskedtexturecol.nil?
+
+          ds_max_scale = [ds.scale1, ds.scale2].max
+          ds_min_scale = [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
+          end
+        end
+
+        draw_sprite(spr)
+      end
+
+      # Chocolate Doom R_RenderMaskedSegRange
+      def render_masked_seg_range(ds, rx1, rx2)
+        return unless ds.maskedtexturecol
+        return unless ds.sidedef
+
+        mid_tex_name = ds.sidedef.middle_texture
+        return if mid_tex_name.nil? || mid_tex_name == '-' || mid_tex_name.empty?
+
+        texture = @textures[anim_texture(mid_tex_name)]
+        return unless texture
+
+        front = ds.frontsector
+        back = ds.backsector
+        return unless front && back
+
+        # Texture anchoring (matching Chocolate Doom)
+        if ds.curline && @map.linedefs[ds.curline.linedef].lower_unpegged?
+          higher_floor = [front.floor_height, back.floor_height].max
+          dc_texturemid = higher_floor + texture.height - @player_z
+        else
+          lower_ceiling = [front.ceiling_height, back.ceiling_height].min
+          dc_texturemid = lower_ceiling - @player_z
+        end
+        dc_texturemid += ds.sidedef.y_offset
+
+        light_level = front.light_level
+
+        # Iterate columns
+        rx1 = [rx1, ds.x1].max
+        rx2 = [rx2, ds.x2].min
+
+        (rx1..rx2).each do |x|
+          col_idx = x - ds.x1
+          next if col_idx < 0 || col_idx >= ds.maskedtexturecol.size
+
+          tex_col = ds.maskedtexturecol[col_idx]
+          next unless tex_col  # nil = already drawn or empty
+
+          # Per-column distance using same 1/z interpolation as wall renderer
+          if ds.dist1 && ds.dist2 && ds.dist1 > 0 && ds.dist2 > 0 && ds.sx2 != ds.sx1
+            t = ((x - ds.sx1) / (ds.sx2 - ds.sx1)).clamp(0.0, 1.0)
+            inv_dist = (1.0 - t) / ds.dist1 + t / ds.dist2
+            col_dist = 1.0 / inv_dist
+          else
+            col_dist = ds.dist1 || 1.0
+          end
+          next if col_dist < 1
+          spryscale = @projection / col_dist
+          spryscale = [spryscale, 64.0].min
+
+          # Screen Y of texture top
+          sprtopscreen = HALF_HEIGHT - dc_texturemid * spryscale
+
+          # Get clip bounds from drawseg
+          clip_idx = x - ds.x1
+          mceilingclip = ds.sprtopclip[clip_idx]
+          mfloorclip = ds.sprbottomclip[clip_idx]
+
+          # Calculate column draw range
+          tex_x = tex_col.to_i % texture.width
+          column = texture.column_pixels(tex_x)
+          next unless column
+
+          iscale = 1.0 / spryscale
+
+          light = calculate_light(light_level, col_dist)
+          cmap = @colormap.maps[light]
+
+          # Draw each non-nil run of pixels (transparency)
+          tex_height = texture.height
+          y_start = nil
+          (0..tex_height).each do |ty|
+            color = ty < tex_height ? column[ty] : nil
+            if color
+              y_start = ty unless y_start
+            elsif y_start
+              # Draw run from y_start to ty-1
+              top_y = (sprtopscreen + y_start * spryscale).to_i
+              bot_y = (sprtopscreen + ty * spryscale).to_i - 1
+              top_y = [top_y, mceilingclip + 1].max
+              bot_y = [bot_y, mfloorclip - 1].min
+
+              if top_y <= bot_y
+                top_y = [top_y, 0].max
+                bot_y = [bot_y, SCREEN_HEIGHT - 1].min
+                tex_frac = y_start + (top_y - (sprtopscreen + y_start * spryscale)) * iscale
+                y = top_y
+                while y <= bot_y
+                  t = ((tex_frac).to_i % tex_height)
+                  c = column[t]
+                  @framebuffer[y * SCREEN_WIDTH + x] = cmap[c] if c
+                  tex_frac += iscale
+                  y += 1
+                end
+              end
+              y_start = nil
+            end
+          end
+
+          # Mark column as drawn
+          ds.maskedtexturecol[col_idx] = nil
+        end
+      end
+
+      # Stub for projectiles/explosions that carries a z height
+      ProjectileStub = Struct.new(:x, :y, :angle, :type, :flags, :z)
+
+      def render_projectiles
+        # Render all projectiles in flight
+        @combat.projectiles.each do |proj|
+          view_x, view_y = transform_point(proj.x, proj.y)
+          next if view_y <= 0
+
+          prefix = proj.sprite_prefix || 'MISL'
+
+          # Try rotation-based sprite first (rockets, baron fireballs)
+          rocket_angle = Math.atan2(proj.dy, proj.dx)
+          viewer_angle = Math.atan2(proj.y - @player_y, proj.x - @player_x)
+          angle_diff = (viewer_angle - rocket_angle) % (2 * Math::PI)
+          rotation = ((angle_diff + Math::PI / 8) / (Math::PI / 4)).to_i % 8 + 1
+
+          # Animate flight: cycle A/B frames
+          flight_frame = %w[A B][@leveltime / 4 % 2]
+          proj_sprite = @sprites.send(:load_sprite_frame, prefix, flight_frame, rotation)
+          proj_sprite ||= @sprites.send(:load_sprite_frame, prefix, flight_frame, 0)
+          proj_sprite ||= @sprites.send(:load_sprite_frame, prefix, 'A', 0)
+          next unless proj_sprite
+
+          screen_x = HALF_WIDTH + (view_x * @projection / view_y)
+          stub = ProjectileStub.new(proj.x, proj.y, 0, 0, 0, proj.z)
+          visible = VisibleSprite.new(stub, proj_sprite, view_x, view_y, view_y, screen_x)
+          draw_sprite(visible)
+        end
+
+        # Render explosions at projectile height
+        @combat.explosions.each do |expl|
+          view_x, view_y = transform_point(expl[:x], expl[:y])
+          next if view_y <= 0
+          elapsed = (@combat.instance_variable_get(:@tic) - expl[:tic])
+          frame_idx = (elapsed / 4).clamp(0, 2)
+
+          prefix = expl[:sprite] || 'MISL'
+          frame_letter = (prefix == 'MISL') ? %w[B C D][frame_idx] : %w[C D E][frame_idx]
+
+          expl_sprite = @sprites.send(:load_sprite_frame, prefix, frame_letter, 0)
+          next unless expl_sprite
+          screen_x = HALF_WIDTH + (view_x * @projection / view_y)
+          expl_z = expl[:z] || @player_z
+          stub = ProjectileStub.new(expl[:x], expl[:y], 0, 0, 0, expl_z)
+          visible = VisibleSprite.new(stub, expl_sprite, view_x, view_y, view_y, screen_x)
+          draw_sprite(visible)
+        end
+      end
+
+      def render_puffs
+        @combat.puffs.each do |puff|
+          view_x, view_y = transform_point(puff[:x], puff[:y])
+          next if view_y <= 0
+          elapsed = @combat.instance_variable_get(:@tic) - puff[:tic]
+          frame_idx = (elapsed / 3).clamp(0, 3)
+          frame_letter = %w[A B C D][frame_idx]
+          puff_sprite = @sprites.send(:load_sprite_frame, 'PUFF', frame_letter, 0)
+          next unless puff_sprite
+          screen_x = HALF_WIDTH + (view_x * @projection / view_y)
+          stub = ProjectileStub.new(puff[:x], puff[:y], 0, 0, 0, puff[:z])
+          visible = VisibleSprite.new(stub, puff_sprite, view_x, view_y, view_y, screen_x)
+          draw_sprite(visible)
         end
       end
 
@@ -1359,10 +1729,17 @@ module Doom
         x2 = [sprite_right, SCREEN_WIDTH - 1].min
         return if x1 > x2
 
-        # Calculate sprite world Z positions
+        # Calculate sprite world Z positions (matching Chocolate Doom R_ProjectSprite)
+        # gzt = mobj->z + spritetopoffset (top of sprite)
+        # gz = gzt - spriteheight (bottom of sprite, 1:1 pixel:unit)
         thing_floor = sector ? sector.floor_height : 0
-        sprite_gz = thing_floor  # bottom of sprite in world Z
-        sprite_gzt = thing_floor + sprite.top_offset  # top of sprite in world Z
+        if thing.is_a?(ProjectileStub) && thing.z
+          base_z = thing.z
+        else
+          base_z = 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)

data/lib/doom/render/screen_melt.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Doom
+  module Render
+    # DOOM's screen melt/wipe effect from wipe.c.
+    # Each column slides down at a slightly different speed,
+    # revealing the new screen underneath.
+    class ScreenMelt
+      WIDTH = SCREEN_WIDTH
+      HEIGHT = SCREEN_HEIGHT
+      MELT_SPEED = HEIGHT / 30  # ~8 pixels per frame (Chocolate Doom does HEIGHT/15 at 35fps)
+
+      def initialize(old_screen, new_screen)
+        # Snapshot both screens (arrays of palette indices, 320x240)
+        @old = old_screen.dup
+        @new = new_screen.dup
+        @done = false
+
+        # Initialize column offsets (from wipe_initMelt in wipe.c)
+        # Column 0 gets random negative offset, each subsequent column
+        # varies by -1/0/+1 from previous, creating a jagged melt line
+        @y = Array.new(WIDTH)
+        @y[0] = -(rand(16))
+        (1...WIDTH).each do |i|
+          @y[i] = @y[i - 1] + (rand(3) - 1)
+          @y[i] = -15 if @y[i] < -15
+          @y[i] = 0 if @y[i] > 0
+        end
+      end
+
+      def done?
+        @done
+      end
+
+      # Advance one tic. Returns the composited framebuffer.
+      def update(framebuffer)
+        all_done = true
+
+        WIDTH.times do |x|
+          if @y[x] < 0
+            @y[x] += 1
+            all_done = false
+            # Column hasn't started melting yet - show old screen
+            HEIGHT.times { |row| framebuffer[row * WIDTH + x] = @old[row * WIDTH + x] }
+          elsif @y[x] < HEIGHT
+            all_done = false
+            dy = @y[x]
+
+            # Top part: new screen revealed
+            dy.times do |row|
+              framebuffer[row * WIDTH + x] = @new[row * WIDTH + x]
+            end
+
+            # Bottom part: old screen shifted down
+            (dy...HEIGHT).each do |row|
+              src_row = row - dy
+              framebuffer[row * WIDTH + x] = @old[src_row * WIDTH + x]
+            end
+
+            @y[x] += MELT_SPEED
+          else
+            # Column fully melted - show new screen
+            HEIGHT.times { |row| framebuffer[row * WIDTH + x] = @new[row * WIDTH + x] }
+          end
+        end
+
+        @done = all_done
+      end
+    end
+  end
+end