termfront 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68852aaca6be7127d8b644aae4670a56e72d5528b249dc081d72ba0d22c5f74a
-  data.tar.gz: 440209c869681acd0f9d77d65fb367e6d055c2ffe3a5a57821dd530912199ecd
+  metadata.gz: b6d91fa7b7758b2151fc31bb9f7862dbda3ad311edea638aa9b11ca50a8b9a8d
+  data.tar.gz: 3a8ce081de76ddd04c45949c490ba4b513f42eb94eb39fce37fef292abdbb004
 SHA512:
-  metadata.gz: 6efb979956fa649ee558ad0190547fd70c62fda5ef8b8ca4dc06f513c15c87c02c74151756486615a0cc21301e6b45d6f62e01e58230ae28b574ceb3570053ae
-  data.tar.gz: 12dfe9fde65aa1517facf4e7e21a37b6db9550e5cc99663801efb33db74f1a1b88af2503c6c6c54be70d60374328009f85334422413737514845602091f70893
+  metadata.gz: a79ab596683eea6f8914c17cf88ad000d7a1b33453820526310f25fd43dbabb1f21e6f65f16a390fa92e491d6cd2da86e981c17bc971161316a6d4f7b431c98a
+  data.tar.gz: 556667b34ba430c7af848fca7d31f5937e24d328480a29a3191db88ca4286d579081b0f6e18c34622d87cb9ea401c20e19da6aaf0a6fbc2b892f15fdbb9f7b76

data/CHANGELOG.md

@@ -6,6 +6,46 @@ The format is based on Keep a Changelog, and this project follows Semantic Versi
 
 ## [Unreleased]
 
