termfront 0.1.0

data/lib/termfront/network/wavesfight_client.rb

@@ -0,0 +1,364 @@
+# frozen_string_literal: true
+
+module Termfront
+  module Network
+    class WavesfightClient
+      def initialize(stdout)
+        @stdout = stdout
+        @conn = Connection.new
+        @input = Input.new
+        @renderer = Renderer.new(stdout)
+        @audio = AudioManager.new
+      end
+
+      def run(mission_id:, difficulty:)
+        @queue_mission_id = mission_id
+        @queue_difficulty = difficulty
+        addr = prompt_address
+        return unless addr
+
+        host, port = addr.include?(":") ? addr.split(":", 2).then { |h, p| [h, p.to_i] } : [addr, Config::PVP_PORT]
+        begin
+          @conn.connect(host, port)
+          @conn.send_msg({ t: "queue", mode: "wavesfight", mission_id: mission_id, difficulty: difficulty })
+        rescue StandardError => e
+          show_error("Connection failed: #{e.message}")
+          return
+        end
+
+        begin
+          unless wait_for_start
+            @conn.close
+            return
+          end
+          run_game_loop
+        rescue StandardError => e
+          show_error("Error: #{e.message}")
+        ensure
+          @audio.close
+          @conn.close
+        end
+      end
+
+      private
+
+      def prompt_address
+        input = "localhost:#{Config::PVP_PORT}"
+
+        STDIN.raw do |stdin|
+          loop do
+            rows, cols = @stdout.winsize
+            buf = TerminalOutput.begin_frame(home: true, clear: true)
+            lines = Array.new(rows) { " " * cols }
+
+            title = "Wavesfight Co-op - Enter Server Address"
+            tc = [(cols - title.size) / 2 + 1, 1].max
+            lines[rows / 2 - 3] = TerminalOutput.fit_ansi("#{" " * (tc - 1)}\e[1;96m#{title}\e[0m", cols)
+
+            pc = [(cols - input.size - 3) / 2 + 1, 1].max
+            lines[rows / 2 - 1] = TerminalOutput.fit_ansi("#{" " * (pc - 1)}\e[97m> #{input}\e[5m_\e[0m", cols)
+
+            hint = "(Enter to continue, ESC to cancel)"
+            hc = [(cols - hint.size) / 2 + 1, 1].max
+            lines[rows / 2 + 1] = TerminalOutput.fit_ansi("#{" " * (hc - 1)}\e[90m#{hint}\e[0m", cols)
+
+            lines.each_with_index do |line, index|
+              buf << line
+              buf << "\r\n" if index < rows - 1
+            end
+            buf << TerminalOutput.end_frame
+            TerminalOutput.write_all(@stdout, buf)
+
+            next unless IO.select([stdin], nil, nil, Config::FRAME_DT)
+
+            begin
+              data = stdin.read_nonblock(64)
+              data.each_byte do |b|
+                case b
+                when 27 then return nil
+                when 13, 10 then return input.empty? ? "localhost:#{Config::PVP_PORT}" : input
+                when 127, 8 then input = input[0...-1] unless input.empty?
+                when 32..126 then input << b.chr
+                end
+              end
+            rescue IO::WaitReadable
+            end
+          end
+        end
+      end
+
+      def wait_for_start
+        STDIN.raw do |stdin|
+          loop do
+            rows, cols = @stdout.winsize
+            buf = TerminalOutput.begin_frame(home: true, clear: true)
+            lines = Array.new(rows) { " " * cols }
+            msg = "Waiting for co-op partner..."
+            mc = [(cols - msg.size) / 2 + 1, 1].max
+            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)
+            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)
+
+            lines.each_with_index do |line, index|
+              buf << line
+              buf << "\r\n" if index < rows - 1
+            end
+            buf << TerminalOutput.end_frame
+            TerminalOutput.write_all(@stdout, buf)
+
+            if IO.select([stdin], nil, nil, 0)
+              begin
+                ch = stdin.read_nonblock(64)
+                return false if ch.bytes.include?(27)
+              rescue IO::WaitReadable
+              end
+            end
+
+            next unless IO.select([@conn.socket], nil, nil, 0.1)
+
+            @conn.receive.each do |msg|
+              next unless msg[:t] == "wavesfight_start"
+
+              load_match(msg)
+              return true
+            end
+          end
+        end
+      end
+
+      def load_match(msg)
+        @map = Map.new(msg[:map])
+        @mission_name = msg[:mission]
+        @player_id = msg[:id]
+        @wave = 1
+        @difficulty = 1
+        self_info = msg[:players].find { |entry| entry[:id] == @player_id }
+        weapons = [Weapon::Base.build(:ar, 60), Weapon::Base.build(:pistol)]
+        @player = Player.new(x: self_info[:spawn][0], y: self_info[:spawn][1], angle: self_info[:spawn][2], weapons: weapons)
+        @player.drops = []
+        @remote_players = {}
+        msg[:players].each do |entry|
+          next if entry[:id] == @player_id
+
+          @remote_players[entry[:id]] = Opponent.new(x: entry[:spawn][0], y: entry[:spawn][1], angle: entry[:spawn][2])
+        end
+        @enemies = []
+        @projectiles = []
+        @match_end = nil
+      end
+
+      def run_game_loop
+        STDIN.raw do |stdin|
+          last_time = clock
+          last_ping = clock
+
+          loop do
+            now = clock
+            dt = now - last_time
+            last_time = now
+
+            keys = @input.process(stdin, player: @player)
+            return if @input.key?(:esc)
+
+            unless @player.dead
+              handle_player_actions(keys)
+              update_local(dt)
+              send_state
+            end
+
+            handle_messages
+            render_world
+
+            if @match_end
+              text = @match_end[:reason] == "defeat" ? "TEAM DOWN AT WAVE #{@match_end[:wave]}" : "MATCH CANCELED"
+              render_result(text, @match_end[:reason] == "defeat" ? "\e[1;91m" : "\e[1;93m")
+              sleep 3
+              return
+            end
+
+            if now - last_ping > 2.0
+              @conn.ping(now)
+              last_ping = now
+            end
+
+            cap_frame(now)
+          end
+        end
+      end
+
+      def handle_player_actions(keys)
+        @player.swap_weapon if keys.include?(:t)
+
+        return unless keys.include?(:space)
+
+        weapon = @player.current_weapon
+        return unless weapon.can_fire?(@player.last_fire, @player.game_time)
+        return unless weapon.infinite_ammo? || (weapon.ammo && weapon.ammo > 0)
+
+        @player.fire_flash = 4
+        weapon.consume_ammo!
+        @player.last_fire = @player.game_time
+        @audio.play_se(:shoot)
+        @conn.send_msg({ t: "fire" })
+      end
+
+      def update_local(dt)
+        @player.game_time += dt
+
+        @player.angle -= Config::ROT_SPEED * dt if @input.key?(:left)
+        @player.angle += Config::ROT_SPEED * dt if @input.key?(:right)
+
+        dx = Math.cos(@player.angle)
+        dy = Math.sin(@player.angle)
+        sx = -dy
+        sy = dx
+        mvx = 0.0
+        mvy = 0.0
+        if @input.key?(:w)
+          mvx += dx * Config::MOVE_SPEED * dt
+          mvy += dy * Config::MOVE_SPEED * dt
+        end
+        if @input.key?(:s)
+          mvx -= dx * Config::MOVE_SPEED * dt
+          mvy -= dy * Config::MOVE_SPEED * dt
+        end
+        if @input.key?(:a)
+          mvx -= sx * Config::MOVE_SPEED * dt
+          mvy -= sy * Config::MOVE_SPEED * dt
+        end
+        if @input.key?(:d)
+          mvx += sx * Config::MOVE_SPEED * dt
+          mvy += sy * Config::MOVE_SPEED * dt
+        end
+
+        nx = @player.x + mvx
+        @player.x = nx unless @map.blocked?(nx, @player.y)
+        ny = @player.y + mvy
+        @player.y = ny unless @map.blocked?(@player.x, ny)
+
+        @player.fire_flash -= 1 if @player.fire_flash > 0
+      end
+
+      def send_state
+        @conn.send_msg({
+                         t: "state",
+                         x: @player.x.round(3),
+                         y: @player.y.round(3),
+                         a: @player.angle.round(4),
+                         w: @player.current_weapon.type_id,
+                         am: @player.current_weapon.ammo || -1,
+                         ff: @player.fire_flash
+                       })
+      end
+
+      def handle_messages
+        @conn.receive.each do |msg|
+          case msg[:t]
+          when "world"
+            apply_world(msg)
+          when "hit"
+            @player.apply_damage(msg[:d] || Config::PVP_HIT_DMG)
+            @audio.play_se(:damage)
+          when "wave_start"
+            @wave = msg[:wave]
+            @difficulty = msg[:difficulty]
+          when "match_end"
+            @match_end = msg
+          end
+        end
+      end
+
+      def apply_world(msg)
+        @wave = msg[:wave]
+        @difficulty = msg[:difficulty]
+
+        msg[:players].each do |entry|
+          if entry[:id] == @player_id
+            @player.shield = entry[:s]
+            @player.health = entry[:h]
+            @player.dead = !entry[:alive]
+          else
+            remote = @remote_players[entry[:id]]
+            next unless remote
+
+            remote.x = entry[:x]
+            remote.y = entry[:y]
+            remote.angle = entry[:a]
+            remote.shield = entry[:s]
+            remote.health = entry[:h]
+            remote.weapon = entry[:w]&.to_sym
+            remote.ammo = entry[:am]
+            remote.fire_flash = entry[:ff] || 0
+          end
+        end
+
+        @enemies = msg[:enemies].filter_map do |enemy|
+          next unless enemy[:alive]
+
+          RemoteEnemy.new(
+            id: enemy[:id],
+            x: enemy[:x],
+            y: enemy[:y],
+            sprite_id: enemy[:type].to_sym,
+            hp: enemy[:hp],
+            max_hp: enemy[:max_hp],
+            alive: true
+          )
+        end
+
+        @projectiles = msg[:projectiles].map do |projectile|
+          Projectile.new(x: projectile[:x], y: projectile[:y], vx: 0.0, vy: 0.0, type: projectile[:type].to_sym)
+        end
+      end
+
+      def render_world
+        allies = @remote_players.values.select { |remote| remote.health.positive? }
+        status = "  WAVE #{@wave}  #{Enemy::Base::DIFFICULTIES[@difficulty][:name]}  CO-OP"
+        @renderer.render(
+          player: @player,
+          map: @map,
+          enemies: @enemies,
+          projectiles: @projectiles,
+          drops: [],
+          terminals: [],
+          status_line: status,
+          allies: allies
+        )
+      end
+
+      def render_result(text, color)
+        rows, cols = @stdout.winsize
+        @renderer.render_centered_message(rows, cols, text, color)
+      end
+
+      def show_error(msg)
+        rows, cols = @stdout.winsize
+        @renderer.render_centered_message(rows, cols, msg, "\e[1;91m")
+        STDIN.raw { |stdin| stdin.getc }
+      end
+
+      def queued_mission_name
+        mission = Mission::Base.wavesfight.find { |klass| klass.new.id == @queue_mission_id }
+        mission ? mission.new.name : @queue_mission_id.to_s
+      end
+
+      def queued_difficulty_name
+        Enemy::Base::DIFFICULTIES[@queue_difficulty][:name]
+      end
+
+      def clock
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def cap_frame(frame_start)
+        spent = clock - frame_start
+        remain = Config::FRAME_DT - spent
+        sleep(remain) if remain > 0
+      end
+    end
+  end
+end

