termfront 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68852aaca6be7127d8b644aae4670a56e72d5528b249dc081d72ba0d22c5f74a
-  data.tar.gz: 440209c869681acd0f9d77d65fb367e6d055c2ffe3a5a57821dd530912199ecd
+  metadata.gz: d84ea40d760b9d62c0037b83a0b83576725a12a16c3aa2937e16025e6a798015
+  data.tar.gz: e33b7fc4bde17b2924ea6a1f30bb11f6f8d30fbba75bd9f9130c773b1b1cf33a
 SHA512:
-  metadata.gz: 6efb979956fa649ee558ad0190547fd70c62fda5ef8b8ca4dc06f513c15c87c02c74151756486615a0cc21301e6b45d6f62e01e58230ae28b574ceb3570053ae
-  data.tar.gz: 12dfe9fde65aa1517facf4e7e21a37b6db9550e5cc99663801efb33db74f1a1b88af2503c6c6c54be70d60374328009f85334422413737514845602091f70893
+  metadata.gz: fc5856f2bb1eea72307f2ba41af96e5b3412e7ef893fe8a3609f0841ab88d693653ed797c072eff8a4092d01511c810edd2fc848c12dcd17a07b8803181cc551
+  data.tar.gz: 461847cef45b100959a044dcb22cca9c537a806331168834d9f936fd6055c4c668581f376058003ad2eb28abdd805cc3f2d82d6f52a36644b7f7d53a13635f9f

data/CHANGELOG.md

@@ -6,6 +6,24 @@ The format is based on Keep a Changelog, and this project follows Semantic Versi
 
 ## [Unreleased]
 
+## [0.1.6] - 2026-05-26
+
+### Changed
+
+- Memoize the HUD shield and ammo lines so `fit_ansi` only re-runs when the shown shield value, weapon, ammo, pickup hint, or terminal width actually change
+- Inline the color-mode branching and SGR lookups into `Renderer#render_view` to remove per-cell `bg_only?`, `ansi_fg`, and `ansi_bg` method calls (about 72,000 calls per second at 30 Hz on an 80-wide terminal)
+- Enable YJIT on startup so the hot Ruby methods in the renderer (`build_view_pixels`, `render_view`, `cast_ray`, etc.) get JIT-compiled instead of interpreted
+- Rewrite `TerminalOutput.fit_ansi` to walk the input by byte index with `getbyte` and `byteslice` instead of scanning with a regular expression, removing the per-line `Regexp#match` / `MatchData` allocations that dominated the renderer's CPU profile under YJIT
+- Render the title screen at 30 Hz while still advancing its spin animation and polling input at 60 Hz, so the per-frame renderer cost halves without making the demo motion feel choppy
+- Cache the demo mission instance, its tile-map, and its enemy definitions inside `TitleScreen#initialize` instead of rebuilding them every frame
+- Render singleplayer and Wavesfight at 30 Hz while still running the update step, physics, and input polling at 60 Hz, halving the in-game renderer cost without slowing the simulation or input response
+- Rewrite `Renderer#build_view_pixels` with column-major `while` loops that read `wtop`/`wbot`/`wcol` once per column and fill the ceiling / wall / floor segments without per-cell branching, hoisting `Config::CEIL_C` / `Config::FLOOR_C` and `@pixels` as locals so YJIT keeps the hot loop tight
+- Memoize the title screen's static lines (logo, subtitle, and the five menu entries) per terminal width so `fit_ansi` runs once instead of seven times per title-screen frame
+- Memoize every line of `Game#render_mission_select` keyed by terminal width, current selection, difficulty, and mission class, so the nine `fit_ansi` calls per frame collapse to cache lookups while the cursor is idle
+- Reuse the radar's enemy / drop / terminal / ally cell hashes between frames and key them by integer (`sy * diam + sx`) to drop per-cell `Array` allocations, hoisting `Config::RADAR_RANGE`, `RADAR_RANGE_SQ`, `r*r`, and the player position as locals so YJIT keeps the radar projection loops tight
+- Tighten the enemy half of `Renderer#overlay_enemies_3d`: hoist the FOV tangent, player position, and half-frame constants as locals, replace the `upto` loops with `while`, use integer shift instead of `to_f` / `.ceil` / `.floor` for half-block row indexing, and cache the float versions of `actual_h` / `actual_w` so the per-cell sprite division loop stops allocating new floats every iteration
+- Apply the same `while`-loop and integer-math pattern to the drop and projectile branches of `Renderer#overlay_enemies_3d`, reusing the hoisted player position and half-frame constants and computing the projectile color directly instead of through an intermediate ANSI code string
+
 ## [0.1.5] - 2026-05-25
 
 ### Changed

data/exe/termfront

@@ -1,6 +1,8 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+RubyVM::YJIT.enable if defined?(RubyVM::YJIT)
+
 require "termfront"
 
 Termfront.start

data/lib/termfront/config.rb

@@ -3,6 +3,7 @@
 module Termfront
   module Config
     FRAME_DT      = 1.0 / 60.0
+    RENDER_DT     = 1.0 / 30.0
     FOV           = 66.0 * Math::PI / 180.0
     PLAYER_RADIUS = 0.2
     KEY_TIMEOUT   = 5

data/lib/termfront/game.rb

@@ -131,6 +131,7 @@ module Termfront
     def run_game_loop(show_complete_banner: true)
       STDIN.raw do |stdin|
         last_time = clock
+        last_render = last_time - Config::RENDER_DT
 
         loop do
           now = clock
@@ -146,11 +147,14 @@ module Termfront
           end
 
           update(dt)
-          @renderer.render(
-            player: @player, map: @map,
-            enemies: @enemies, projectiles: @projectiles,
-            drops: @player.drops, terminals: @terminals
-          )
+          if now - last_render >= Config::RENDER_DT
+            @renderer.render(
+              player: @player, map: @map,
+              enemies: @enemies, projectiles: @projectiles,
+              drops: @player.drops, terminals: @terminals
+            )
+            last_render = now
+          end
 
           if @player.dead
             rows, cols = @stdout.winsize
@@ -176,6 +180,7 @@ module Termfront
     def run_wavesfight_loop
       STDIN.raw do |stdin|
         last_time = clock
