termfront 0.1.0

data/lib/termfront/map.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Termfront
+  class Map
+    attr_reader :grid, :width, :height
+
+    def initialize(rows)
+      @grid = rows.map { |r| r.is_a?(Array) ? r : r.chars }
+      @height = @grid.size
+      @width = @grid[0].size
+    end
+
+    def wall_at?(fx, fy)
+      ix = fx.floor
+      iy = fy.floor
+      return true if iy < 0 || iy >= @height || ix < 0 || ix >= @width
+
+      @grid[iy][ix] == "#"
+    end
+
+    def blocked?(px, py, radius = Config::PLAYER_RADIUS)
+      wall_at?(px - radius, py - radius) || wall_at?(px + radius, py - radius) ||
+        wall_at?(px - radius, py + radius) || wall_at?(px + radius, py + radius)
+    end
+
+    def line_of_sight?(x1, y1, x2, y2)
+      dx = x2 - x1
+      dy = y2 - y1
+      dist = Math.sqrt(dx * dx + dy * dy)
+      return true if dist < 0.01
+
+      dx /= dist
+      dy /= dist
+
+      mx = x1.floor
+      my = y1.floor
+      ddx = dx == 0 ? 1e30 : (1.0 / dx).abs
+      ddy = dy == 0 ? 1e30 : (1.0 / dy).abs
+
+      if dx < 0
+        step_x = -1
+        sd_x = (x1 - mx) * ddx
+      else
+        step_x = 1
+        sd_x = (mx + 1.0 - x1) * ddx
+      end
+      if dy < 0
+        step_y = -1
+        sd_y = (y1 - my) * ddy
+      else
+        step_y = 1
+        sd_y = (my + 1.0 - y1) * ddy
+      end
+
+      loop do
+        if sd_x < sd_y
+          return true if sd_x > dist
+
+          sd_x += ddx
+          mx += step_x
+        else
+          return true if sd_y > dist
+
+          sd_y += ddy
+          my += step_y
+        end
+        return false if my < 0 || my >= @height || mx < 0 || mx >= @width
+        return false if @grid[my][mx] == "#"
+      end
+    end
+  end
+end

data/lib/termfront/mission/base.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Termfront
+  module Mission
+    class Base
+      def id
+        self.class.name.split("::").last
+          .gsub(/([a-z0-9])([A-Z])/, '\1_\2')
+          .downcase
+      end
+
+      def name      = raise(NotImplementedError)
+      def briefing  = raise(NotImplementedError)
+      def map_data  = raise(NotImplementedError)
+      def spawn     = raise(NotImplementedError)
+      def weapon_defs = raise(NotImplementedError)
+      def enemy_defs  = raise(NotImplementedError)
+
+      def events_path
+        File.expand_path("../../../data/events/#{id}.json", __dir__)
+      end
+
+      def event_definitions
+        @event_definitions ||= EventLoader.load_file(events_path)
+      end
+
+      def build_terminals
+        terminal_ids = event_definitions.filter_map do |event|
+          trigger = event[:trigger]
+          trigger[:terminal_id] if trigger[:type] == :terminal_used
+        end.uniq
+
+        map_data.each_with_index.filter_map do |row, y|
+          row.chars.each_with_index.filter_map do |cell, x|
+            next unless cell == "*"
+
+            { id: (terminal_ids.shift || :"terminal_#{x}_#{y}"), x: x + 0.5, y: y + 0.5 }
+          end
+        end.flatten
+      end
+
+      def build_map
+        Map.new(map_data)
+      end
+
+      def build_weapons
+        weapon_defs.map { |type, ammo| Weapon::Base.build(type, ammo) }
+      end
+
+      def build_enemies(difficulty_index)
+        enemies = enemy_defs.map do |ed|
+          type = ed[4]
+          Enemy::Base.build(type, ed, difficulty_index)
+        end
+        if difficulty_index
+          extra = Enemy::Base::DIFFICULTIES[difficulty_index][:extra_enemies]
+          enemies += Enemy::Base.generate_extras(enemy_defs, extra, difficulty_index)
+        end
+        enemies
+      end
+
+      class << self
+        def campaign
+          @campaign ||= []
+        end
+
+        def wavesfight
+          @wavesfight ||= []
+        end
+
+        def register(klass)
+          campaign << klass
+        end
+
+        def register_wavesfight(klass)
+          wavesfight << klass
+        end
+      end
+    end
+  end
+end

