reinforce 0.1.0

data/lib/reinforce/attributes/ability.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Reinforce
+  module Attributes
+    class Ability < Base
+      AUTOBUILDS = %w[
+        abilities/races/american/battlegroups/infantry/infantry_left_2a_medical_tent
+      ].freeze
+
+      SPAWNERS = %w[
+        armored_support_flame_p3_ak
+        armored_support_command_p4_ak
+        italian_combined_arms_bersaglieri_ak
+        italian_combined_arms_semovente_ak
+        italian_combined_arms_m13_40_ak
+        italian_infantry_double_l640_ak
+        italian_infantry_guastatori_ak
+        italian_infantry_cannone_da_105_ak
+        infiltration_left_1_vampire_ht_goliath_ak
+        british_air_and_sea_left_2a_centaur_cs_uk
+        british_air_and_sea_right_1_commandos_uk
+        british_air_and_sea_right_2a_pack_howitzer_team_uk
+        british_air_and_sea_right_2b_commando_lmg_team_uk
+        british_armored_right_2_crusader_aa_uk
+        british_armored_left_2_churchill
+        british_armored_left_3b_churchill_black_prince_uk
+        artillery_gurkhas_uk
+        artillery_4_2_inch_heavy_mortar_uk
+        artillery_bl_5_5_heavy_artillery_uk
+        australian_defense_archer_tank_destroyer_call_in_uk
+        australian_defense_australian_light_infantry_uk
+        australian_defense_2pdr_at_gun_uk
+        airborne_right_1a_pathfinders_us
+        airborne_right_1b_paradrop_hmg_us
+        airborne_right_2_paratrooper_us
+        airborne_right_3_paradrop_at_gun_us
+        armored_left_2b_recovery_vehicle_us
+        armored_right_2a_scott_us
+        armored_right_3_easy_8_task_force_us
+        special_operations_left_1a_m29_weasal_us
+        special_operations_left_1b_m29_weasal_with_pack_howitzer
+        special_operations_left_3_whizbang_us
+        special_operations_right_2_devils_brigade_us
+        infantry_left_1_rifleman_convert_to_ranger_us
+        infantry_right_1a_artillery_observers_us
+        infantry_right_2_105mm_howitzer_us
+        breakthrough_right_3a_assault_group_ger
+        breakthrough_left_1b_truck_2_5_ger
+        breakthrough_left_2b_panzer_iv_cmd_ger
+        breakthrough_left_3_tiger_ger
+        luftwaffe_right_2_fallschirmjagers_ger
+        luftwaffe_left_1b_fallschirmpioneers_ger
+        luftwaffe_left_2b_combat_group_ger
+        luftwaffe_left_2a_weapon_drop_ger
+        luftwaffe_left_3_88mm_at_gun_ger
+        mechanized_right_2a_stug_assault_group_ger
+        mechanized_left_2b_8_rad_ger
+        mechanized_right_3_panther_ger
+        mechanized_left_3a_wespe_ger
+        coastal_left_1_coastal_reserve_ger
+        coastal_artillery_officer_ger
+        coastal_obice_ger
+        halftrack_deployment_panzerjager_inf_1_ak
+        halftrack_deployment_assault_grenadier_1_ak
+        halftrack_deployment_at_gun_1_ak
+        halftrack_deployment_leig_1_ak
+        halftrack_deployment_piv_tank_hunter_group_ak
+        halftrack_deployment_stug_assault_group_ak
+        halftrack_deployment_panzer_iii_assault_group_ak
+        halftrack_deployment_tiger_ak
+      ].to_set
+
+      FILENAME = 'abilities.json'
+
+      attr_reader :builds
+
+      def initialize(path:, pbgid:, locstring:, icon_name:, builds:)
+        super(path:, pbgid:, locstring:, icon_name:)
+        @builds = builds
+      end
+
+      class << self
+      private
+
+        def parse(data)
+          parse_subtree(data, %w[abilities])
+        end
+
+        def parse_subtree(data, key)
+          data.flat_map do |k, tree|
+            new_key = key + [k]
+            if tree.key?('ability_bag')
+              parse_ability_bag(tree, new_key)
+            else
+              parse_subtree(tree, new_key)
+            end
+          end.compact
+        end
+
+        def parse_ability_bag(data, path)
+          locstring = data.dig('ability_bag', 'ui_info', 'screen_name', 'locstring', 'value')
+
+          return if locstring.nil? || locstring == '0'
+
+          icon_name = data.dig('ability_bag', 'ui_info', 'icon_name')
+          builds = data.dig('ability_bag', 'cursor_ghost_ebp', 'instance_reference')
+
+          new(locstring:,
+              icon_name:,
+              builds: builds == '' ? nil : builds,
+              path:,
+              pbgid: data['pbgid'])
+        end
+      end
+
+      def autobuild?
+        @path.include?('auto_build') || @path.include?('autobuild') || AUTOBUILDS.include?(path)
+      end
+
+      def production_building?
+        %r{ebps/races/.+/buildings/production/.+}.match?(@builds)
+      end
+
+      def spawner?
+        SPAWNERS.include?(@path.last)
+      end
+
+      def ==(other)
+        super && @builds == other.builds
+      end
+
+      def as_json(_options)
+        super.merge(builds:)
+      end
+    end
+  end
+end