+## [0.1.7] - 2026-05-26
+
+### Changed
+
+- Restore the in-game and title screen render rate to 60 Hz (`Config::RENDER_DT = 1.0 / 60.0`) after testers reported choppy motion at 30 Hz; the hybrid rendering scaffolding is kept in place so the rate can be tuned later without code changes
+- Cap the per-frame `dt` at `Config::MAX_DT` (50 ms / 20 FPS-equivalent) in the singleplayer, Wavesfight, and PvP game loops so a frame that runs long under a constrained host no longer translates into a single oversized physics step. Movement, weapon timers, and projectile motion now stay smooth — the simulation simply slows for that frame instead of producing a teleporting opponent or instant fire-rate
+- Hoist the sprite shape function out of the per-cell loop in `Renderer#overlay_enemies_3d`: look up `Sprite::REGISTRY[sprite_id]` once per enemy and call it directly from the inner cell loop instead of going through `Sprite.for` (which re-hashed `REGISTRY` and re-checked the result for `nil` on every cell). With several enemies on-screen the per-cell hash lookup overhead disappears
+- Migrate the PvP/Wavesfight client render paths to 256-color SGR sequences as well: add a `Sprite.player_enemy` variant pre-tinted toward red instead of recomputing the tint per cell, replace the per-cell `\e[38;2;…m` (and `\e[48;2;…m` for damage flash) escapes with `\e[38;5;Nm` lookups, drop the `tint_player_color` helper and its per-cell `String#split`/`Array#map` work, and reuse the renderer's shared `DAMAGE_FLASH_RAMP` for the screen-edge flash
+- Hand frame output off to a dedicated writer thread (`AsyncWriter`) so the game loop's `syswrite` becomes a non-blocking `Queue#push` and the actual `IO#syswrite` runs on a background thread that releases the GVL during the PTY write. The main loop no longer pays the wall-clock cost of waiting for the terminal to drain its buffer; when a write is still in progress, the latest frame replaces the queued one so the terminal always sees the freshest frame instead of a backlog
+- Drop truecolor SGR sequences from the in-game and title 3D views; convert every sprite, fallback, bar, projectile, drop, and damage-flash color to an xterm 256-color index once with `Color.rgb_to_256`, simplify `Renderer#render_view` to a pure 256-color path that drops the per-cell `is_a?(Integer)` test and the truecolor SGR caches, and switch the title screen's half-block compositor to look up its escapes in the shared `FG_256` / `BG_256` tables. The 13-byte truecolor SGR shrinks to a 9-byte 256-color SGR (or shorter on cell boundaries via `\e[K`), the renderer's hottest cell loop loses its type dispatch, and the dead `bg_only?` / `ansi_fg` / `ansi_bg` helpers go away
+- Build the half-block rows in `TitleScreen#render` directly into the final per-row string with the column count already capped, skipping the per-row `TerminalOutput.fit_ansi` walk entirely; rows that come out uniformly the same color collapse to `\e[bg]\e[K\e[0m`, fully-blank rows ship as a single space run, and the byte stream the terminal sees for each title frame shrinks substantially
+- Coalesce same-color cell runs in `TitleScreen#render`'s half-block compositor and only emit SGR escapes on transitions instead of wrapping every cell in `\e[…m…\e[0m`; the per-row string handed to `fit_ansi` shrinks from one bracketed SGR per cell to a handful of color changes, cutting both the title frame's byte volume and `fit_ansi`'s per-row scan cost
+- Emit `\e[K` (Erase to End of Line) for rows in `Renderer#render_view` whose top/bottom cells are all the same integer background color; the ceiling-only and floor-only bands now ship as `\e[bg]\e[K\r\n` per row instead of the full per-cell glyph sequence, slashing the ANSI byte volume of those rows from `view_w` bytes plus per-cell SGR transitions down to about a dozen bytes total
+- Memoize `AudioManager#which` results in a class-level cache so the per-command `PATH` walk (and the per-directory `File.executable?` stat) only runs the first time a binary is looked up; subsequent `AudioManager.new` calls during mode transitions hit the cache instead of re-scanning `PATH`, which removes a noticeable stutter on WSL hosts where Windows-mounted `PATH` entries are slow to stat
+- Coalesce same-color runs of cells in `Renderer#render_view` with a single `String#*` instead of one `buf << " "` (or `buf << "█"`) per cell, and rewrite the row/column loops as `while` so the ceiling/floor bands cost one short string copy per row instead of dozens of one-byte appends
+- Skip the per-column DDA in `Renderer#render` when the player position, facing, map, and viewport are unchanged from the previous frame; the cached `@dists`, `@sides`, `@wtop`, `@wbot`, and `@wcol` arrays are reused so `cast_ray` and the wall-column projection only run when something actually moved
+- Bulk-fill the ceiling-only and floor-only rows of `Renderer#build_view_pixels` with `Array#fill` so each fully ceiling or fully floor row is written as a single C-level call, with the column-major wall loop kept for the mixed band in the middle
+
+### Fixed
+
+- Treat `Errno::EAGAIN` from `syswrite` the same as `IO::WaitWritable` in `TerminalOutput.write_all` so the renderer keeps draining its frame buffer instead of crashing when the terminal's PTY temporarily refuses additional bytes
+
+## [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/async_writer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Termfront
+  class AsyncWriter
+    def initialize(io)
+      @io = io
+      @queue = Queue.new
+      @closed = false
+      @thread = Thread.new do
+        Thread.current.report_on_exception = false
+        while (data = @queue.pop)
+          begin
+            TerminalOutput.write_all(@io, data)
+          rescue IOError, Errno::EBADF, Errno::EPIPE
+            break
+          end
+        end
+      end
+    end
+
+    def syswrite(data)
+      raise IOError, "writer closed" if @closed
+
+      @queue.clear if @queue.size >= 1
+      @queue.push(data)
+      data.bytesize
+    end
+
+    def winsize
+      @io.winsize
+    end
+
+    def raw(&block)
+      @io.raw(&block)
+    end
+
+    def close
+      return if @closed
+
+      @closed = true
+      @queue.push(nil)
+      @thread.join
+    end
+  end
+end

data/lib/termfront/audio_manager.rb

@@ -8,6 +8,8 @@ module Termfront
   class AudioManager
     Player = Struct.new(:command, :supports_loop, keyword_init: true)
 