data/lib/termfront/mission/corridor_sweep.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Termfront
+  module Mission
+    class CorridorSweep < Base
+      def name = "Corridor Sweep"
+      def briefing = "Sweep the original facility. Expect resistance."
+
+      def map_data
+        [
+          "########################",
+          "#..........#...........#",
+          "#..........#...........#",
+          "#..........#...........#",
+          "#..........#...........#",
+          "#......................#",
+          "#..........####........#",
+          "#......................#",
+          "#..............#.......#",
+          "#..............#.......#",
+          "########################"
+        ]
+      end
+
+      def spawn = [10.0, 6.0, 0.0]
+      def weapon_defs = [[:ar, 60], [:pistol, nil]]
+
+      def enemy_defs
+        [
+          [16.5, 1.5, 16.5, 4.5, :executor],
+          [5.5,  8.5, 9.5,  8.5, :crawler],
+          [20.5, 5.5, 20.5, 9.5, :crawler],
+          [3.5,  2.5, 3.5,  4.5, :crawler]
+        ]
+      end
+    end
+
+    Base.register(CorridorSweep)
+    Base.register_wavesfight(CorridorSweep)
+  end
+end

data/lib/termfront/mission/event_loader.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Termfront
+  module Mission
+    module EventLoader
+      module_function
+
+      def load_file(path)
+        return [] unless File.file?(path)
+
+        doc = JSON.parse(File.read(path))
+        events = doc.fetch("events") do
+          raise ArgumentError, "event file #{path} is missing top-level events array"
+        end
+
+        unless events.is_a?(Array)
+          raise ArgumentError, "event file #{path} must define events as an array"
+        end
+
+        events.map.with_index do |event, index|
+          validate_event!(event, path, index)
+        end
+      end
+
+      def validate_event!(event, path, index)
+        unless event.is_a?(Hash)
+          raise ArgumentError, "event #{index} in #{path} must be an object"
+        end
+
+        id = event["id"]
+        trigger = event["trigger"]
+        actions = event["actions"]
+
+        raise ArgumentError, "event #{index} in #{path} is missing id" if blank?(id)
+        raise ArgumentError, "event #{id} in #{path} is missing trigger" unless trigger.is_a?(Hash)
+        raise ArgumentError, "event #{id} in #{path} is missing actions" unless actions.is_a?(Array) && !actions.empty?
+
+        trigger_type = trigger["type"]
+        raise ArgumentError, "event #{id} in #{path} trigger is missing type" if blank?(trigger_type)
+
+        normalized_actions = actions.map.with_index do |action, action_index|
+          validate_action!(action, path, id, action_index)
+        end
+
+        normalized_trigger = symbolize_keys(trigger).merge(type: trigger_type.to_sym)
+        normalized_trigger[:terminal_id] = normalized_trigger[:terminal_id].to_sym if normalized_trigger[:terminal_id].is_a?(String)
+
+        {
+          id: id,
+          once: event.fetch("once", true),
+          trigger: normalized_trigger,
+          actions: normalized_actions
+        }
+      end
+
+      def validate_action!(action, path, event_id, index)
+        unless action.is_a?(Hash)
+          raise ArgumentError, "action #{index} in event #{event_id} (#{path}) must be an object"
+        end
+
+        type = action["type"]
+        raise ArgumentError, "action #{index} in event #{event_id} (#{path}) is missing type" if blank?(type)
+
+        symbolize_keys(action).merge(type: type.to_sym)
+      end
+
+      def symbolize_keys(value)
+        case value
+        when Array
+          value.map { |item| symbolize_keys(item) }
+        when Hash
+          value.each_with_object({}) do |(key, item), memo|
+            memo[key.to_sym] = symbolize_keys(item)
+          end
+        else
+          value
+        end
+      end
+
+      def blank?(value)
+        value.nil? || value == ""
+      end
+    end
+  end
+end

data/lib/termfront/mission/event_runtime.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Termfront
+  module Mission
+    class EventRuntime
+      def initialize(events)
+        @events = events
+        @fired = Set.new
+      end
+
+      def trigger(type, payload = {})
+        normalized_type = type.to_sym
+        normalized_payload = payload.transform_keys(&:to_sym)
+
+        @events.filter_map do |event|
+          next if event[:once] && @fired.include?(event[:id])
+          next unless matches?(event[:trigger], normalized_type, normalized_payload)
+
+          @fired << event[:id] if event[:once]
+          event
+        end
+      end
+
+      private
+
+      def matches?(trigger, type, payload)
+        return false unless trigger[:type] == type
+
+        trigger.all? do |key, value|
+          key == :type || payload[key] == value
+        end
+      end
+    end
+  end
+end

data/lib/termfront/mission/final_push.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Termfront
+  module Mission
+    class FinalPush < Base
+      def name = "Final Push"
+      def briefing = "Storm the fortress. Maximum resistance. Good luck."
+
+      def map_data
+        [
+          "##########################",
+          "#............#...........#",
+          "#............#...........#",
+          "#............#...........#",
+          "#...........*............#",
+          "#............#...........#",
+          "#............#..####..####",
+          "####..########..#........#",
+          "#...............#........#",
+          "#...........*...#........#",
+          "#...............#........#",
+          "##########################"
+        ]
+      end
+
+      def spawn = [2.5, 2.5, 0.0]
+      def weapon_defs = [[:ar, 60], [:pistol, nil]]
+
+      def enemy_defs
+        [
+          [8.5,  2.5, 8.5,  5.5, :executor],
+          [4.5,  9.5, 4.5,  8.5, :crawler],
+          [10.5, 9.5, 10.5, 8.5, :crawler],
+          [18.5, 2.5, 18.5, 5.5, :executor],
+          [22.5, 8.5, 22.5, 10.5, :executor],
+          [16.5, 9.5, 16.5, 8.5, :crawler]
+        ]
+      end
+    end
+
+    Base.register(FinalPush)
+    Base.register_wavesfight(FinalPush)
+  end
+end