data/lib/reinforce/attributes/base.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Reinforce
+  module Attributes
+    class Base
+      attr_reader :locstring, :icon_name
+
+      def initialize(path:, pbgid:, locstring:, icon_name:)
+        @path = path
+        @pbgid = pbgid
+        @locstring = locstring
+        @icon_name = icon_name
+      end
+
+      class << self
+        def load_from_file(path)
+          File.open(path) do |file|
+            data = JSON.parse(file.read)
+            parse(data)
+          end
+        end
+
+      private
+
+        def parse(_data)
+          raise NotImplementedError
+        end
+      end
+
+      def path
+        @path.join('/')
+      end
+
+      def pbgid
+        @pbgid.to_i
+      end
+
+      def ==(other)
+        return false unless other.is_a?(self.class)
+
+        path == other.path &&
+          pbgid == other.pbgid &&
+          locstring == other.locstring &&
+          icon_name == other.icon_name
+      end
+
+      def as_json(_options)
+        {
+          path: @path,
+          pbgid:,
+          locstring:,
+          icon_name:
+        }
+      end
+
+      def to_json(*options)
+        as_json(*options).to_json(*options)
+      end
+    end
+  end
+end

data/lib/reinforce/attributes/collection.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Reinforce
+  module Attributes
+    class Collection
+      LATEST_BUILD = -1
+
+      def initialize
+        @pbgid_keyed = {}
+        @path_keyed = {}
+      end
+
+      class << self
+        def generate_for(klass, pretty: false)
+          collection = load_from_data(klass)
+
+          collection.rehash_all
+
+          generation_path = File.join(Reinforce.root, 'generated', klass::FILENAME)
+          json = pretty ? JSON.pretty_generate(collection) : JSON.generate(collection)
+          File.write(generation_path, json)
+
+          true
+        end
+
+        def instance
+          return @instance if defined?(@instance)
+
+          @instance = new
+
+          [Ability, Entity, Squad, Upgrade].each do |klass|
+            generated_path = File.join(Reinforce.root, 'generated', klass::FILENAME)
+            File.open(generated_path) do |file|
+              data = JSON.parse(file.read)
+              data.each do |build, attributes|
+                @instance.populate(build, attributes.map { |a| klass.new(**a.transform_keys(&:to_sym)) }, rehash: false)
+              end
+            end
+          end
+
+          @instance.rehash_all
+          @instance
+        end
+
+        def load_for(klass)
+          collection = new
+          generated_path = File.join(Reinforce.root, 'generated', klass::FILENAME)
+          File.open(generated_path) do |file|
+            data = JSON.parse(file.read)
+            data.each do |build, attributes|
+              collection.populate(build, attributes.map { |a| klass.new(**a.transform_keys(&:to_sym)) }, rehash: false)
+            end
+          end
+
+          collection.rehash_all
+          collection
+        end
+
+      private
+
+        def load_from_data(klass)
+          collection = new
+          data_path = File.join(Reinforce.root, 'data')
+
+          Dir.chdir(data_path) do
+            Dir.glob('*').select { |f| File.directory?(f) }.each do |dir|
+              file_path = File.join(dir, klass::FILENAME)
+              next unless File.exist?(file_path)
+
+              data = klass.load_from_file(file_path)
+              collection.populate(dir, data, rehash: false)
+            end
+          end
+
+          collection
+        end
+      end
+
+      def get_by_pbgid(pbgid, build: LATEST_BUILD)
+        return nil if build.nil?
+
+        build = last_build if build == LATEST_BUILD
+        @pbgid_keyed.dig(build, pbgid) || get_by_pbgid(pbgid, build: previous_build_for(build))
+      end
+
+      def get_by_path(path, build: LATEST_BUILD)
+        return nil if build.nil?
+
+        build = last_build if build == LATEST_BUILD
+        @path_keyed.dig(build, path) || get_by_path(path, build: previous_build_for(build))
+      end
+
+      def populate(build, data, rehash: true)
+        populate_pbgid_hash(build, data)
+        populate_path_hash(build, data)
+
+        rehash_all if rehash
+        true
+      end
+
+      def rehash_all
+        rehash(@pbgid_keyed)
+        rehash(@path_keyed)
+      end
+
+      def as_json(_options)
+        @pbgid_keyed.transform_values(&:values)
+      end
+
+      def to_json(*options)
+        as_json(*options).to_json(*options)
+      end
+
+    private
+
+      def populate_pbgid_hash(build, data)
+        @pbgid_keyed[build.to_i] ||= {}
+        @pbgid_keyed[build.to_i] = @pbgid_keyed[build.to_i].merge(data.to_h { |o| [o.pbgid, o] })
+      end
+
+      def populate_path_hash(build, data)
+        @path_keyed[build.to_i] ||= {}
+        @path_keyed[build.to_i] = @path_keyed[build.to_i].merge(data.to_h { |o| [o.path, o] })
+      end
+
+      def first_build
+        @pbgid_keyed.keys.min
+      end
+
+      def last_build
+        @pbgid_keyed.keys.max
+      end
+
+      def previous_build_for(build)
+        @pbgid_keyed.keys.sort.reverse.find { |b| b < build }
+      end
+
+      def rehash(hash)
+        previous = nil
+
+        hash.keys.sort.each do |build|
+          next previous = build if previous.nil?
+
+          hash[build].each do |key, value|
+            hash[build].delete(key) if value == hash[previous][key]
+          end
+
+          hash[build] = hash[previous].merge(hash[build])
+
+          previous = build
+        end
+      end
+    end
+  end
+end