+        last_render = last_time - Config::RENDER_DT
 
         loop do
           now = clock
@@ -191,12 +196,15 @@ module Termfront
           end
 
           update(dt)
-          @renderer.render(
-            player: @player, map: @map,
-            enemies: @enemies, projectiles: @projectiles,
-            drops: @player.drops, terminals: @terminals,
-            status_line: "  WAVE #{@wave}  #{Enemy::Base::DIFFICULTIES[@difficulty][:name]}"
-          )
+          if now - last_render >= Config::RENDER_DT
+            @renderer.render(
+              player: @player, map: @map,
+              enemies: @enemies, projectiles: @projectiles,
+              drops: @player.drops, terminals: @terminals,
+              status_line: "  WAVE #{@wave}  #{Enemy::Base::DIFFICULTIES[@difficulty][:name]}"
+            )
+            last_render = now
+          end
 
           if @player.dead
             rows, cols = @stdout.winsize
@@ -209,6 +217,7 @@ module Termfront
             show_wave_clear
             start_wavesfight_wave
             last_time = clock
+            last_render = clock - Config::RENDER_DT
           end
 
           cap_frame(now)
@@ -543,62 +552,78 @@ module Termfront
       end
     end
 
+    MISSION_SELECT_DIFF_COLORS = ["\e[92m", "\e[93m", "\e[38;2;255;165;0m", "\e[91m"].freeze
+    MISSION_SELECT_CTRL = "Up/Down: Select   Left/Right: Difficulty   Enter/1-5: Start   Q: Back"
+
     def render_mission_select(selected, missions, title)
       rows, cols = @stdout.winsize
       buf = TerminalOutput.begin_frame(home: true)
       lines = Array.new(rows) { " " * cols }
+      cache = (@mission_select_cache ||= {})
 
-      tc = [(cols - title.size) / 2 + 1, 1].max
-      lines[1] = TerminalOutput.fit_ansi("#{" " * (tc - 1)}\e[1;38;2;120;140;255m#{title}\e[0m", cols)
+      lines[1] = cache[[:title, cols, title]] ||= begin
+        tc = [(cols - title.size) / 2 + 1, 1].max
+        TerminalOutput.fit_ansi("#{" " * (tc - 1)}\e[1;38;2;120;140;255m#{title}\e[0m", cols)
+      end
 
       diff = Enemy::Base::DIFFICULTIES[@difficulty]
-      diff_colors = ["\e[92m", "\e[93m", "\e[38;2;255;165;0m", "\e[91m"]
-      diff_label = "< #{diff[:name]} >"
-      dc = [(cols - diff_label.size) / 2 + 1, 1].max
-      lines[2] = TerminalOutput.fit_ansi("#{" " * (dc - 1)}#{diff_colors[@difficulty]}#{diff_label}\e[0m", cols)
+      lines[2] = cache[[:diff, cols, @difficulty]] ||= begin
+        diff_label = "< #{diff[:name]} >"
+        dc = [(cols - diff_label.size) / 2 + 1, 1].max
+        TerminalOutput.fit_ansi("#{" " * (dc - 1)}#{MISSION_SELECT_DIFF_COLORS[@difficulty]}#{diff_label}\e[0m", cols)
+      end
 
       missions.each_with_index do |klass, i|
-        m = klass.new
         row = 5 + i * 2
-        label = "  #{i + 1}. #{m.name}"
-        lc = [(cols - 40) / 2 + 1, 1].max
-        text = if i == selected
-                 "\e[1;97;44m> #{label.strip.ljust(38)}\e[0m"
-               else
-                 "\e[97m  #{label.strip.ljust(38)}\e[0m"
-               end
-        lines[row - 1] = TerminalOutput.fit_ansi("#{" " * (lc - 1)}#{text}", cols)
+        is_selected = i == selected
+        lines[row - 1] = cache[[:mission, cols, i, is_selected, klass]] ||= begin
+          m = klass.new
+          label = "  #{i + 1}. #{m.name}"
+          lc = [(cols - 40) / 2 + 1, 1].max
+          text = if is_selected
+                   "\e[1;97;44m> #{label.strip.ljust(38)}\e[0m"
+                 else
+                   "\e[97m  #{label.strip.ljust(38)}\e[0m"
+                 end
+          TerminalOutput.fit_ansi("#{" " * (lc - 1)}#{text}", cols)
+        end
       end
 
       brief_row = 5 + missions.size * 2 + 1
-      m = missions[selected].new
-      briefing = m.briefing
-      bc = [(cols - briefing.size) / 2 + 1, 1].max
-      lines[brief_row - 1] = TerminalOutput.fit_ansi("#{" " * (bc - 1)}\e[38;2;180;180;200m#{briefing}\e[0m", cols)
+      lines[brief_row - 1] = cache[[:brief, cols, missions[selected]]] ||= begin
+        m = missions[selected].new
+        briefing = m.briefing
+        bc = [(cols - briefing.size) / 2 + 1, 1].max
+        TerminalOutput.fit_ansi("#{" " * (bc - 1)}\e[38;2;180;180;200m#{briefing}\e[0m", cols)
+      end
 
       info_row = brief_row + 2
-      edefs = m.enemy_defs
-      base_crawler = edefs.count { |e| e[4] == :crawler }
-      base_executor = edefs.count { |e| e[4] == :executor }
-      extra = diff[:extra_enemies]
-      extra_crawler = 0
-      extra_executor = 0
-      extra.times do |i|
-        src_type = edefs[i % edefs.size][4]
-        src_type == :crawler ? (extra_crawler += 1) : (extra_executor += 1)
+      lines[info_row - 1] = cache[[:info, cols, @difficulty, missions[selected]]] ||= begin
+        m = missions[selected].new
+        edefs = m.enemy_defs
+        base_crawler = edefs.count { |e| e[4] == :crawler }
+        base_executor = edefs.count { |e| e[4] == :executor }
+        extra = diff[:extra_enemies]
+        extra_crawler = 0
+        extra_executor = 0
+        extra.times do |i|
+          src_type = edefs[i % edefs.size][4]
+          src_type == :crawler ? (extra_crawler += 1) : (extra_executor += 1)
+        end
+        crawler_c = base_crawler + extra_crawler
+        executor_c = base_executor + extra_executor
+        info = "Enemies: #{crawler_c} Crawler#{crawler_c != 1 ? "s" : ""}"
+        info += ", #{executor_c} Executor#{executor_c != 1 ? "s" : ""}" if executor_c > 0
+        info += "  |  HP x#{diff[:hp_mult]}"
+        ic = [(cols - info.size) / 2 + 1, 1].max
+        TerminalOutput.fit_ansi("#{" " * (ic - 1)}\e[38;2;140;140;160m#{info}\e[0m", cols)
       end