data/lib/termfront/opponent.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Termfront
+  class Opponent
+    attr_accessor :x, :y, :angle, :shield, :health, :weapon, :ammo, :fire_flash
+
+    def initialize(x:, y:, angle:, shield: Config::SHIELD_MAX, health: Config::HEALTH_MAX, weapon: :ar, ammo: 60,
+                   fire_flash: 0)
+      @x = x
+      @y = y
+      @angle = angle
+      @shield = shield
+      @health = health
+      @weapon = weapon
+      @ammo = ammo
+      @fire_flash = fire_flash
+    end
+
+    def dup_state
+      Opponent.new(x: @x, y: @y, angle: @angle, shield: @shield, health: @health,
+                   weapon: @weapon, ammo: @ammo, fire_flash: @fire_flash)
+    end
+  end
+end

data/lib/termfront/player.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Termfront
+  class Player
+    attr_accessor :x, :y, :angle, :shield, :health, :weapons, :weapon_idx,
+                  :last_fire, :dead, :game_time, :last_damage, :damage_flash,
+                  :fire_flash, :beep_count, :last_beep, :regen_active,
+                  :swap_pressed, :pickup_pressed, :drops
+
+    def initialize(x:, y:, angle:, weapons:)
+      @x = x
+      @y = y
+      @angle = angle
+      @weapons = weapons
+      @weapon_idx = 0
+      @last_fire = 0.0
+      @shield = Config::SHIELD_MAX
+      @health = Config::HEALTH_MAX
+      @dead = false
+      @game_time = 0.0
+      @last_damage = -Config::SHIELD_DELAY
+      @damage_flash = 0
+      @fire_flash = 0
+      @beep_count = 0
+      @last_beep = 0.0
+      @regen_active = false
+      @swap_pressed = false
+      @pickup_pressed = false
+      @drops = []
+    end
+
+    def current_weapon
+      @weapons[@weapon_idx]
+    end
+
+    def swap_weapon
+      @weapon_idx = 1 - @weapon_idx
+    end
+
+    def apply_damage(amount)
+      @last_damage = @game_time
+      @damage_flash = 3
+
+      if @shield > 0
+        overflow = amount - @shield
+        @shield = [(@shield - amount), 0].max
+        @health = [@health - [overflow, 0].max, 0].max if @shield == 0
+      else
+        @health = [@health - amount, 0].max
+      end
+
+      @dead = true if @health <= 0
+    end
+
+    def update_shield(dt, stdout, audio: nil)
+      regen_now = @shield < Config::SHIELD_MAX && (@game_time - @last_damage) >= Config::SHIELD_DELAY
+      if regen_now
+        unless @regen_active
+          @regen_active = true
+          if audio
+            audio.play_loop_se(:shield_regen)
+          else
+            stdout.syswrite("\a")
+          end
+        end
+        @shield = [@shield + Config::SHIELD_REGEN * dt, Config::SHIELD_MAX].min
+      else
+        audio&.stop_loop_se(:shield_regen) if @regen_active
+        @regen_active = false
+      end
+      @damage_flash -= 1 if @damage_flash > 0
+
+      if @shield >= Config::SHIELD_MAX && @health < Config::HEALTH_MAX
+        @health = [@health + Config::SHIELD_REGEN * dt, Config::HEALTH_MAX].min
+      end
+
+      return unless @shield == 0 && @health > 0
+
+      @beep_count = 3 if @beep_count <= 0
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      return unless (now - @last_beep) >= Config::BEEP_INTERVAL
+
+      if audio
+        audio.play_se(:shield_alarm)
+      else
+        stdout.syswrite("\a")
+      end
+      @last_beep = now
+      @beep_count -= 1
+    end
+
+    def try_pickup
+      nearest = nil
+      best_d2 = Config::PICKUP_RADIUS**2
+      @drops.each do |d|
+        d2 = (d.x - @x)**2 + (d.y - @y)**2
+        if d2 < best_d2
+          nearest = d
+          best_d2 = d2
+        end
+      end
+      return unless nearest
+
+      cur = current_weapon
+      if cur.type_id == nearest.type
+        max = cur.max_ammo
+        cur.ammo = [cur.ammo + nearest.ammo, max].min if max
+      else
+        @drops << DropItem::Weapon.new(x: @x, y: @y, type: cur.type_id, ammo: cur.ammo)
+        @weapons[@weapon_idx] = Weapon::Base.build(nearest.type, nearest.ammo)
+      end
+      @drops.delete(nearest)
+    end
+
+    def process_fire(enemies, map)
+      dx = Math.cos(@angle)
+      dy = Math.sin(@angle)
+
+      weapon = current_weapon
+
+      best = nil
+      best_d = 1e30
+      enemies.each do |e|
+        next unless e.alive
+
+        ex = e.x - @x
+        ey = e.y - @y
+        dot = ex * dx + ey * dy
+        next if dot < 0.1
+
+        perp = (ex * (-dy) + ey * dx).abs
+        next if perp > weapon.hit_width
+
+        if dot < best_d && map.line_of_sight?(@x, @y, e.x, e.y)
+          best = e
+          best_d = dot
+        end
+      end
+      return unless best
+
+      best.take_damage(1)
+      return if best.alive
+
+      @drops << DropItem::Weapon.new(x: best.x, y: best.y, type: best.drop_type, ammo: best.drop_ammo)
+    end
+  end
+end