data/lib/reinforce/attributes/entity.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Reinforce
+  module Attributes
+    class Entity < Base
+      FILENAME = 'ebps.json'
+
+      attr_reader :spawns, :upgrades
+
+      def initialize(path:, pbgid:, locstring:, icon_name:, spawns:, upgrades:)
+        super(path:, pbgid:, locstring:, icon_name:)
+        @spawns = spawns
+        @upgrades = upgrades
+      end
+
+      class << self
+      private
+
+        def parse(data)
+          parse_subtree(data, %w[ebps])
+        end
+
+        def parse_subtree(data, key)
+          data.flat_map do |k, tree|
+            new_key = key + [k]
+            if tree.key?('extensions')
+              parse_extensions(tree, new_key)
+            else
+              parse_subtree(tree, new_key)
+            end
+          end.compact
+        end
+
+        def parse_extensions(data, path)
+          locstring = parse_locstring(data)
+
+          return if locstring.nil? || locstring == '0'
+
+          new(locstring:,
+              icon_name: parse_icon_name(data),
+              path:,
+              spawns: parse_spawns(data),
+              upgrades: parse_upgrades(data),
+              pbgid: data['pbgid'])
+        end
+
+        def parse_locstring(data)
+          ext_data = data['extensions'].find { |ext| ext['exts'].key?('screen_name') }
+          ext_data&.dig('exts', 'screen_name', 'locstring', 'value')
+        end
+
+        def parse_icon_name(data)
+          ext_data = data['extensions'].find { |ext| ext['exts'].key?('screen_name') }
+          ext_data.dig('exts', 'icon_name')
+        end
+
+        def parse_spawns(data)
+          ext_spawns = data['extensions'].find { |ext| ext['exts'].key?('spawn_items') }
+          (ext_spawns&.dig('exts', 'spawn_items') || []).map do |item|
+            item.dig('spawn_item', 'squad', 'instance_reference')
+          end
+        end
+
+        def parse_upgrades(data)
+          ext_upgrades = data['extensions'].find { |ext| ext['exts'].key?('standard_upgrades') }
+          (ext_upgrades&.dig('exts', 'standard_upgrades') || []).map do |item|
+            item.dig('upgrade', 'instance_reference')
+          end
+        end
+      end
+
+      def produces?(path)
+        @spawns.include?(path) || @upgrades.include?(path)
+      end
+
+      def ==(other)
+        super && @spawns == other.spawns && @upgrades == other.upgrades
+      end
+
+      def as_json(_options)
+        super.merge(spawns:, upgrades:)
+      end
+    end
+  end
+end