-      crawler_c = base_crawler + extra_crawler
-      executor_c = base_executor + extra_executor
-      info = "Enemies: #{crawler_c} Crawler#{crawler_c != 1 ? "s" : ""}"
-      info += ", #{executor_c} Executor#{executor_c != 1 ? "s" : ""}" if executor_c > 0
-      info += "  |  HP x#{diff[:hp_mult]}"
-      ic = [(cols - info.size) / 2 + 1, 1].max
-      lines[info_row - 1] = TerminalOutput.fit_ansi("#{" " * (ic - 1)}\e[38;2;140;140;160m#{info}\e[0m", cols)
 
       ctrl_row = info_row + 2
-      ctrl = "Up/Down: Select   Left/Right: Difficulty   Enter/1-5: Start   Q: Back"
-      cc = [(cols - ctrl.size) / 2 + 1, 1].max
-      lines[ctrl_row - 1] = TerminalOutput.fit_ansi("#{" " * (cc - 1)}\e[38;2;100;100;120m#{ctrl}\e[0m", cols)
+      lines[ctrl_row - 1] = cache[[:ctrl, cols]] ||= begin
+        cc = [(cols - MISSION_SELECT_CTRL.size) / 2 + 1, 1].max
+        TerminalOutput.fit_ansi("#{" " * (cc - 1)}\e[38;2;100;100;120m#{MISSION_SELECT_CTRL}\e[0m", cols)
+      end
 
       lines.each_with_index do |line, index|
         buf << line

data/lib/termfront/renderer.rb

@@ -19,6 +19,10 @@ module Termfront
       @radar_grid_template = build_radar_grid_template
       @hrule_cache = Hash.new { |h, c| h[c] = ("\xE2\x94\x80" * c)[0, c * 3].freeze }
       @radar_drop_glyphs = {}
+      @radar_enemy_cells = {}
+      @radar_drop_cells = {}
+      @radar_terminal_cells = {}
+      @radar_ally_cells = {}
       @fg_truecolor_cache = {}
       @bg_truecolor_cache = {}
       @enemy_sprites = []
@@ -28,6 +32,10 @@ module Termfront
       @radar_line_buf = +""
       @size_cache = nil
       @size_cache_at = -Float::INFINITY
+      @cached_hud_shield_key = nil
+      @cached_hud_shield_line = nil
+      @cached_hud_ammo_key = nil
+      @cached_hud_ammo_line = nil
     end
 
     def invalidate_size_cache!
@@ -211,6 +219,14 @@ module Termfront
     end
 
     def render_hud(buf, cols, player, drops, terminals, status_line)
+      buf << hud_shield_line(cols, player, status_line) << "\r\n"
+      buf << hud_ammo_line(cols, player, drops, terminals) << "\r\n"
+    end
+
+    def hud_shield_line(cols, player, status_line)
+      key = [player.shield.to_i, status_line, cols]
+      return @cached_hud_shield_line if @cached_hud_shield_key == key
+
       bar_w = [cols - 20, 10].max
       pct = player.shield / Config::SHIELD_MAX.to_f
       filled = (pct * bar_w).to_i
@@ -226,11 +242,23 @@ module Termfront
       shield_str = "SHIELD #{color}#{"█" * filled}#{"░" * empty}\e[0m #{pct_s}"
       shield_str = "#{shield_str}\e[90m#{status_line}\e[0m" if status_line
       pad = [(cols - bar_w - 15) / 2, 0].max
-      buf << TerminalOutput.fit_ansi("#{" " * pad}#{shield_str}", cols) << "\r\n"
+      line = TerminalOutput.fit_ansi("#{" " * pad}#{shield_str}", cols)
 
+      @cached_hud_shield_key = key
+      @cached_hud_shield_line = line
+      line
+    end
+
+    def hud_ammo_line(cols, player, drops, terminals)
       weapon = player.current_weapon
-      wcolor = weapon.type_id.to_s.start_with?("shock") ? "\e[96m" : "\e[97m"
+      can_pickup = drops.any? { |d| d.in_range?(player.x, player.y) }
+      can_use_terminal = terminals.any? do |terminal|
+        (terminal[:x] - player.x)**2 + (terminal[:y] - player.y)**2 < Config::TERMINAL_USE_RADIUS**2
+      end
+      key = [weapon.type_id, weapon.ammo, can_pickup, can_use_terminal, cols]
+      return @cached_hud_ammo_line if @cached_hud_ammo_key == key
 
+      wcolor = weapon.type_id.to_s.start_with?("shock") ? "\e[96m" : "\e[97m"
       if weapon.max_ammo
         ammo_bar_w = 12
         ammo_pct = weapon.ammo.to_f / weapon.max_ammo
@@ -241,10 +269,6 @@ module Termfront
         ammo_str = "#{wcolor}#{weapon.name}\e[0m [\xe2\x88\x9e]"
       end
 
-      can_pickup = drops.any? { |d| d.in_range?(player.x, player.y) }
-      can_use_terminal = terminals.any? do |terminal|
-        (terminal[:x] - player.x)**2 + (terminal[:y] - player.y)**2 < Config::TERMINAL_USE_RADIUS**2
-      end
       interact_str = if can_use_terminal
                        "\e[1;96m[E]Use Terminal\e[0m"
                      elsif can_pickup
@@ -253,26 +277,48 @@ module Termfront
                        "E:interact"
                      end
 
-      line = "#{ammo_str}  T:swap  #{interact_str}  Space:fire"
-      buf << TerminalOutput.fit_ansi(line, cols) << "\r\n"
+      line = TerminalOutput.fit_ansi("#{ammo_str}  T:swap  #{interact_str}  Space:fire", cols)
+
+      @cached_hud_ammo_key = key
+      @cached_hud_ammo_line = line
+      line
     end
 
     def build_view_pixels(virt_h, view_w, wtop, wbot, wcol)