data/lib/termfront/mission/stronghold.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Termfront
+  module Mission
+    class Stronghold < Base
+      def name = "Stronghold"
+      def briefing = "Multi-room stronghold. Executors guard the inner rooms."
+
+      def map_data
+        [
+          "####################",
+          "#........#.........#",
+          "#........#.........#",
+          "#........#.........#",
+          "#...........*......#",
+          "#........#.........#",
+          "#........#.........#",
+          "####..####.........#",
+          "#........#.........#",
+          "#........#.........#",
+          "#................*.#",
+          "#........#.........#",
+          "#........#.........#",
+          "####################"
+        ]
+      end
+
+      def spawn = [2.5, 2.5, 0.0]
+      def weapon_defs = [[:ar, 60], [:pistol, nil]]
+
+      def enemy_defs
+        [
+          [5.5,  5.5, 5.5,  2.5, :crawler],
+          [14.5, 2.5, 14.5, 5.5, :executor],
+          [3.5, 10.5, 3.5, 12.5, :crawler],
+          [14.5, 9.5, 14.5, 12.5, :executor],
+          [10.5, 11.5, 15.5, 11.5, :crawler]
+        ]
+      end
+    end
+
+    Base.register(Stronghold)
+    Base.register_wavesfight(Stronghold)
+  end
+end

data/lib/termfront/mission/the_gauntlet.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Termfront
+  module Mission
+    class TheGauntlet < Base
+      def name = "The Gauntlet"
+      def briefing = "A long corridor with enemies in every room."
+
+      def map_data
+        [
+          "##############################",
+          "#.....#.....#.....#.....#....#",
+          "#.....#.....#.....#.....#....#",
+          "#...........*...........*....#",
+          "#.....#.....#.....#.....#....#",
+          "#.....#.....#.....#.....#....#",
+          "#.....#.....#.....#.....#....#",
+          "##############################"
+        ]
+      end
+
+      def spawn = [2.5, 3.5, 0.0]
+      def weapon_defs = [[:ar, 60], [:pistol, nil]]
+
+      def enemy_defs
+        [
+          [4.5,  2.5, 4.5,  5.5, :crawler],
+          [8.5,  5.5, 8.5,  2.5, :crawler],
+          [14.5, 2.5, 14.5, 5.5, :crawler],
+          [20.5, 5.5, 20.5, 2.5, :crawler],
+          [26.5, 2.5, 26.5, 5.5, :crawler]
+        ]
+      end
+    end
+
+    Base.register(TheGauntlet)
+  end
+end

data/lib/termfront/mission/training.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Termfront
+  module Mission
+    class Training < Base
+      def name = "Training"
+      def briefing = "Practice mode. Sweep the facility."
+
+      def map_data
+        [
+          "########################",
+          "#..........#...........#",
+          "#..........#...........#",
+          "#..........#...........#",
+          "#..........#...........#",
+          "#......................#",
+          "#..........####........#",
+          "#......................#",
+          "#..............#.......#",
+          "#..............#.......#",
+          "########################"
+        ]
+      end
+
+      def spawn = [10.0, 6.0, 0.0]
+      def weapon_defs = [[:ar, 60], [:pistol, nil]]
+
+      def enemy_defs
+        [
+          [16.5, 1.5, 16.5, 4.5, :executor],
+          [5.5,  8.5, 9.5,  8.5, :crawler],
+          [20.5, 5.5, 20.5, 9.5, :crawler],
+          [3.5,  2.5, 3.5,  4.5, :crawler]
+        ]
+      end
+    end
+  end
+end

data/lib/termfront/mission/training_grounds.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Termfront
+  module Mission
+    class TrainingGrounds < Base
+      def name = "Training Grounds"
+      def briefing = "Clear a small compound. Learn the basics."
+
+      def map_data
+        [
+          "################",
+          "#..............#",
+          "#..............#",
+          "#......##......#",
+          "#......##......#",
+          "#..............#",
+          "#..............#",
+          "#..............#",
+          "#..............#",
+          "################"
+        ]
+      end
+
+      def spawn = [2.5, 5.0, 0.0]
+      def weapon_defs = [[:pistol, nil]]
+
+      def enemy_defs
+        [
+          [10.5, 3.5, 10.5, 6.5, :crawler],
+          [13.5, 7.5, 13.5, 2.5, :crawler]
+        ]
+      end
+    end
+
+    Base.register(TrainingGrounds)
+  end
+end