data/lib/reinforce/attributes/squad.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Reinforce
+  module Attributes
+    class Squad < Base
+      FILENAME = 'sbps.json'
+
+      class << self
+      private
+
+        def parse(data)
+          parse_subtree(data, %w[sbps])
+        end
+
+        def parse_subtree(data, key)
+          data.flat_map do |k, tree|
+            new_key = key + [k]
+            if tree.key?('extensions')
+              parse_extensions(tree, new_key)
+            else
+              parse_subtree(tree, new_key)
+            end
+          end.compact
+        end
+
+        def parse_extensions(data, path)
+          squad_data = squad_data_from(data)
+          locstring = squad_data&.dig('race_data', 'info', 'screen_name', 'locstring', 'value')
+
+          return if locstring.nil? || locstring == '0'
+
+          icon_name = squad_data.dig('race_data', 'info', 'icon_name')
+
+          new(locstring:,
+              icon_name:,
+              path:,
+              pbgid: data['pbgid'])
+        end
+
+        def squad_data_from(data)
+          race_ext = data['extensions'].find do |ext|
+            ext['squadexts'].key?('race_list')
+          end
+
+          race_ext&.dig('squadexts', 'race_list')&.find do |entry|
+            !entry.dig('race_data', 'info', 'screen_name').nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reinforce/attributes/upgrade.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Reinforce
+  module Attributes
+    class Upgrade < Base
+      FILENAME = 'upgrade.json'
+
+      class << self
+      private
+
+        def parse(data)
+          parse_subtree(data, %w[upgrade])
+        end
+
+        def parse_subtree(data, key)
+          data.flat_map do |k, tree|
+            new_key = key + [k]
+            if tree.key?('upgrade_bag')
+              parse_upgrade_bag(tree, new_key)
+            else
+              parse_subtree(tree, new_key)
+            end
+          end.compact
+        end
+
+        def parse_upgrade_bag(data, path)
+          locstring = data.dig('upgrade_bag', 'ui_info', 'screen_name', 'locstring', 'value')
+
+          return if locstring.nil? || locstring == '0'
+
+          icon_name = data.dig('upgrade_bag', 'ui_info', 'icon_name')
+
+          new(locstring:,
+              icon_name:,
+              path:,
+              pbgid: data['pbgid'])
+        end
+      end
+    end
+  end
+end