-      virt_h.times do |vr|
-        row = @pixels[vr]
-        view_w.times do |c|
-          row[c] = if vr < wtop[c]
-                     Config::CEIL_C
-                   elsif vr < wbot[c]
-                     wcol[c]
-                   else
-                     Config::FLOOR_C
-                   end
+      ceil_c = Config::CEIL_C
+      floor_c = Config::FLOOR_C
+      pixels = @pixels
+
+      c = 0
+      while c < view_w
+        wt = wtop[c]
+        wb = wbot[c]
+        wc = wcol[c]
+
+        vr = 0
+        while vr < wt && vr < virt_h
+          pixels[vr][c] = ceil_c
+          vr += 1
+        end
+        while vr < wb && vr < virt_h
+          pixels[vr][c] = wc
+          vr += 1
         end
+        while vr < virt_h
+          pixels[vr][c] = floor_c
+          vr += 1
+        end
+
+        c += 1
       end
     end
 
     def render_view(buf, view_h, view_w, pixels)
+      fg_256 = FG_256
+      bg_256 = BG_256
+      fg_cache = @fg_truecolor_cache
+      bg_cache = @bg_truecolor_cache
+
       view_h.times do |r|
         vp0 = r * 2
         vp1 = r * 2 + 1
@@ -286,16 +332,16 @@ module Termfront
           bc = bot_row[c]
 
           if tc == bc
-            if bg_only?(tc)
+            if tc.is_a?(Integer)
               if tc != pbg
-                buf << ansi_bg(tc)
+                buf << bg_256[tc]
                 pbg = tc
                 pfg = nil
               end
               buf << " "
             else
               if tc != pfg || pbg
-                buf << ansi_fg(tc)
+                buf << (fg_cache[tc] ||= "\e[38;2;#{tc}m".freeze)
                 pfg = tc
                 pbg = nil
               end
@@ -303,7 +349,9 @@ module Termfront
             end
           else
             if tc != pfg || bc != pbg
-              buf << ansi_fg(tc) << ansi_bg(bc)
+              fg = tc.is_a?(Integer) ? fg_256[tc] : (fg_cache[tc] ||= "\e[38;2;#{tc}m".freeze)
+              bg = bc.is_a?(Integer) ? bg_256[bc] : (bg_cache[bc] ||= "\e[48;2;#{bc}m".freeze)
+              buf << fg << bg
               pfg = tc
               pbg = bc
             end
@@ -319,82 +367,97 @@ module Termfront
 
       r = Config::RADAR_RADIUS
       diam = r * 2 + 1
+      range = Config::RADAR_RANGE
+      range_sq = Config::RADAR_RANGE_SQ
+      r_sq = r * r
       grid = @radar_grid_template
 
       cos_a = Math.cos(-player.angle + Math::PI / 2)
       sin_a = Math.sin(-player.angle + Math::PI / 2)
-      enemy_cells = {}
+      px = player.x
+      py = player.y
+
+      enemy_cells = @radar_enemy_cells
+      drop_cells = @radar_drop_cells
+      terminal_cells = @radar_terminal_cells
+      ally_cells = @radar_ally_cells
+      enemy_cells.clear
+      drop_cells.clear
+      terminal_cells.clear
+      ally_cells.clear
+
       enemies.each do |e|
         next unless e.alive
 
-        ex = e.x - player.x
-        ey = e.y - player.y
-        next if ex * ex + ey * ey > Config::RADAR_RANGE_SQ
+        ex = e.x - px
+        ey = e.y - py
+        next if ex * ex + ey * ey > range_sq
 
         rx = -(ex * cos_a - ey * sin_a)
         ry = -(ex * sin_a + ey * cos_a)
-        sx = r + (rx / Config::RADAR_RANGE * r).round
-        sy = r + (ry / Config::RADAR_RANGE * r).round
-        next unless sx.between?(0, diam - 1) && sy.between?(0, diam - 1)
+        sx = r + (rx / range * r).round
+        sy = r + (ry / range * r).round
+        next if sx < 0 || sx >= diam || sy < 0 || sy >= diam
 
-        d2 = (sx - r)**2 + (sy - r)**2
-        next if d2 > r * r
+        dxr = sx - r
+        dyr = sy - r
+        next if dxr * dxr + dyr * dyr > r_sq
 
-        enemy_cells[[sy, sx]] = e.sprite_id
+        enemy_cells[sy * diam + sx] = e.sprite_id
       end
 
-      drop_cells = {}
       drops.each do |d|
-        ex = d.x - player.x
-        ey = d.y - player.y
-        next if ex * ex + ey * ey > Config::RADAR_RANGE_SQ
+        ex = d.x - px
+        ey = d.y - py
+        next if ex * ex + ey * ey > range_sq
 
         rx = -(ex * cos_a - ey * sin_a)
         ry = -(ex * sin_a + ey * cos_a)
-        sx = r + (rx / Config::RADAR_RANGE * r).round
-        sy = r + (ry / Config::RADAR_RANGE * r).round
-        next unless sx.between?(0, diam - 1) && sy.between?(0, diam - 1)
+        sx = r + (rx / range * r).round
+        sy = r + (ry / range * r).round
+        next if sx < 0 || sx >= diam || sy < 0 || sy >= diam
 
-        d2 = (sx - r)**2 + (sy - r)**2
-        next if d2 > r * r
+        dxr = sx - r
+        dyr = sy - r
+        next if dxr * dxr + dyr * dyr > r_sq
 
-        drop_cells[[sy, sx]] = d
+        drop_cells[sy * diam + sx] = d
       end
 
-      terminal_cells = {}
       terminals.each do |terminal|
-        ex = terminal[:x] - player.x
-        ey = terminal[:y] - player.y
-        next if ex * ex + ey * ey > Config::RADAR_RANGE_SQ
+        ex = terminal[:x] - px
+        ey = terminal[:y] - py
+        next if ex * ex + ey * ey > range_sq
 
         rx = -(ex * cos_a - ey * sin_a)
         ry = -(ex * sin_a + ey * cos_a)