data/lib/termfront/projectile.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Termfront
+  class Projectile
+    attr_accessor :x, :y, :vx, :vy, :type
+
+    def initialize(x:, y:, vx:, vy:, type:)
+      @x = x
+      @y = y
+      @vx = vx
+      @vy = vy
+      @type = type
+    end
+
+    def update(dt)
+      @x += @vx * dt
+      @y += @vy * dt
+    end
+
+    def hit_wall?(map)
+      map.wall_at?(@x, @y)
+    end
+
+    def hit_player?(px, py, radius = Config::PROJ_RADIUS)
+      (@x - px).abs < radius && (@y - py).abs < radius
+    end
+
+    def self.update_all(projectiles, map, player)
+      projectiles.reject! do |p|
+        p.update(0) # dt is applied in the caller
+        if p.hit_wall?(map)
+          true
+        elsif p.hit_player?(player.x, player.y)
+          enemy_klass = Enemy::Base.registry[p.type]
+          dmg = enemy_klass ? enemy_klass.allocate.send(:damage) : 10
+          player.apply_damage(dmg)
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/termfront/remote_enemy.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Termfront
+  class RemoteEnemy
+    attr_accessor :id, :x, :y, :hp, :max_hp, :alive
+
+    def initialize(id:, x:, y:, sprite_id:, hp:, max_hp:, alive: true)
+      @id = id
+      @x = x
+      @y = y
+      @sprite_id = sprite_id
+      @hp = hp
+      @max_hp = max_hp
+      @alive = alive
+    end
+
+    def sprite_id
+      @sprite_id
+    end
+  end
+end