termfront 0.1.0

data/lib/termfront/audio_manager.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require "json"
+require "shellwords"
+require "thread"
+
+module Termfront
+  class AudioManager
+    Player = Struct.new(:command, :supports_loop, keyword_init: true)
+
+    def initialize
+      @manifest = load_manifest
+      @bgm_player = detect_player(%w[ffplay afplay paplay aplay], prefer_loop: true)
+      @loop_se_player = detect_player(%w[ffplay afplay paplay aplay], prefer_loop: true)
+      @se_player = detect_player(%w[paplay afplay aplay ffplay], prefer_loop: false)
+      @mutex = Mutex.new
+      @bgm_pid = nil
+      @bgm_thread = nil
+      @bgm_stop = false
+      @loop_se_pid = nil
+      @loop_se_thread = nil
+      @loop_se_stop = false
+      @loop_se_name = nil
+    end
+
+    def play_bgm(name)
+      path = asset_path(:bgm, name)
+      return unless path
+
+      stop_bgm
+
+      @mutex.synchronize do
+        @bgm_stop = false
+        @bgm_thread = Thread.new do
+          if @bgm_player&.supports_loop
+            @bgm_pid = spawn_player(@bgm_player, path, loop_playback: true)
+            wait_for_channel(:bgm)
+          else
+            loop do
+              break if channel_stopped?(:bgm)
+
+              @bgm_pid = spawn_player(@bgm_player, path, loop_playback: false)
+              wait_for_channel(:bgm)
+              break if channel_stopped?(:bgm)
+            end
+          end
+        rescue StandardError
+          nil
+        ensure
+          @mutex.synchronize do
+            @bgm_pid = nil
+            @bgm_thread = nil
+          end
+        end
+      end
+    end
+
+    def stop_bgm
+      thread = nil
+      pid = nil
+
+      @mutex.synchronize do
+        @bgm_stop = true
+        thread = @bgm_thread
+        pid = @bgm_pid
+      end
+
+      terminate_process(pid) if pid
+      thread&.join(0.5)
+    end
+
+    def play_se(name)
+      path = asset_path(:se, name)
+      return unless path && @se_player
+
+      spawn_player(@se_player, path, loop_playback: false, detach: true)
+    rescue StandardError
+      nil
+    end
+
+    def play_loop_se(name)
+      path = asset_path(:loop_se, name) || asset_path(:se, name)
+      return unless path
+
+      @mutex.synchronize do
+        return if @loop_se_name == name && @loop_se_thread&.alive?
+      end
+
+      stop_loop_se
+
+      @mutex.synchronize do
+        @loop_se_stop = false
+        @loop_se_name = name
+        @loop_se_thread = Thread.new do
+          if @loop_se_player&.supports_loop
+            @loop_se_pid = spawn_player(@loop_se_player, path, loop_playback: true)
+            wait_for_channel(:loop_se)
+          else
+            loop do
+              break if channel_stopped?(:loop_se)
+
+              @loop_se_pid = spawn_player(@loop_se_player, path, loop_playback: false)
+              wait_for_channel(:loop_se)
+              break if channel_stopped?(:loop_se)
+            end
+          end
+        rescue StandardError
+          nil
+        ensure
+          @mutex.synchronize do
+            @loop_se_pid = nil
+            @loop_se_thread = nil
+            @loop_se_name = nil
+          end
+        end
+      end
+    end
+
+    def stop_loop_se(name = nil)
+      thread = nil
+      pid = nil
+
+      @mutex.synchronize do
+        return if name && @loop_se_name != name
+
+        @loop_se_stop = true
+        thread = @loop_se_thread
+        pid = @loop_se_pid
+      end
+
+      terminate_process(pid) if pid
+      thread&.join(0.5)
+    end
+
+    def close
+      stop_bgm
+      stop_loop_se
+    end
+
+    private
+
+    def load_manifest
+      path = File.expand_path("../../data/audio/manifest.json", __dir__)
+      JSON.parse(File.read(path))
+    rescue Errno::ENOENT, JSON::ParserError
+      {}
+    end
+
+    def detect_player(candidates, prefer_loop:)
+      found = candidates.filter_map do |command|
+        path = which(command)
+        next unless path
+
+        Player.new(command: command, supports_loop: command == "ffplay")
+      end
+
+      return found.find(&:supports_loop) if prefer_loop
+
+      found.first
+    end
+
+    def which(command)
+      ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).each do |dir|
+        candidate = File.join(dir, command)
+        return candidate if File.executable?(candidate) && !File.directory?(candidate)
+      end
+
+      nil
+    end
+
+    def asset_path(kind, name)
+      relative = @manifest.fetch(kind.to_s, {})[name.to_s]
+      return unless relative
+
+      path = File.expand_path("../../#{relative}", __dir__)
+      File.file?(path) ? path : nil
+    end
+
+    def spawn_player(player, path, loop_playback:, detach: false)
+      return unless player
+
+      command = command_for(player.command, path, loop_playback)
+      return unless command
+
+      pid = Process.spawn(*command, pgroup: true, out: File::NULL, err: File::NULL)
+      Process.detach(pid) if detach
+      pid
+    end
+
+    def command_for(command, path, loop_playback)
+      case command
+      when "ffplay"
+        ["ffplay", "-nodisp", "-autoexit", "-loglevel", "quiet", ("-loop" if loop_playback), ("0" if loop_playback), path].compact
+      when "afplay"
+        ["afplay", path]
+      when "paplay"
+        ["paplay", path]
+      when "aplay"
+        ["aplay", "-q", path]
+      end
+    end
+
+    def wait_for_channel(channel)
+      pid = nil
+      @mutex.synchronize do
+        pid = channel == :bgm ? @bgm_pid : @loop_se_pid
+      end
+      Process.wait(pid) if pid
+    rescue Errno::ECHILD
+      nil
+    end
+
+    def channel_stopped?(channel)
+      @mutex.synchronize do
+        channel == :bgm ? @bgm_stop : @loop_se_stop
+      end
+    end
+
+    def terminate_process(pid)
+      Process.kill("TERM", -pid)
+    rescue Errno::ESRCH
+      nil
+    end
+  end
+end