-        sx = r + (rx / Config::RADAR_RANGE * r).round
-        sy = r + (ry / Config::RADAR_RANGE * r).round
-        next unless sx.between?(0, diam - 1) && sy.between?(0, diam - 1)
+        sx = r + (rx / range * r).round
+        sy = r + (ry / range * r).round
+        next if sx < 0 || sx >= diam || sy < 0 || sy >= diam
 
-        d2 = (sx - r)**2 + (sy - r)**2
-        next if d2 > r * r
+        dxr = sx - r
+        dyr = sy - r
+        next if dxr * dxr + dyr * dyr > r_sq
 
-        terminal_cells[[sy, sx]] = terminal
+        terminal_cells[sy * diam + sx] = terminal
       end
 
-      ally_cells = {}
       allies.each do |ally|
-        ex = ally.x - player.x
-        ey = ally.y - player.y
-        next if ex * ex + ey * ey > Config::RADAR_RANGE_SQ
+        ex = ally.x - px
+        ey = ally.y - py
+        next if ex * ex + ey * ey > range_sq
 
         rx = -(ex * cos_a - ey * sin_a)
         ry = -(ex * sin_a + ey * cos_a)
-        sx = r + (rx / Config::RADAR_RANGE * r).round
-        sy = r + (ry / Config::RADAR_RANGE * r).round
-        next unless sx.between?(0, diam - 1) && sy.between?(0, diam - 1)
+        sx = r + (rx / range * r).round
+        sy = r + (ry / range * r).round
+        next if sx < 0 || sx >= diam || sy < 0 || sy >= diam
 
-        d2 = (sx - r)**2 + (sy - r)**2
-        next if d2 > r * r
+        dxr = sx - r
+        dyr = sy - r
+        next if dxr * dxr + dyr * dyr > r_sq
 
-        ally_cells[[sy, sx]] = true
+        ally_cells[sy * diam + sx] = true
       end
 
       alive_count = enemies.count(&:alive)
@@ -402,21 +465,25 @@ module Termfront
       info_lines = [
         "Enemies: #{alive_count}/#{total_count}",
         "Heading: #{format("%.0f", (player.angle % (Math::PI * 2)) * 180 / Math::PI)}\xC2\xB0",
-        "Pos: (#{"%.1f" % player.x}, #{"%.1f" % player.y})  T:terminal"
+        "Pos: (#{"%.1f" % px}, #{"%.1f" % py})  T:terminal"
       ]
 
-      radar_h.times do |row|
+      row = 0
+      while row < radar_h
         line = @radar_line_buf.clear
         if row < diam
           line << "  "
-          diam.times do |cx|
-            if (etype = enemy_cells[[row, cx]])
+          cx = 0
+          base = row * diam
+          while cx < diam
+            key = base + cx
+            if (etype = enemy_cells[key])
               line << (etype == :executor ? RADAR_EXECUTOR : RADAR_CRAWLER)
-            elsif ally_cells[[row, cx]]
+            elsif ally_cells[key]
               line << RADAR_ALLY
-            elsif (drop = drop_cells[[row, cx]])
+            elsif (drop = drop_cells[key])
               line << radar_drop_glyph(drop)
-            elsif terminal_cells[[row, cx]]
+            elsif terminal_cells[key]
               line << RADAR_TERMINAL
             elsif row == r && cx == r
               line << RADAR_PLAYER
@@ -425,28 +492,36 @@ module Termfront
             else
               line << grid[row][cx]
             end
+            cx += 1
           end
           line << (row < info_lines.size ? "    #{info_lines[row]}" : "")
         end
         buf << TerminalOutput.fit_ansi(line, cols)
         buf << "\r\n" if row < radar_h - 1
+        row += 1
       end
     end
 
     def overlay_enemies_3d(pixels, view_h, view_w, dists, player, enemies, projectiles, drops)
       dx = Math.cos(player.angle)
       dy = Math.sin(player.angle)
-      px = -dy * Math.tan(Config::FOV / 2.0)
-      py = dx * Math.tan(Config::FOV / 2.0)
+      tan_half_fov = Math.tan(Config::FOV / 2.0)
+      px = -dy * tan_half_fov
+      py = dx * tan_half_fov
       virt_h = view_h * 2
+      half_virt_h = virt_h / 2
+      half_view_w = view_w / 2.0
+      view_w_last = view_w - 1
       inv = 1.0 / (px * dy - py * dx)
+      player_x = player.x
+      player_y = player.y
 
       @enemy_sprites.clear
       enemies.each do |e|
         next unless e.alive
 
-        ex = e.x - player.x
-        ey = e.y - player.y
+        ex = e.x - player_x
+        ey = e.y - player_y
         tx = inv * (dy * ex - dx * ey)
         tz = inv * (-py * ex + px * ey)
         next if tz < 0.2
@@ -456,8 +531,8 @@ module Termfront
 
       @proj_sprites.clear
       projectiles.each do |p|
-        ex = p.x - player.x
-        ey = p.y - player.y
+        ex = p.x - player_x
+        ey = p.y - player_y
         tx = inv * (dy * ex - dx * ey)
         tz = inv * (-py * ex + px * ey)
         next if tz < 0.2
@@ -468,78 +543,94 @@ module Termfront
       @enemy_sprites.sort! { |a, b| b[0] <=> a[0] }
 
       @enemy_sprites.each do |tz, tx, e|
-        sx = ((view_w / 2.0) * (1 + tx / tz)).to_i
+        sx = (half_view_w * (1 + tx / tz)).to_i
         sprite_h = (virt_h / tz).to_i
-        draw_top = [(virt_h / 2 - sprite_h / 2), 0].max
-        draw_bot = [(virt_h / 2 + sprite_h / 2), virt_h].min
-        sprite_w = (sprite_h / 2.0).to_i
-        start_x = [sx - sprite_w / 2, 0].max
-        end_x   = [sx + sprite_w / 2, view_w - 1].min
+        draw_top = half_virt_h - sprite_h / 2
+        draw_top = 0 if draw_top < 0
+        draw_bot = half_virt_h + sprite_h / 2
+        draw_bot = virt_h if draw_bot > virt_h
+        sprite_w = sprite_h / 2
+        start_x = sx - sprite_w / 2
+        start_x = 0 if start_x < 0
+        end_x = sx + sprite_w / 2
+        end_x = view_w_last if end_x > view_w_last
 
         actual_h = draw_bot - draw_top
         actual_w = end_x - start_x + 1
         next if actual_h < 1 || actual_w < 1
 