+    WHICH_CACHE = {}
+
     def initialize
       @manifest = load_manifest
       @bgm_player = detect_player(%w[ffplay afplay paplay aplay], prefer_loop: true)
@@ -160,12 +162,18 @@ module Termfront
     end
 
     def which(command)
+      return WHICH_CACHE[command] if WHICH_CACHE.key?(command)
+
+      resolved = nil
       ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).each do |dir|
         candidate = File.join(dir, command)
-        return candidate if File.executable?(candidate) && !File.directory?(candidate)
+        if File.executable?(candidate) && !File.directory?(candidate)
+          resolved = candidate
+          break
+        end
       end
 
-      nil
+      WHICH_CACHE[command] = resolved
     end
 
     def asset_path(kind, name)

data/lib/termfront/color.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Termfront
+  module Color
+    module_function
+
+    def rgb_to_256(r, g, b)
+      if (r - g).abs < 8 && (g - b).abs < 8 && (r - b).abs < 8
+        avg = (r + g + b) / 3
+        return 16 if avg < 8
+        return 231 if avg > 247
+
+        232 + (avg - 8) * 23 / 240
+      else
+        16 + (r * 5 / 255) * 36 + (g * 5 / 255) * 6 + (b * 5 / 255)
+      end
+    end
+  end
+end

data/lib/termfront/config.rb

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

data/lib/termfront/drop_item/weapon.rb

@@ -22,8 +22,11 @@ module Termfront
         end
       end
 
+      SHOCK_COLOR  = Color.rgb_to_256(60, 200, 220)
+      NORMAL_COLOR = Color.rgb_to_256(220, 200, 60)
+
       def sprite_color
-        @type.to_s.start_with?("shock") ? "60;200;220" : "220;200;60"
+        @type.to_s.start_with?("shock") ? SHOCK_COLOR : NORMAL_COLOR
       end
 
       def radar_color

data/lib/termfront/game.rb

@@ -3,7 +3,7 @@
 module Termfront
   class Game
     def initialize
-      @stdout = STDOUT
+      @stdout = AsyncWriter.new(STDOUT)
       @audio = AudioManager.new
       @renderer = Renderer.new(@stdout)
       @input = Input.new
@@ -36,6 +36,7 @@ module Termfront
       @crash = e
     ensure
       @audio.close
+      @stdout.close if @stdout.respond_to?(:close) && !@stdout.equal?(STDOUT)
       leave_alt_screen
       if @crash
         warn "#{@crash.class}: #{@crash.message}"
@@ -131,10 +132,12 @@ 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
           dt = now - last_time
+          dt = Config::MAX_DT if dt > Config::MAX_DT
           last_time = now
 
           keys = @input.process(stdin, player: @player)
@@ -146,11 +149,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,10 +182,12 @@ module Termfront
     def run_wavesfight_loop
       STDIN.raw do |stdin|
         last_time = clock
+        last_render = last_time - Config::RENDER_DT
 
         loop do
           now = clock
           dt = now - last_time
+          dt = Config::MAX_DT if dt > Config::MAX_DT
           last_time = now
 
           keys = @input.process(stdin, player: @player)
@@ -191,12 +199,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 +220,7 @@ module Termfront
             show_wave_clear
             start_wavesfight_wave
             last_time = clock
+            last_render = clock - Config::RENDER_DT
           end
 
           cap_frame(now)
@@ -543,62 +555,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/network/client.rb

@@ -6,6 +6,14 @@ module Termfront
       TEAM_SIZES = [1, 2, 4].freeze
       ALLOWED_WEAPONS = %w[pistol ar].freeze
 
+      ALLY_PLAYER_FALLBACK  = Color.rgb_to_256(70, 210, 255)
+      ENEMY_PLAYER_FALLBACK = Color.rgb_to_256(255, 110, 80)
+      ALLY_BAR_FILL         = Color.rgb_to_256(0, 180, 255)
+      ENEMY_BAR_FILL        = Color.rgb_to_256(255, 80, 80)
+      BAR_EMPTY             = Color.rgb_to_256(80, 20, 20)
+      PROJ_SHOCK            = Color.rgb_to_256(80, 220, 255)
+      PROJ_NORMAL           = Color.rgb_to_256(255, 210, 80)
+
       def initialize(stdout)
         @stdout = stdout
         @conn = Connection.new