data/lib/termfront/config.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Termfront
+  module Config
+    FRAME_DT      = 1.0 / 30.0
+    FOV           = 66.0 * Math::PI / 180.0
+    PLAYER_RADIUS = 0.2
+    KEY_TIMEOUT   = 5
+    ROT_SPEED     = 2.8
+    MOVE_SPEED    = 6.0
+
+    CEIL_C  = 17
+    FLOOR_C = 234
+
+    ARROWS = ">v<^".chars
+
+    SHIELD_MAX   = 100
+    SHIELD_REGEN = 25.0
+    SHIELD_DELAY = 3.0
+
+    HEALTH_MAX     = 100
+    BEEP_INTERVAL  = 0.15
+
+    PICKUP_RADIUS = 0.8
+    TERMINAL_USE_RADIUS = 2.25
+
+    PROJ_SPEED  = 2.5
+    PROJ_RADIUS = 0.3
+
+    RADAR_RADIUS = 3
+    RADAR_RANGE  = 12.0
+
+    PVP_PORT    = 7777
+    PVP_HIT_DMG = 10
+
+    DEMO_SPEED = 0.008
+  end
+end

data/lib/termfront/demo_player.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Termfront
+  class DemoPlayer
+    DemoActor = Struct.new(:x, :y, :sprite_id, :alive, :hp, :max_hp, keyword_init: true)
+
+    def initialize(stdout, renderer)
+      @stdout = stdout
+      @renderer = renderer
+    end
+
+    def play(action, mission:, stdin: nil)
+      path = Array(action[:path])
+      return if path.empty?
+
+      duration = (action[:duration] || path.last[:t] || 0.0).to_f
+      return if duration <= 0
+
+      if stdin
+        play_loop(stdin, action, mission, path, duration)
+      else
+        STDIN.raw { |raw| play_loop(raw, action, mission, path, duration) }
+      end
+    end
+
+    private
+
+    def play_loop(stdin, action, mission, path, duration)
+      map = mission.build_map
+      player = build_player(mission, path.first)
+      terminals = mission.build_terminals
+      actors = build_actors(action[:actors])
+      fire_times = Array(action[:fire_times]).map(&:to_f)
+
+      started_at = clock
+      last_tick = started_at
+
+      loop do
+        now = clock
+        elapsed = now - started_at
+        dt = now - last_tick
+        last_tick = now
+
+        return if skip_requested?(stdin)
+
+        pose = interpolate_pose(path, [elapsed, duration].min)
+        player.x = pose[:x]
+        player.y = pose[:y]
+        player.angle = pose[:angle]
+        player.game_time += dt
+        player.fire_flash = fire_active?(fire_times, elapsed) ? 3 : 0
+
+        @renderer.render(
+          player: player,
+          map: map,
+          enemies: active_actors(actors, elapsed),
+          projectiles: [],
+          drops: [],
+          terminals: terminals
+        )
+        render_caption(action[:caption], elapsed, duration)
+
+        break if elapsed >= duration
+
+        sleep(Config::FRAME_DT)
+      end
+    end
+
+    def build_player(mission, pose)
+      weapons = mission.build_weapons
+      weapons = [Weapon::Base.build(:pistol)] if weapons.empty?
+      player = Player.new(
+        x: pose[:x],
+        y: pose[:y],
+        angle: pose[:angle] || 0.0,
+        weapons: weapons
+      )
+      player.drops = []
+      player
+    end
+
+    def build_actors(definitions)
+      Array(definitions).map do |definition|
+        {
+          entity: DemoActor.new(
+            x: definition[:x].to_f,
+            y: definition[:y].to_f,
+            sprite_id: definition[:sprite_id].to_sym,
+            alive: true,
+            hp: 1,
+            max_hp: 1
+          ),
+          from: definition.fetch(:from, 0.0).to_f,
+          to: definition.fetch(:to, Float::INFINITY).to_f
+        }
+      end
+    end
+
+    def active_actors(actors, elapsed)
+      actors.filter_map do |actor|
+        next unless elapsed >= actor[:from] && elapsed <= actor[:to]
+
+        actor[:entity]
+      end
+    end
+
+    def interpolate_pose(path, elapsed)
+      current = path.first
+      nxt = path.last
+
+      path.each_cons(2) do |left, right|
+        if elapsed <= right[:t].to_f
+          current = left
+          nxt = right
+          break
+        end
+      end
+
+      span = nxt[:t].to_f - current[:t].to_f
+      ratio = span <= 0 ? 1.0 : ((elapsed - current[:t].to_f) / span).clamp(0.0, 1.0)
+
+      {
+        x: lerp(current[:x], nxt[:x], ratio),
+        y: lerp(current[:y], nxt[:y], ratio),
+        angle: lerp_angle(current[:angle] || 0.0, nxt[:angle] || 0.0, ratio)
+      }
+    end
+
+    def render_caption(caption, elapsed, duration)
+      return if caption.to_s.empty?
+
+      rows, cols = @stdout.winsize
+      lines = caption.to_s.split("\n")
+      base_row = [rows - lines.size - 2, 2].max
+
+      buf = TerminalOutput.begin_frame
+      lines.each_with_index do |line, index|
+        col = [(cols - line.size) / 2 + 1, 1].max
+        buf << "\e[#{base_row + index};1H\e[K"
+        buf << "\e[#{base_row + index};#{col}H\e[1;97m#{line}\e[0m"
+      end
+
+      hint = "[Enter] Skip Demo"
+      progress = "#{elapsed.ceil}/#{duration.ceil}s"
+      buf << "\e[#{rows - 1};3H\e[90m#{hint}\e[0m"
+      buf << "\e[#{rows - 1};#{[cols - progress.size - 1, 1].max}H\e[90m#{progress}\e[0m"
+      buf << TerminalOutput.end_frame
+      TerminalOutput.write_all(@stdout, buf)
+    end
+
+    def fire_active?(fire_times, elapsed)
+      fire_times.any? { |time| (elapsed - time).abs < 0.12 }
+    end
+
+    def skip_requested?(stdin)
+      while IO.select([stdin], nil, nil, 0)
+        data = stdin.read_nonblock(64)
+        return true if data.bytes.any? { |byte| [13, 10, 27, 32, 81, 113].include?(byte) }
+      end
+
+      false
+    rescue IO::WaitReadable
+      false
+    end
+
+    def lerp(a, b, t)
+      a.to_f + (b.to_f - a.to_f) * t
+    end
+
+    def lerp_angle(a, b, t)
+      delta = b.to_f - a.to_f
+      delta -= Math::PI * 2 while delta > Math::PI
+      delta += Math::PI * 2 while delta < -Math::PI
+      a.to_f + delta * t
+    end
+
+    def clock
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  end
+end