-        fallback_color = e.sprite_id == :executor ? "100;60;200" : "220;140;30"
+        sprite_id = e.sprite_id
+        fallback_color = sprite_id == :executor ? "100;60;200" : "220;140;30"
         use_shape = actual_h >= 6
-
-        start_x.upto(end_x) do |c|
-          next if c < 0 || c >= view_w
-          next if dists[c] < tz
-
-          nx = (c - start_x).to_f / actual_w
-
-          r_top = (draw_top / 2.0).ceil
-          r_bot = (draw_bot / 2.0).floor
-          r_top.upto(r_bot - 1) do |r|
-            vp0 = r * 2
-            vp1 = r * 2 + 1
-            top_in = vp0 >= draw_top && vp0 < draw_bot
-            bot_in = vp1 >= draw_top && vp1 < draw_bot
-            next unless top_in || bot_in
-
-            if use_shape
-              ny0 = top_in ? (vp0 - draw_top).to_f / actual_h : nil
-              ny1 = bot_in ? (vp1 - draw_top).to_f / actual_h : nil
-              top_color = ny0 ? Sprite.for(e.sprite_id, nx, ny0) : nil
-              bot_color = ny1 ? Sprite.for(e.sprite_id, nx, ny1) : nil
-              next unless top_color || bot_color
-
-              pixels[vp0][c] = top_color if top_color
-              pixels[vp1][c] = bot_color if bot_color
-            else
-              pixels[vp0][c] = fallback_color if top_in
-              pixels[vp1][c] = fallback_color if bot_in
+        r_top = (draw_top + 1) >> 1
+        r_bot = draw_bot >> 1
+        actual_h_f = actual_h.to_f
+        actual_w_f = actual_w.to_f
+
+        c = start_x
+        while c <= end_x
+          if c >= 0 && c < view_w && dists[c] >= tz
+            nx = (c - start_x) / actual_w_f
+
+            r = r_top
+            while r < r_bot
+              vp0 = r << 1
+              vp1 = vp0 + 1
+              top_in = vp0 >= draw_top && vp0 < draw_bot
+              bot_in = vp1 >= draw_top && vp1 < draw_bot
+
+              if top_in || bot_in
+                if use_shape
+                  ny0 = top_in ? (vp0 - draw_top) / actual_h_f : nil
+                  ny1 = bot_in ? (vp1 - draw_top) / actual_h_f : nil
+                  top_color = ny0 ? Sprite.for(sprite_id, nx, ny0) : nil
+                  bot_color = ny1 ? Sprite.for(sprite_id, nx, ny1) : nil
+                  if top_color || bot_color
+                    pixels[vp0][c] = top_color if top_color
+                    pixels[vp1][c] = bot_color if bot_color
+                  end
+                else
+                  pixels[vp0][c] = fallback_color if top_in
+                  pixels[vp1][c] = fallback_color if bot_in
+                end
+              end
+              r += 1
             end
           end
+          c += 1
         end
 
         next unless e.max_hp > 1
 
-        bar_row = (draw_top / 2.0).ceil - 1
+        bar_row = r_top - 1
         next unless bar_row >= 0 && bar_row < view_h
 
-        bar_w = [actual_w, 2].max
-        bar_sx = [sx - bar_w / 2, 0].max
-        bar_ex = [bar_sx + bar_w - 1, view_w - 1].min
+        bar_w = actual_w > 2 ? actual_w : 2
+        bar_sx = sx - bar_w / 2
+        bar_sx = 0 if bar_sx < 0
+        bar_ex = bar_sx + bar_w - 1
+        bar_ex = view_w_last if bar_ex > view_w_last
         hp_pct = e.hp.to_f / e.max_hp
         filled = (hp_pct * (bar_ex - bar_sx + 1)).ceil
-        bar_sx.upto(bar_ex) do |c|
-          next if c < 0 || c >= view_w
-          next if dists[c] < tz
-
-          ci = c - bar_sx
-          color = ci < filled ? "0;200;0" : "200;0;0"
-          pixels[bar_row * 2][c] = color
-          pixels[bar_row * 2 + 1][c] = color
+        bar_vp0 = bar_row << 1
+        bar_vp1 = bar_vp0 + 1
+        c = bar_sx
+        while c <= bar_ex
+          if c >= 0 && c < view_w && dists[c] >= tz
+            ci = c - bar_sx
+            color = ci < filled ? "0;200;0" : "200;0;0"
+            pixels[bar_vp0][c] = color
+            pixels[bar_vp1][c] = color
+          end
+          c += 1
         end
       end
 
       # Render weapon drops
       @drop_sprites.clear
       drops.each do |d|
-        ex = d.x - player.x
-        ey = d.y - player.y
+        ex = d.x - player_x
+        ey = d.y - player_y
         tx = inv * (dy * ex - dx * ey)
         tz = inv * (-py * ex + px * ey)
         next if tz < 0.2
@@ -549,70 +640,83 @@ module Termfront
       @drop_sprites.sort! { |a, b| b[0] <=> a[0] }
 
       @drop_sprites.each do |tz, tx, d|
-        sx = ((view_w / 2.0) * (1 + tx / tz)).to_i
-        sprite_h = (virt_h / tz * 0.3).to_i.clamp(2, virt_h / 2)
-        ground = (virt_h / 2 + virt_h / tz * 0.35).to_i
-        draw_bot = [ground, virt_h].min
-        draw_top = [draw_bot - sprite_h, 0].max
-        sprite_w = (sprite_h / 2.0).to_i.clamp(1, 6)
-        start_x = [sx - sprite_w / 2, 0].max
-        end_x   = [sx + sprite_w / 2, view_w - 1].min
+        sx = (half_view_w * (1 + tx / tz)).to_i
+        sprite_h = (virt_h / tz * 0.3).to_i.clamp(2, half_virt_h)
+        ground = (half_virt_h + virt_h / tz * 0.35).to_i
+        draw_bot = ground < virt_h ? ground : virt_h
+        draw_top = draw_bot - sprite_h
+        draw_top = 0 if draw_top < 0
+        sprite_w = (sprite_h / 2).clamp(1, 6)
+        start_x = sx - sprite_w / 2
+        start_x = 0 if start_x < 0
+        end_x = sx + sprite_w / 2
+        end_x = view_w_last if end_x > view_w_last
 
         color = d.sprite_color