data/lib/reinforce/command.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Reinforce
+  class Command
+    attr_reader :action_type, :tick, :pbgid, :source, :index, :details
+
+    # rubocop:disable Metrics/AbcSize
+    def initialize(command_hash, build_number)
+      @action_type = command_hash.keys.first
+      @tick = command_hash.values.first[:tick]
+      @pbgid = command_hash.values.first[:pbgid]
+      @source = command_hash.values.first[:source_identifier]
+      @index = command_hash.values.first[:queue_index]
+      @details = Attributes::Collection.instance.get_by_pbgid(@pbgid, build: build_number)
+      @cancelled = false
+      @suspect_from_tick = nil
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def cancelled?
+      @cancelled
+    end
+
+    def cancel
+      @cancelled = true
+    end
+
+    def suspect?
+      !@suspect_from_tick.nil?
+    end
+
+    def mark_suspect(tick)
+      @suspect_from_tick = tick
+    end
+
+    def mark_legit
+      @suspect_from_tick = nil
+    end
+
+    def suspect_since
+      @suspect_from_tick
+    end
+
+    def as_json(_options)
+      {
+        action: action_type,
+        tick:,
+        pbgid:,
+        locstring: @details.locstring,
+        icon_name: @details.icon_name
+      }
+    end
+
+    def to_json(*options)
+      as_json(*options).to_json(*options)
+    end
+  end
+end

data/lib/reinforce/factory.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Reinforce
+  class Factory
+    BUILDING_COMMANDS = %w[UseAbility].freeze
+    PRODUCTION_COMMANDS = %w[BuildSquad BuildGlobalUpgrade].freeze
+    BATTLEGROUP_COMMANDS = %w[SelectBattlegroup SelectBattlegroupAbility UseBattlegroupAbility].freeze
+    CANCEL_COMMANDS = %w[CancelConstruction CancelProduction].freeze
+    ALL_COMMANDS = BUILDING_COMMANDS + PRODUCTION_COMMANDS + BATTLEGROUP_COMMANDS + CANCEL_COMMANDS
+
+    def initialize(player, build_number)
+      @player = player.to_h
+      @build_number = build_number
+      @buildings = []
+      @productions = {}
+      @battlegroup = []
+    end
+
+    def build(with_cancellations: false)
+      commands.each { |c| classify_command(c) }
+      result = consolidate
+      result = rectify_suspects(result)
+      result = result.reject(&:cancelled?) unless with_cancellations
+      result
+    end
+
+  private
+
+    def commands
+      @commands ||= @player[:commands].filter { |c| ALL_COMMANDS.include?(c.keys.first) }
+                                      .map { |c| Command.new(c, @build_number) }
+    end
+
+    def classify_command(command)
+      if BUILDING_COMMANDS.include?(command.action_type)
+        classify_building_command(command)
+      elsif PRODUCTION_COMMANDS.include?(command.action_type)
+        classify_production_command(command)
+      elsif BATTLEGROUP_COMMANDS.include?(command.action_type)
+        classify_battlegroup_command(command)
+      elsif CANCEL_COMMANDS.include?(command.action_type)
+        process_cancellation(command)
+      end
+    end
+
+    def classify_building_command(command)
+      @buildings << command if command.details.autobuild?
+    end
+
+    def classify_production_command(command)
+      @productions[command.source] ||= []
+      @productions[command.source] << command
+    end
+
+    def classify_battlegroup_command(command)
+      if command.details.respond_to?(:autobuild?) && command.details.autobuild?
+        @buildings << command
+      else
+        @battlegroup << command
+      end
+    end
+
+    def process_cancellation(command)
+      if command.action_type == 'CancelConstruction'
+        @buildings.reject(&:suspect?).each { |building| building.mark_suspect(command.tick) }
+      else
+        @productions[command.source][command.index - 1].cancel
+      end
+    end
+
+    def consolidate
+      build = @buildings + @battlegroup + @productions.values.flatten
+      build.sort_by(&:tick)
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def rectify_suspects(commands)
+      commands.each_with_index do |command, idx|
+        next unless command.suspect?
+
+        building_details = Attributes::Collection.instance.get_by_path(command.details.builds, build: @build_number)
+        remaining = commands[(idx + 1)..]
+        relevant = remaining.take_while { |c| c.pbgid != command.pbgid }
+
+        used = relevant.any? do |c|
+          building_details.produces?(c.details.path)
+        end
+
+        command.mark_legit if used
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+  end
+end

data/lib/reinforce/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Reinforce
+  VERSION = '0.1.0'
+end