@@ -199,6 +207,7 @@ module Termfront
           loop do
             now = clock
             dt = now - last_time
+            dt = Config::MAX_DT if dt > Config::MAX_DT
             last_time = now
 
             keys = @input.process(stdin, player: @player)
@@ -548,33 +557,34 @@ module Termfront
             next unless top_in || bot_in
 
             if use_shape
+              sprite_fn = color_mode == :ally ? Sprite.method(:player) : Sprite.method(:player_enemy)
               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 ? tint_player_color(Sprite.player(nx, ny0), color_mode) : nil
-              bot_color = ny1 ? tint_player_color(Sprite.player(nx, ny1), color_mode) : nil
+              top_color = ny0 ? sprite_fn.call(nx, ny0) : nil
+              bot_color = ny1 ? sprite_fn.call(nx, ny1) : nil
               next unless top_color || bot_color
 
               buf << "\e[#{3 + r};#{c + 1}H"
               buf << if top_color && bot_color
                        if top_color == bot_color
-                         "\e[38;2;#{top_color}m\xE2\x96\x88\e[0m"
+                         "\e[38;5;#{top_color}m\xE2\x96\x88\e[0m"
                        else
-                         "\e[38;2;#{top_color};48;2;#{bot_color}m\xE2\x96\x80\e[0m"
+                         "\e[38;5;#{top_color};48;5;#{bot_color}m\xE2\x96\x80\e[0m"
                        end
                      elsif top_color
-                       "\e[38;2;#{top_color}m\xE2\x96\x80\e[0m"
+                       "\e[38;5;#{top_color}m\xE2\x96\x80\e[0m"
                      else
-                       "\e[38;2;#{bot_color}m\xE2\x96\x84\e[0m"
+                       "\e[38;5;#{bot_color}m\xE2\x96\x84\e[0m"
                      end
             else
-              fc = color_mode == :ally ? "70;210;255" : "255;110;80"
+              fc = color_mode == :ally ? ALLY_PLAYER_FALLBACK : ENEMY_PLAYER_FALLBACK
               buf << "\e[#{3 + r};#{c + 1}H"
               buf << if top_in && bot_in
-                       "\e[38;2;#{fc}m\xE2\x96\x88\e[0m"
+                       "\e[38;5;#{fc}m\xE2\x96\x88\e[0m"
                      elsif top_in
-                       "\e[38;2;#{fc}m\xE2\x96\x80\e[0m"
+                       "\e[38;5;#{fc}m\xE2\x96\x80\e[0m"
                      else
-                       "\e[38;2;#{fc}m\xE2\x96\x84\e[0m"
+                       "\e[38;5;#{fc}m\xE2\x96\x84\e[0m"
                      end
             end
           end
@@ -590,15 +600,15 @@ module Termfront
         max_total = Config::SHIELD_MAX + Config::HEALTH_MAX
         hp_pct = total.to_f / max_total
         filled = (hp_pct * (bar_ex - bar_sx + 1)).ceil
-        fill_color = color_mode == :ally ? "0;180;255" : "255;80;80"
+        fill_color = color_mode == :ally ? ALLY_BAR_FILL : ENEMY_BAR_FILL
 
         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 ? fill_color : "80;20;20"
-          buf << "\e[#{3 + bar_row};#{c + 1}H\e[38;2;#{color}m\xE2\x96\x88\e[0m"
+          color = ci < filled ? fill_color : BAR_EMPTY
+          buf << "\e[#{3 + bar_row};#{c + 1}H\e[38;5;#{color}m\xE2\x96\x88\e[0m"
         end
       end
 
@@ -649,28 +659,17 @@ module Termfront
               proj_color = projectile[:color]
               buf << "\e[#{3 + r};#{c + 1}H"
               buf << if top_in && bot_in