-
-        start_x.upto(end_x) do |c|
-          next if c < 0 || c >= view_w
-          next if dists[c] < tz
-
-          r_top = (draw_top / 2.0).ceil
-          r_bot = (draw_bot / 2.0).floor
-          r_top.upto(r_bot - 1) do |r|
-            next if r < 0 || r >= view_h
-
-            vp0 = r * 2
-            vp1 = r * 2 + 1
-            top_in = vp0 >= draw_top && vp0 < draw_bot
-            bot_in = vp1 >= draw_top && vp1 < draw_bot
-            next unless top_in || bot_in
-
-            pixels[vp0][c] = color if top_in
-            pixels[vp1][c] = color if bot_in
+        r_top = (draw_top + 1) >> 1
+        r_bot = draw_bot >> 1
+
+        c = start_x
+        while c <= end_x
+          if c >= 0 && c < view_w && dists[c] >= tz
+            r = r_top
+            while r < r_bot
+              if r >= 0 && r < view_h
+                vp0 = r << 1
+                vp1 = vp0 + 1
+                top_in = vp0 >= draw_top && vp0 < draw_bot
+                bot_in = vp1 >= draw_top && vp1 < draw_bot
+                if top_in || bot_in
+                  pixels[vp0][c] = color if top_in
+                  pixels[vp1][c] = color if bot_in
+                end
+              end
+              r += 1
+            end
           end
+          c += 1
         end
       end
 
       # Render projectiles
       @proj_sprites.sort! { |a, b| b[0] <=> a[0] }
       @proj_sprites.each do |tz, tx, p|
-        sx = ((view_w / 2.0) * (1 + tx / tz)).to_i
+        sx = (half_view_w * (1 + tx / tz)).to_i
         pw = (4.0 / tz).ceil.clamp(1, 5)
         ph = (virt_h / tz * 0.15).ceil.clamp(2, 6)
-        vmid = virt_h / 2
-        draw_top = [(vmid - ph / 2), 0].max
-        draw_bot = [(vmid + ph / 2).clamp(draw_top + 2, virt_h), virt_h].min
-        start_x = [sx - pw / 2, 0].max
-        end_x   = [sx + pw / 2, view_w - 1].min
-        col_code = p.type == :executor ? "94" : "93"
-
-        start_x.upto(end_x) do |c|
-          next if c < 0 || c >= view_w
-          next if dists[c] < tz
-
-          r_top = (draw_top / 2.0).ceil
-          r_bot = [(draw_bot / 2.0).floor, r_top + 1].max
-          r_top.upto(r_bot - 1) do |r|
-            next if r < 0 || r >= view_h
-
-            vp0 = r * 2
-            vp1 = r * 2 + 1
-            top_in = vp0 >= draw_top && vp0 < draw_bot
-            bot_in = vp1 >= draw_top && vp1 < draw_bot
-            next unless top_in || bot_in
-
-            proj_color = col_code == "94" ? "94;94;255" : "255;210;80"
-            pixels[vp0][c] = proj_color if top_in
-            pixels[vp1][c] = proj_color if bot_in
+        draw_top = half_virt_h - ph / 2
+        draw_top = 0 if draw_top < 0
+        draw_bot = half_virt_h + ph / 2
+        draw_bot = draw_top + 2 if draw_bot < draw_top + 2
+        draw_bot = virt_h if draw_bot > virt_h
+        start_x = sx - pw / 2
+        start_x = 0 if start_x < 0
+        end_x = sx + pw / 2
+        end_x = view_w_last if end_x > view_w_last
+        proj_color = p.type == :executor ? "94;94;255" : "255;210;80"
+        r_top = (draw_top + 1) >> 1
+        r_bot = draw_bot >> 1
+        r_bot = r_top + 1 if r_bot < r_top + 1
+
+        c = start_x
+        while c <= end_x
+          if c >= 0 && c < view_w && dists[c] >= tz
+            r = r_top
+            while r < r_bot
+              if r >= 0 && r < view_h
+                vp0 = r << 1
+                vp1 = vp0 + 1
+                top_in = vp0 >= draw_top && vp0 < draw_bot
+                bot_in = vp1 >= draw_top && vp1 < draw_bot
+                if top_in || bot_in
+                  pixels[vp0][c] = proj_color if top_in
+                  pixels[vp1][c] = proj_color if bot_in
+                end
+              end
+              r += 1
+            end
           end
+          c += 1
         end
       end
     end

data/lib/termfront/terminal_output.rb

@@ -3,7 +3,6 @@
 module Termfront
   module TerminalOutput
     module_function
-    ANSI_PATTERN = /\e\[[0-9;]*[A-Za-z]/.freeze
 
     def begin_frame(home: false, clear: false)
       buf = +""
@@ -17,25 +16,41 @@ module Termfront
     end
 
     def fit_ansi(text, width)
-      visible = 0
       out = +""
-      index = 0
+      visible = 0
+      any_ansi = false
+      i = 0
+      len = text.bytesize
+      segment_start = 0
 
-      while index < text.length && visible < width
-        if (match = ANSI_PATTERN.match(text, index)) && match.begin(0) == index
-          out << match[0]
-          index = match.end(0)
-          next
-        end
+      while i < len
+        byte = text.getbyte(i)
+        if byte == 0x1B
+          out << text.byteslice(segment_start, i - segment_start) if i > segment_start
 
-        char = text[index]
-        out << char
-        visible += 1
-        index += 1
+          esc_start = i
+          i += 1
+          while i < len
+            b = text.getbyte(i)
+            i += 1
+            break if (b >= 65 && b <= 90) || (b >= 97 && b <= 122)
+          end
+          out << text.byteslice(esc_start, i - esc_start)
+          any_ansi = true
+          segment_start = i
+        else
+          if (byte & 0xC0) != 0x80
+            break if visible >= width
+
+            visible += 1
+          end
+          i += 1
+        end
       end
 
-      out << "\e[0m" if out.include?("\e[")
-      out << (" " * (width - visible)) if visible < width
+      out << text.byteslice(segment_start, i - segment_start) if i > segment_start
+      out << "\e[0m" if any_ansi
+      (width - visible).times { out << " " } if visible < width
       out
     end
 

data/lib/termfront/title_screen.rb

@@ -7,12 +7,30 @@ module Termfront
       [13.0, 8.0], [10.0, 8.5], [5.0, 8.5], [2.5, 5.0]
     ].freeze
 