data/lib/termfront/drop_item/base.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Termfront
+  module DropItem
+    class Base
+      attr_accessor :x, :y
+
+      def initialize(x:, y:)
+        @x = x
+        @y = y
+      end
+
+      def in_range?(px, py)
+        (px - @x)**2 + (py - @y)**2 < Config::PICKUP_RADIUS**2
+      end
+
+      def pickup!(player)
+        raise NotImplementedError
+      end
+
+      def sprite_color
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/termfront/drop_item/weapon.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Termfront
+  module DropItem
+    class Weapon < Base
+      attr_accessor :type, :ammo
+
+      def initialize(x:, y:, type:, ammo:)
+        super(x: x, y: y)
+        @type = type
+        @ammo = ammo
+      end
+
+      def pickup!(player)
+        cur = player.current_weapon
+        if cur.type_id == @type
+          max = cur.max_ammo
+          cur.ammo = [cur.ammo + @ammo, max].min if max
+        else
+          player.drops << DropItem::Weapon.new(x: player.x, y: player.y, type: cur.type_id, ammo: cur.ammo)
+          player.weapons[player.weapon_idx] = Weapon::Base.build(@type, @ammo)
+        end
+      end
+
+      def sprite_color
+        @type.to_s.start_with?("shock") ? "60;200;220" : "220;200;60"
+      end
+
+      def radar_color
+        @type.to_s.start_with?("shock") ? "\e[96m" : "\e[93m"
+      end
+
+      def radar_label
+        Weapon::Base.registry[@type].new.name[0]
+      end
+    end
+  end
+end