-                       "\e[38;2;#{proj_color}m\xE2\x96\x88\e[0m"
+                       "\e[38;5;#{proj_color}m\xE2\x96\x88\e[0m"
                      elsif top_in
-                       "\e[38;2;#{proj_color}m\xE2\x96\x80\e[0m"
+                       "\e[38;5;#{proj_color}m\xE2\x96\x80\e[0m"
                      else
-                       "\e[38;2;#{proj_color}m\xE2\x96\x84\e[0m"
+                       "\e[38;5;#{proj_color}m\xE2\x96\x84\e[0m"
                      end
             end
           end
         end
       end
 
-      def tint_player_color(color, mode)
-        return nil unless color
-        return color if mode == :ally
-
-        r, g, b = color.split(";").map(&:to_i)
-        nr = [[r + 70, 255].min, 0].max
-        ng = [[g - 50, 0].max, 0].max
-        nb = [[b - 90, 0].max, 0].max
-        "#{nr};#{ng};#{nb}"
-      end
-
       def render_pvp_hud(buf, cols)
         bar_w = [cols - 30, 10].max
         pct = @player.shield / Config::SHIELD_MAX.to_f
@@ -806,13 +805,15 @@ module Termfront
       def render_damage_flash(buf, view_h, view_w)
         return unless @player.damage_flash > 0
 
-        intensity = @player.damage_flash * 60
+        intensity = (@player.damage_flash * 60).to_i
+        intensity = 255 if intensity > 255
+        color = Renderer::DAMAGE_FLASH_RAMP[intensity]
         flash_w = 2
 
         view_h.times do |r|
-          buf << "\e[#{3 + r};1H\e[48;2;#{intensity};0;0m#{" " * flash_w}\e[0m"
+          buf << "\e[#{3 + r};1H\e[48;5;#{color}m#{" " * flash_w}\e[0m"
           rc = [view_w - flash_w + 1, 1].max
-          buf << "\e[#{3 + r};#{rc}H\e[48;2;#{intensity};0;0m#{" " * flash_w}\e[0m"
+          buf << "\e[#{3 + r};#{rc}H\e[48;5;#{color}m#{" " * flash_w}\e[0m"
         end
       end
 
@@ -849,7 +850,7 @@ module Termfront
 
       def spawn_remote_projectile_effect(msg)
         shock = msg[:w].to_s.start_with?("shock")
-        color = shock ? "80;220;255" : "255;210;80"
+        color = shock ? PROJ_SHOCK : PROJ_NORMAL
         speed = shock ? 18.0 : 14.0
         angle = msg[:a]
         @projectiles << {

data/lib/termfront/network/wavesfight_client.rb

@@ -57,7 +57,7 @@ module Termfront
             lines[rows / 2 - 2] = TerminalOutput.fit_ansi("#{" " * (mc - 1)}\e[1;93m#{msg}\e[0m", cols)
             detail = "#{queued_mission_name}  |  #{queued_difficulty_name}"
             dc = [(cols - detail.size) / 2 + 1, 1].max
-            lines[rows / 2] = TerminalOutput.fit_ansi("#{" " * (dc - 1)}\e[38;2;170;170;190m#{detail}\e[0m", cols)
+            lines[rows / 2] = TerminalOutput.fit_ansi("#{" " * (dc - 1)}\e[38;5;#{Color.rgb_to_256(170, 170, 190)}m#{detail}\e[0m", cols)
             hint = "(ESC to cancel)"
             hc = [(cols - hint.size) / 2 + 1, 1].max
             lines[rows / 2 + 2] = TerminalOutput.fit_ansi("#{" " * (hc - 1)}\e[90m#{hint}\e[0m", cols)
@@ -121,6 +121,7 @@ module Termfront
           loop do
             now = clock
             dt = now - last_time
+            dt = Config::MAX_DT if dt > Config::MAX_DT
             last_time = now
 
             keys = @input.process(stdin, player: @player)