+    TITLE_TEXT = "T E R M F R O N T"
+    SUB_TEXT = "Terminal FPS"
+    MENU_ITEMS = ["[P] PvP", "[F] Wavesfight", "[C] Campaign", "[S] Training", "[Q] Quit"].freeze
+
     def initialize(stdout)
       @stdout = stdout
       @title_spin = 0.0
       @demo_wp_idx = 0
       @demo_wp_t = 0.0
       @demo_fire = 0
+
+      mission_class = Mission::Base.campaign.first
+      if mission_class
+        m = mission_class.new
+        @demo_map = m.map_data.map { |row| row.is_a?(Array) ? row : row.chars }.freeze
+        @demo_map_h = @demo_map.size
+        @demo_map_w = @demo_map[0].size
+        @demo_enemies = m.enemy_defs.freeze
+      end
+
+      @static_lines_cols = 0
+      @static_title_line = nil
+      @static_sub_line = nil
+      @static_menu_lines = nil
     end
 
     def show
@@ -24,11 +42,15 @@ module Termfront
       TerminalOutput.write_all(@stdout, TerminalOutput.begin_frame(home: true, clear: true) + TerminalOutput.end_frame)
 
       STDIN.raw do |stdin|
+        last_render = clock - Config::RENDER_DT
         loop do
           now = clock
           @title_spin += 0.015
 
-          render
+          if now - last_render >= Config::RENDER_DT
+            render
+            last_render = now
+          end
 
           while IO.select([stdin], nil, nil, 0)
             begin
@@ -60,6 +82,20 @@ module Termfront
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
+    def ensure_static_lines(cols)
+      return if @static_lines_cols == cols
+
+      tc = [(cols - TITLE_TEXT.size) / 2 + 1, 1].max
+      sc = [(cols - SUB_TEXT.size) / 2 + 1, 1].max
+      @static_title_line = TerminalOutput.fit_ansi("#{" " * (tc - 1)}\e[1;38;2;120;140;255m#{TITLE_TEXT}\e[0m", cols)
+      @static_sub_line = TerminalOutput.fit_ansi("#{" " * (sc - 1)}\e[38;2;80;80;120m#{SUB_TEXT}\e[0m", cols)
+      @static_menu_lines = MENU_ITEMS.map do |item|
+        ic = [(cols - item.size) / 2 + 1, 1].max
+        TerminalOutput.fit_ansi("#{" " * (ic - 1)}\e[97m#{item}\e[0m", cols)
+      end
+      @static_lines_cols = cols
+    end
+
     def render
       rows, cols = @stdout.winsize
       rows = [rows, 10].max
@@ -76,13 +112,11 @@ module Termfront
       virt_h = th * 2
       color = Array.new(tw * virt_h, nil)
 
-      mission = Mission::Base.campaign.first
-      return unless mission
+      return unless @demo_map
 
-      m = mission.new
-      demo_map = m.map_data.map { |r| r.is_a?(Array) ? r : r.chars }
-      dm_h = demo_map.size
-      dm_w = demo_map[0].size
+      demo_map = @demo_map
+      dm_h = @demo_map_h
+      dm_w = @demo_map_w
 
       @demo_wp_t += Config::DEMO_SPEED
       if @demo_wp_t >= 1.0
@@ -184,7 +218,7 @@ module Termfront
       end
 
       # Demo enemies
-      demo_enemies = m.enemy_defs
+      demo_enemies = @demo_enemies
       ddx = Math.cos(cam_a)
       ddy = Math.sin(cam_a)
       ppx = -ddy * Math.tan(fov / 2.0)
@@ -269,22 +303,16 @@ module Termfront
         lines[r] = TerminalOutput.fit_ansi(line, cols)
       end
 
-      # Title text
+      # Title text + menu items (memoized per cols)
+      ensure_static_lines(cols)
+
       title_row = [[th + 1, rows - 4].min, 1].max
-      title = "T E R M F R O N T"
-      sub   = "Terminal FPS"
-      tc = [(cols - title.size) / 2 + 1, 1].max
-      sc = [(cols - sub.size) / 2 + 1, 1].max
-      lines[title_row - 1] = TerminalOutput.fit_ansi("#{" " * (tc - 1)}\e[1;38;2;120;140;255m#{title}\e[0m", cols)
-      lines[title_row] = TerminalOutput.fit_ansi("#{" " * (sc - 1)}\e[38;2;80;80;120m#{sub}\e[0m", cols)
-
-      # Menu items
-      items = ["[P] PvP", "[F] Wavesfight", "[C] Campaign", "[S] Training", "[Q] Quit"]
-      items_count_for_menu = items.size
-      menu_row = [[title_row + 2, rows - items_count_for_menu].min, 1].max
-      items.each_with_index do |item, i|
-        ic = [(cols - item.size) / 2 + 1, 1].max
-        lines[menu_row + i - 1] = TerminalOutput.fit_ansi("#{" " * (ic - 1)}\e[97m#{item}\e[0m", cols)
+      lines[title_row - 1] = @static_title_line
+      lines[title_row] = @static_sub_line
+
+      menu_row = [[title_row + 2, rows - MENU_ITEMS.size].min, 1].max
+      @static_menu_lines.each_with_index do |menu_line, i|
+        lines[menu_row + i - 1] = menu_line
       end
 
       lines.each_with_index do |line, index|

data/lib/termfront/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Termfront
-  VERSION = "0.1.5"
+  VERSION = "0.1.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: termfront
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - S-H-GAMELINKS