data/lib/termfront/enemy/base.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Termfront
+  module Enemy
+    class Base
+      attr_accessor :x, :y, :wp_a, :wp_b, :wp_t, :wp_dir, :last_fire, :alive, :hp, :max_hp
+
+      DIFFICULTIES = [
+        { name: "Easy",      hp_mult: 1, cooldown_mult: 1.5, extra_enemies: 0 },
+        { name: "Normal",    hp_mult: 2, cooldown_mult: 1.0, extra_enemies: 1 },
+        { name: "Hard",      hp_mult: 3, cooldown_mult: 0.7, extra_enemies: 3 },
+        { name: "Very Hard", hp_mult: 4, cooldown_mult: 0.5, extra_enemies: 5 }
+      ].freeze
+
+      def initialize(x:, y:, wp_a:, wp_b:, hp:)
+        @x = x
+        @y = y
+        @wp_a = wp_a
+        @wp_b = wp_b
+        @wp_t = 0.0
+        @wp_dir = 1
+        @last_fire = 0.0
+        @alive = true
+        @hp = hp
+        @max_hp = hp
+      end
+
+      def damage    = raise(NotImplementedError)
+      def range     = raise(NotImplementedError)
+      def cooldown  = raise(NotImplementedError)
+      def speed     = raise(NotImplementedError)
+      def drop_type = raise(NotImplementedError)
+      def drop_ammo = raise(NotImplementedError)
+      def sprite_id = raise(NotImplementedError)
+      def base_hp   = raise(NotImplementedError)
+
+      def dead? = !@alive
+
+      def take_damage(amount)
+        @hp -= amount
+        return unless @hp <= 0
+
+        @alive = false
+      end
+
+      def update(dt, player, projectiles, map, game_time, difficulty:)
+        return unless @alive
+
+        patrol(dt)
+
+        edx = player.x - @x
+        edy = player.y - @y
+        edist = Math.sqrt(edx * edx + edy * edy)
+        cd = cooldown
+        cd *= DIFFICULTIES[difficulty][:cooldown_mult] if difficulty
+        return unless edist < range && (game_time - @last_fire) > cd
+        return unless map.line_of_sight?(@x, @y, player.x, player.y)
+
+        @last_fire = game_time
+        ndx = edx / edist
+        ndy = edy / edist
+        projectiles << Projectile.new(
+          x: @x, y: @y,
+          vx: ndx * Config::PROJ_SPEED,
+          vy: ndy * Config::PROJ_SPEED,
+          type: sprite_id
+        )
+      end
+
+      def patrol(dt)
+        seg_len = Math.sqrt(
+          (@wp_b[0] - @wp_a[0])**2 + (@wp_b[1] - @wp_a[1])**2 + 0.01
+        )
+        @wp_t += @wp_dir * speed * dt / seg_len
+        if @wp_t >= 1.0
+          @wp_t = 1.0
+          @wp_dir = -1
+        elsif @wp_t <= 0.0
+          @wp_t = 0.0
+          @wp_dir = 1
+        end
+        @x = @wp_a[0] + (@wp_b[0] - @wp_a[0]) * @wp_t
+        @y = @wp_a[1] + (@wp_b[1] - @wp_a[1]) * @wp_t
+      end
+
+      class << self
+        def registry
+          @registry ||= {}
+        end
+
+        def register(type, klass)
+          registry[type] = klass
+        end
+
+        def build(type, enemy_def, difficulty_index)
+          klass = registry[type] || raise(ArgumentError, "Unknown enemy type: #{type}")
+          sx, sy, ax, ay, _type = enemy_def
+          hp = compute_hp(klass, difficulty_index)
+          klass.new(x: sx, y: sy, wp_a: [sx, sy], wp_b: [ax, ay], hp: hp)
+        end
+
+        def generate_extras(base_list, count, difficulty_index)
+          return [] if count == 0 || base_list.empty?
+
+          extras = []
+          count.times do |i|
+            src = base_list[i % base_list.size]
+            sx, sy, ax, ay, type = src
+            offset = 0.3 + (i * 0.2)
+            klass = registry[type] || raise(ArgumentError, "Unknown enemy type: #{type}")
+            hp = compute_hp(klass, difficulty_index)
+            extras << klass.new(
+              x: sx + offset, y: sy + offset,
+              wp_a: [sx + offset, sy + offset],
+              wp_b: [ax + offset, ay + offset],
+              hp: hp
+            )
+          end
+          extras
+        end
+
+        private
+
+        def compute_hp(klass, difficulty_index)
+          return 1 unless difficulty_index
+
+          instance = klass.allocate
+          instance.send(:base_hp) * DIFFICULTIES[difficulty_index][:hp_mult]
+        end
+      end
+    end
+  end
+end

data/lib/termfront/enemy/crawler.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Termfront
+  module Enemy
+    class Crawler < Base
+      def damage    = 10
+      def range     = 5.0
+      def cooldown  = 1.5
+      def speed     = 1.8
+      def drop_type = :shock_pistol
+      def drop_ammo = 60
+      def sprite_id = :crawler
+      def base_hp   = 1
+    end
+
+    Base.register(:crawler, Crawler)
+  end
+end

data/lib/termfront/enemy/executor.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Termfront
+  module Enemy
+    class Executor < Base
+      def damage    = 25
+      def range     = 8.0
+      def cooldown  = 2.5
+      def speed     = 1.2
+      def drop_type = :shock_rifle
+      def drop_ammo = 100
+      def sprite_id = :executor
+      def base_hp   = 2
+    end
+
+    Base.register(:executor, Executor)
+  end
+end