modsvaskr 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 35bcc4ccf0026926ed167c88235b0da1d1b86735e348b9a5059203ed4389ab89
+  data.tar.gz: 550b218d7b1f3d5c779d68a8e303da98117484219d2009848a31b5f51a3714a9
+SHA512:
+  metadata.gz: deefc507a16b05a96c799f3749dc519d9b3c286bb8a035066e844102e4c6a86138642bd057046b1bd6ea06493a95344d9282eae514920dcfe477b624c8f41f86
+  data.tar.gz: d7b7d7e0944f24eb07cbbbcc0f9bc02c56b687ef4d9dcc8c5edbe3a136c23720e58c61583179bb4b50eac69c698ed53567f66466e743a5db03b1b86cb3a130e4

data/bin/modsvaskr

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# require 'mod_organizer'
+require 'modsvaskr/config'
+require 'modsvaskr/ui'
+
+begin
+  Modsvaskr::Ui.new(config: Modsvaskr::Config.new('./modsvaskr.yaml')).run
+rescue
+  puts "Unhandled exception: #{$!}\n#{$!.backtrace.join("\n")}"
+  puts 'Press Enter to exit.'
+  $stdin.gets
+end

data/lib/modsvaskr/config.rb

@@ -0,0 +1,42 @@
+require 'yaml'
+require 'modsvaskr/game'
+require 'modsvaskr/xedit'
+
+module Modsvaskr
+
+  # Configuration
+  class Config
+
+    # Constructor
+    #
+    # Parameters::
+    # * *file* (String): File containing configuration
+    def initialize(file)
+      @config = YAML.load(File.read(file))
+    end
+
+    # Get the games list
+    #
+    # Result::
+    # * Array<Game>: List of games
+    def games
+      unless defined?(@games)
+        @games = @config['games'].map do |game_info|
+          require "#{__dir__}/games/#{game_info['type']}.rb"
+          Games.const_get(game_info['type'].to_s.split('_').collect(&:capitalize).join.to_sym).new(self, game_info)
+        end
+      end
+      @games
+    end
+
+    # Return the xEdit path
+    #
+    # Result::
+    # * String: The xEdit path
+    def xedit_path
+      @config['xedit']
+    end
+
+  end
+
+end

data/lib/modsvaskr/game.rb

@@ -0,0 +1,61 @@
+require 'yaml'
+require 'modsvaskr/logger'
+require 'modsvaskr/run_cmd'
+
+module Modsvaskr
+
+  # Common functionality for any Game
+  class Game
+
+    include Logger, RunCmd
+
+    # Constructor
+    #
+    # Parameters::
+    # * *config* (Config): The config
+    # * *game_info* (Hash<String,Object>): Game info:
+    #   * *name* (String): Game name
+    #   * *path* (String): Game installation dir
+    def initialize(config, game_info)
+      @config = config
+      @game_info = game_info
+      @name = name
+      init if self.respond_to?(:init)
+    end
+
+    # Return the game name
+    #
+    # Result::
+    # * String: Game name
+    def name
+      @game_info['name']
+    end
+
+    # Return the game path
+    #
+    # Result::
+    # * String: Game path
+    def path
+      @game_info['path']
+    end
+
+    # Return the launch executable
+    #
+    # Result::
+    # * String: Launch executable
+    def launch_exe
+      @game_info['launch_exe']
+    end
+
+    # Return an xEdit instance for this game
+    #
+    # Result::
+    # * Xedit: The xEdit instance
+    def xedit
+      @xedit = Xedit.new(@config.xedit_path, path) unless defined?(@xedit)
+      @xedit
+    end
+
+  end
+
+end

data/lib/modsvaskr/games/skyrim_se.rb

@@ -0,0 +1,91 @@
+require 'open-uri'
+require 'tmpdir'
+require 'nokogiri'
+
+module Modsvaskr
+
+  module Games
+
+    # Handle a Skyrim installation
+    class SkyrimSe < Game
+
+      SEVEN_ZIP_CMD = {
+        dir: 'C:\Program Files\7-Zip',
+        exe: '7z.exe'
+      }
+
+      # Initialize the game
+      # [API] - This method is optional
+      def init
+        @tmp_dir = "#{Dir.tmpdir}/modsvaskr"
+      end
+
+      # Complete the game menu
+      # [API] - This method is optional
+      #
+      # Parameters::
+      # * *menu* (CursesMenu): Menu to complete
+      def complete_game_menu(menu)
+        menu.item 'Install SKSE64' do
+          install_skse64
+          puts 'Press Enter to continue...'
+          $stdin.gets
+        end
+      end
+
+      # Get the game running executable name (that can be found in a tasks manager)
+      # [API] - This method is mandatory
+      #
+      # Result::
+      # * String: The running exe name
+      def running_exe
+        'SkyrimSE.exe'
+      end
+
+      # List of default esps present in the game (the ones in the Data folder when 0 mod is being used)
+      #
+      # Result::
+      # * Array<String>: List of esp/esm/esl base file names.
+      def game_esps
+        %w[
+          skyrim.esm
+          update.esm
+          dawnguard.esm
+          hearthfires.esm
+          dragonborn.esm
+        ]
+      end
+
+      private
+
+      # Install SKSE64 corresponding to our game
+      def install_skse64
+        doc = Nokogiri::HTML(open('https://skse.silverlock.org/'))
+        p_element = doc.css('p').find { |el| el.text.strip =~ /^Current SE build .+: 7z archive$/ }
+        if p_element.nil?
+          log '!!! Can\'t get SKSE64 from https://skse.silverlock.org/. It looks like the page structure has changed. Please update the code or install it manually.'
+        else
+          url = "https://skse.silverlock.org/#{p_element.at('a')['href']}"
+          path = "#{@tmp_dir}/skse64.7z"
+          FileUtils.mkdir_p File.dirname(path)
+          log "Download from #{url} => #{path}..."
+          open(url, 'rb') do |web_io|
+            File.write(path, web_io.read, mode: 'wb')
+          end
+          skse64_tmp_dir = "#{@tmp_dir}/skse64"
+          log "Unzip into #{skse64_tmp_dir}..."
+          FileUtils.rm_rf skse64_tmp_dir
+          FileUtils.mkdir_p skse64_tmp_dir
+          run_cmd SEVEN_ZIP_CMD, args: ['x', "\"#{path}\"", "-o\"#{skse64_tmp_dir}\"", '-r']
+          skse64_subdir = Dir.glob("#{skse64_tmp_dir}/*").first
+          log "Move files from #{skse64_subdir} to #{self.path}..."
+          FileUtils.cp_r "#{skse64_subdir}/.", self.path, remove_destination: true
+          log 'SKSE64 installed successfully.'
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/modsvaskr/logger.rb

@@ -0,0 +1,25 @@
+module Modsvaskr
+
+  # Mixin adding logging functionality, both on screen and in file
+  module Logger
+
+    class << self
+      attr_accessor :log_file
+    end
+    @log_file = File.expand_path('Modsvaskr.log')
+
+    # Log on screen and in log file
+    #
+    # Parameters::
+    # * *msg* (String): Message to log
+    def log(msg)
+      complete_msg = "[ #{Time.now.strftime('%F %T')} ] - #{msg}"
+      puts complete_msg
+      File.open(Logger.log_file, 'a') do |f|
+        f.puts complete_msg
+      end
+    end
+
+  end
+
+end

data/lib/modsvaskr/run_cmd.rb

@@ -0,0 +1,22 @@
+module Modsvaskr
+
+  module RunCmd
+
+    # Run a given command with eventual parameters
+    #
+    # Parameters::
+    # * *cmd* (Hash<Symbol,Object>): The command description:
+    #   * *dir* (String): Directory in which the command is found
+    #   * *exe* (String): Name of the executable of the command
+    #   * *args* (Array<String>): Default arguments of the command [default = []]
+    # * *args* (Array<String>): Additional arguments to give the command [default: []]
+    def run_cmd(cmd, args: [])
+      Dir.chdir cmd[:dir] do
+        cmd_line = "#{cmd[:exe]} #{((cmd.key?(:args) ? cmd[:args] : []) + args).join(' ')}"
+        raise "Unable to execute command line from \"#{dir}\": #{cmd_line}" unless system cmd_line
+      end
+    end
+
+  end
+
+end

data/lib/modsvaskr/tests_runner.rb

@@ -0,0 +1,430 @@
+require 'json'
+require 'time'
+require 'modsvaskr/tests_suite'
+
+module Modsvaskr
+
+  class TestsRunner
+
+    include Logger
+
+    # Constructor.
+    # Default values are for a standard Skyrim SE installation.
+    #
+    # Parameters::
+    # * *game* (Game): Game for which we run tests
+    # * *tests_poll_secs* (Integer): Number of seconds to poll for the game run and tests changes [default: 5]
+    # * *timeout_frozen_tests_secs* (Integer): Time out (in seconds) between tests updates: if no test has been updated before this timeout, consider the game has crashed. [default: 300]
+    def initialize(
+      game,
+      tests_poll_secs: 5,
+      timeout_frozen_tests_secs: 300
+    )
+      @game = game
+      @tests_poll_secs = tests_poll_secs
+      @timeout_frozen_tests_secs = timeout_frozen_tests_secs
+      # Parse tests suites
+      @tests_suites = Hash[Dir.glob("#{__dir__}/tests_suites/*.rb").map do |tests_suite_file|
+        tests_suite = File.basename(tests_suite_file, '.rb').to_sym
+        require "#{__dir__}/tests_suites/#{tests_suite}.rb"
+        [
+          tests_suite,
+          TestsSuites.const_get(tests_suite.to_s.split('_').collect(&:capitalize).join.to_sym).new(tests_suite, @game)
+        ]
+      end]
+      @tests_info_file = "#{@game.path}/Data/Modsvaskr/Tests/TestsInfo.json"
+    end
+
+    # Return tests suites
+    #
+    # Result::
+    # * Array<Symbol>: List of tests suites
+    def tests_suites
+      @tests_suites.keys
+    end
+
+    # Return test names for a given tests suite
+    #
+    # Parameters::
+    # * *tests_suite* (Symbol): The tests suite
+    # Result::
+    # * Array<String>: Test names of this suite
+    def discover_tests_for(tests_suite)
+      discovered_tests = @tests_suites[tests_suite].discover_tests
+      # Complete our tests information
+      complete_info = tests_info
+      discovered_tests.each do |test_name, test_info|
+        complete_info[tests_suite] = {} unless complete_info.key?(tests_suite)
+        complete_info[tests_suite][test_name] = test_info
+      end
+      update_tests_info(complete_info)
+      discovered_tests.keys
+    end
+
+    # Get test statuses for a given tests suite
+    #
+    # Parameters::
+    # * *tests_suite* (Symbol): The tests suite
+    # Result::
+    # * Array<[String, String]>: Ordered list of couples [test name, test status]
+    def statuses_for(tests_suite)
+      @tests_suites[tests_suite].statuses
+    end
+
+    # Set test statuses for a given tests suite
+    #
+    # Parameters::
+    # * *tests_suite* (Symbol): The tests suite
+    # * *statuses* (Array<[String, String]>): Ordered list of couples [test name, test status])
+    def set_statuses_for(tests_suite, statuses)
+      @tests_suites[tests_suite].set_statuses(statuses)
+    end
+
+    # Return test information
+    #
+    # Parameters::
+    # * *tests_suite* (Symbol): The tests suite
+    # * *test_name* (String): The test name
+    # Result::
+    # * Hash<Symbol,Object>: The test information (all properties are optional):
+    #   * *name* (String): The test full name
+    def test_info(tests_suite, test_name)
+      tests_info.dig(tests_suite, test_name) || {}
+    end
+
+    # Clear tests for a given tests suite
+    #
+    # Parameters::
+    # * *tests_suite* (Symbol): The tests suite
+    def clear_tests_for(tests_suite)
+      @tests_suites[tests_suite].clear_tests
+    end
+
+    # Run tests in a loop until they are all tested
+    #
+    # Parameters::
+    # * *selected_tests* (Hash<Symbol, Array<String> >): Ordered list of tests to be run, per tests suite
+    def run(selected_tests)
+      # Test names (ordered) to be performed in game, per tests suite
+      # Hash< Symbol, Array<String> >
+      in_game_tests = {}
+      selected_tests.each do |tests_suite, suite_selected_tests|
+        if @tests_suites[tests_suite].respond_to?(:run_test)
+          # Simple synchronous tests
+          suite_selected_tests.each do |test_name|
+            # Store statuses after each test just in case of crash
+            set_statuses_for(tests_suite, [[test_name, @tests_suites[tests_suite].run_test(test_name)]])
+          end
+        end
+        if @tests_suites[tests_suite].respond_to?(:auto_tests_for)
+          # We run the tests from the game itself, using AutoTest mod.
+          in_game_tests[tests_suite] = suite_selected_tests
+        end
+      end
+      unless in_game_tests.empty?
+        # Get the list of AutoTest we have to run and that we will monitor
+        in_game_auto_tests = in_game_tests.inject({}) do |merged_auto_tests, (tests_suite, suite_selected_tests)|
+          merged_auto_tests.merge(@tests_suites[tests_suite].auto_tests_for(suite_selected_tests)) do |auto_test_suite, auto_test_tests1, auto_test_tests2|
+            (auto_test_tests1 + auto_test_tests2).uniq
+          end
+        end
+        in_game_auto_tests.each do |auto_test_suite, auto_test_tests|
+          # Write the JSON file that contains the list of tests to run
+          File.write(
+            "#{@game.path}/Data/SKSE/Plugins/StorageUtilData/AutoTest_#{auto_test_suite}_Run.json",
+            JSON.pretty_generate(
+              'stringList' => {
+                'tests_to_run' => auto_test_tests
+              }
+            )
+          )
+          # Clear the AutoTest test statuses
+          File.unlink("#{@game.path}/Data/SKSE/Plugins/StorageUtilData/AutoTest_#{auto_test_suite}_Statuses.json") if File.exist?("#{@game.path}/Data/SKSE/Plugins/StorageUtilData/AutoTest_#{auto_test_suite}_Statuses.json")
+        end
+        auto_test_config_file = "#{@game.path}/Data/SKSE/Plugins/StorageUtilData/AutoTest_Config.json"
+        # Write the JSON file that contains the configuration of the AutoTest tests runner
+        File.write(
+          auto_test_config_file,
+          JSON.pretty_generate(
+            'string' => {
+              'on_start' => 'run',
+              'on_stop' => 'exit'
+            }
+          )
+        )
+        puts ''
+        puts '=========================================='
+        puts '= In-game tests are about to be launched ='
+        puts '=========================================='
+        puts ''
+        puts 'Here is what you need to do once the game will be launched (don\'t launch it by yourself, the test framework will launch it for you):'
+        puts '* Load the game save you want to test (or start a new game).'
+        puts ''
+        puts 'This will execute all in-game tests automatically.'
+        puts ''
+        puts 'It is possible that the game crashes during tests:'
+        puts '* That\'s a normal situation, as tests don\'t mimick a realistic gaming experience, and the Bethesda engine is not meant to be stressed like that.'
+        puts '* In case of game crash (CTD), the Modsvaskr test framework will relaunch it automatically and resume testing from when it crashed.'
+        puts '* In case of repeated CTD on the same test, the Modsvaskr test framework will detect it and skip the crashing test automatically.'
+        puts '* In case of a game freeze without CTD, the Modsvaskr test framework will detect it after a few minutes and automatically kill the game before re-launching it to resume testing.'
+        puts ''
+        puts 'If you want to interrupt in-game testing: invoke the console with ~ key and type stop_tests followed by Enter.'
+        puts ''
+        puts 'Press enter to start in-game testing (this will lauch your game automatically)...'
+        $stdin.gets
+        idx_launch = 0
+        old_statuses = auto_test_statuses
+        loop do
+          launch_game(use_autoload: idx_launch > 0)
+          idx_launch += 1
+          monitor_game_tests
+          # Check tests again
+          new_statuses = auto_test_statuses
+          # Update the tests results based on what has been run in-game
+          in_game_tests.each do |tests_suite, suite_selected_tests|
+            @tests_suites[tests_suite].set_statuses(
+              @tests_suites[tests_suite].
+                parse_auto_tests_statuses_for(suite_selected_tests, new_statuses).
+                select { |(test_name, _test_status)| suite_selected_tests.include?(test_name) }
+            )
+          end
+          log 'Test statuses after game run:'
+          print_test_statuses(new_statuses)
+          # Careful as this JSON file can be written by Papyrus that treat strings as case insensitive.
+          # cf. https://github.com/xanderdunn/skaar/wiki/Common-Tasks
+          auto_test_config = Hash[JSON.parse(File.read(auto_test_config_file))['string'].map { |key, value| [key.downcase, value.downcase] }]
+          if auto_test_config.dig('stopped_by') == 'user'
+            log 'Tests have been stopped by user. Stop looping.'
+            break
+          end
+          if auto_test_config.dig('tests_execution') == 'end'
+            log 'Tests have finished running. Stop looping.'
+            break
+          end
+          if new_statuses == old_statuses
+            log 'No changes in AutoTest tests statuses in the game run. Stop looping.'
+            break
+          end
+          old_statuses = new_statuses
+          # We will start again. Leave some time to interrupt if we want.
+          log 'We are going to start again in 10 seconds. Press Enter now to interrupt it.'
+          key_pressed =
+            begin
+              Timeout.timeout(10) { $stdin.gets }
+            rescue
+              nil
+            end
+          if key_pressed
+            log 'Run interrupted by user.'
+            break
+          end
+        end
+      end
+    end
+
+    private
+
+    # Return all tests info.
+    # Keep a cache of it.
+    #
+    # Result::
+    # * Hash< Symbol, Hash< String, Hash<Symbol,Object> > >: The tests info, per test name, per tests suite
+    def tests_info
+      unless defined?(@tests_info_cache)
+        @tests_info_cache =
+          if File.exist?(@tests_info_file)
+            Hash[JSON.parse(File.read(@tests_info_file)).map do |tests_suite_str, tests_suite_info|
+              [
+                tests_suite_str.to_sym,
+                Hash[tests_suite_info.map { |test_name, test_info| [test_name, test_info.transform_keys(&:to_sym)] }]
+              ]
+            end]
+          else
+            {}
+          end
+      end
+      @tests_info_cache
+    end
+
+    # Update tests info.
+    #
+    # Parameters::
+    # * *tests_info* (Hash< Symbol, Hash< String, Hash<Symbol,Object> > >): The tests info, per test name, per tests suite
+    def update_tests_info(tests_info)
+      # Persist the tests information on disk
+      FileUtils.mkdir_p File.dirname(@tests_info_file)
+      File.write(@tests_info_file, JSON.pretty_generate(tests_info))
+      @tests_info_cache = tests_info
+    end
+
+    # Launch the game, and wait for launch to be successful (get a PID)
+    #
+    # Parameters::
+    # * *use_autoload* (Boolean): If true, then launch the game using AutoLoad
+    def launch_game(use_autoload:)
+      # Launch the game
+      @idx_launch = 0 unless defined?(@idx_launch)
+      Dir.chdir(@game.path) do
+        if use_autoload
+          log "Launch Game (##{@idx_launch}) using AutoLoad..."
+          system "\"#{@game.path}/Data/AutoLoad.cmd\" auto_test"
+        else
+          log "Launch Game (##{@idx_launch}) using configured launcher..."
+          system "\"#{@game.path}/#{@game.launch_exe}\""
+        end
+      end
+      @idx_launch += 1
+      # The game launches asynchronously, so just wait a little bit and check for the process
+      sleep 10
+      tasklist_stdout = nil
+      loop do
+        tasklist_stdout = `tasklist | find "#{@game.running_exe}"`.strip
+        break unless tasklist_stdout.empty?
+        log "#{@game.running_exe} is not running. Wait for its startup..."
+        sleep 1
+      end
+      @game_pid = Integer(tasklist_stdout.split(' ')[1])
+      log "#{@game.running_exe} has started with PID #{@game_pid}"
+    end
+
+    # Kill the game, and wait till it is killed
+    def kill_game
+      first_time = true
+      loop do
+        system "taskkill #{first_time ? '' : '/F'} /pid #{@game_pid}"
+        first_time = false
+        sleep 1
+        tasklist_stdout = `tasklist | find "#{@game.running_exe}"`.strip
+        break if tasklist_stdout.empty?
+        log "#{@game.running_exe} is still running. Wait for its kill..."
+        sleep 5
+      end
+    end
+
+    # Get the list of AutoTest statuses
+    #
+    # Result::
+    # * Hash<String, Array<[String, String]> >: Ordered list of AutoTest [test name, test status], per AutoTest tests suite
+    def auto_test_statuses
+      statuses = {}
+      `dir "#{@game.path}/Data/SKSE/Plugins/StorageUtilData" /B`.split("\n").each do |file|
+        if file =~ /^AutoTest_(.+)_Statuses\.json$/
+          auto_test_suite = $1
+          # Careful as this JSON file can be written by Papyrus that treat strings as case insensitive.
+          # cf. https://github.com/xanderdunn/skaar/wiki/Common-Tasks
+          statuses[auto_test_suite] = JSON.parse(File.read("#{@game.path}/Data/SKSE/Plugins/StorageUtilData/AutoTest_#{auto_test_suite}_Statuses.json"))['string'].map do |test_name, test_status|
+            [test_name.downcase, test_status.downcase]
+          end
+        end
+      end
+      statuses
+    end
+
+    # Loop while monitoring game tests progression.
+    # If the game exits, then exit also the loop.
+    # In case no test is being updated for a long period of time, kill the game (we consider it was frozen)
+    # Prerequisite: launch_game has to be called before.
+    def monitor_game_tests
+      log 'Start monitoring game testing...'
+      last_time_tests_changed = Time.now
+      # Get a picture of current tests
+      current_statuses = auto_test_statuses
+      loop do
+        still_running = true
+        begin
+          # Process.kill does not work when the game has crashed (the process is still detected as zombie)
+          # still_running = Process.kill(0, @game_pid) == 1
+          tasklist_stdout = `tasklist 2>&1`
+          still_running = tasklist_stdout.split("\n").any? { |line| line =~ /#{Regexp.escape(@game.running_exe)}/ }
+          # log "Tasklist returned no Skyrim:\n#{tasklist_stdout}" unless still_running
+        rescue Errno::ESRCH
+          log "Got error while waiting for #{@game.running_exe} PID: #{$!}"
+          still_running = false
+        end
+        # Log a diff in tests
+        new_statuses = auto_test_statuses
+        diff_statuses = diff_statuses(current_statuses, new_statuses)
+        unless diff_statuses.empty?
+          # Tests have progressed
+          last_time_tests_changed = Time.now
+          log '===== Test statuses changes:'
+          diff_statuses.each do |tests_suite, tests_statuses|
+            log "* #{tests_suite}:"
+            tests_statuses.each do |(test_name, test_status)|
+              log "  * #{test_name}: #{test_status}"
+            end
+          end
+        end
+        break unless still_running
+        # If the tests haven't changed for too long, consider the game has frozen, but not crashed. So kill it.
+        if Time.now - last_time_tests_changed > @timeout_frozen_tests_secs
+          log "Last time test have changed is #{last_time_tests_changed.strftime('%F %T')}. Consider the game is frozen, so kill it."
+          kill_game
+          break
+        end
+        current_statuses = new_statuses
+        sleep @tests_poll_secs
+      end
+      log 'End monitoring game testing.'
+    end
+
+    # Diff between test statuses.
+    #
+    # Parameters::
+    # * *statuses1* (Hash<String, Array<[String, String]> >): Test statuses, per test name (in a sorted list), per tests suite
+    # * *statuses2* (Hash<String, Array<[String, String]> >): Test statuses, per test name (in a sorted list), per tests suite
+    # Result::
+    # * Hash<String, Array<[String, String]> >: statuses2 - statuses1
+    def diff_statuses(statuses1, statuses2)
+      statuses = {}
+      statuses1.each do |tests_suite, tests_info|
+        if statuses2.key?(tests_suite)
+          # Handle Hashes as it will be faster
+          statuses1_for_test = Hash[tests_info]
+          statuses2_for_test = Hash[statuses2[tests_suite]]
+          statuses1_for_test.each do |test_name, status1|
+            if statuses2_for_test.key?(test_name)
+              if statuses2_for_test[test_name] != status1
+                # Change in status
+                statuses[tests_suite] = [] unless statuses.key?(tests_suite)
+                statuses[tests_suite] << [test_name, statuses2_for_test[test_name]]
+              end
+            else
+              # This test has been removed
+              statuses[tests_suite] = [] unless statuses.key?(tests_suite)
+              statuses[tests_suite] << [test_name, 'Deleted']
+            end
+          end
+          statuses2_for_test.each do |test_name, status2|
+            unless statuses1_for_test.key?(test_name)
+              # This test has been added
+              statuses[tests_suite] = [] unless statuses.key?(tests_suite)
+              statuses[tests_suite] << [test_name, status2]
+            end
+          end
+        else
+          # All test statuses have been removed
+          statuses[tests_suite] = tests_info.map { |(test_name, _test_status)| [test_name, 'Deleted'] }
+        end
+      end
+      statuses2.each do |tests_suite, tests_info|
+        # All test statuses have been added
+        statuses[tests_suite] = tests_info unless statuses1.key?(tests_suite)
+      end
+      statuses
+    end
+
+    # Print test statuses
+    #
+    # Parameters::
+    # * *statuses* (Hash<String, Array<[String, String]> >): Test statuses, per test name (in a sorted list), per tests suite
+    def print_test_statuses(statuses)
+      statuses.each do |tests_suite, statuses_for_type|
+        next_test_name, _next_test_status = statuses_for_type.find { |(_name, status)| status != 'ok' }
+        log "[ #{tests_suite} ] - #{statuses_for_type.select { |(_name, status)| status == 'ok' }.size} / #{statuses_for_type.size} - Next test to perform: #{next_test_name.nil? ? 'None' : next_test_name}"
+      end
+    end
+
+  end
+
+end

data/lib/modsvaskr/tests_suite.rb

@@ -0,0 +1,69 @@
+require 'fileutils'
+require 'json'
+require 'modsvaskr/logger'
+require 'modsvaskr/run_cmd'
+
+module Modsvaskr
+
+  # Common functionality for any tests suite
+  class TestsSuite
+
+    include Logger, RunCmd
+
+    # Constructor
+    #
+    # Parameters::
+    # * *tests_suite* (Symbol): The tests suite name
+    # * *game* (Game): The game for which this test type is instantiated
+    def initialize(tests_suite, game)
+      @tests_suite = tests_suite
+      @game = game
+    end
+
+    # Get test statuses
+    #
+    # Result::
+    # * Array<[String, String]>: Ordered list of [test name, test status]
+    def statuses
+      File.exist?(json_statuses_file) ? JSON.parse(File.read(json_statuses_file)) : []
+    end
+
+    # Set test statuses.
+    # Add new ones and overwrites existing ones.
+    #
+    # Parameters::
+    # * *statuses* (Array<[String, String]>): Ordered list of [test name, test status]
+    def set_statuses(statuses)
+      current_statuses = self.statuses
+      statuses.each do |(test_name, test_status)|
+        test_status_info = current_statuses.find { |(search_test_name, _search_test_status)| search_test_name == test_name }
+        if test_status_info.nil?
+          # New one. Add it to the end.
+          current_statuses << [test_name, test_status]
+        else
+          # Already existing. Just change its status.
+          test_status_info[1] = test_status
+        end
+      end
+      FileUtils.mkdir_p File.dirname(json_statuses_file)
+      File.write(json_statuses_file, JSON.pretty_generate(current_statuses))
+    end
+
+    # Remove all tests from this suite
+    def clear_tests
+      File.unlink(json_statuses_file) if File.exist?(json_statuses_file)
+    end
+
+    private
+
+    # Get the JSON statuses file name
+    #
+    # Result::
+    # * String: The JSON statuses file name
+    def json_statuses_file
+      "#{@game.path}/Data/Modsvaskr/Tests/Statuses_#{@tests_suite}.json"
+    end
+
+  end
+
+end

data/lib/modsvaskr/tests_suites/exterior_cell.rb

@@ -0,0 +1,130 @@
+module Modsvaskr
+
+  module TestsSuites
+
+    class ExteriorCell < TestsSuite
+
+      # Discover the list of tests information that could be run.
+      # [API] - This method is mandatory
+      #
+      # Result::
+      # * Hash< String, Hash<Symbol,Object> >: Ordered hash of test information, per test name
+      def discover_tests
+        # List of exterior cells coordinates, per worldspace name, per plugin name
+        # Hash< String, Hash< String, Array<[Integer, Integer]> > >
+        exterior_cells = {}
+        @game.xedit.run_script('DumpInfo', only_once: true)
+        CSV.read("#{@game.xedit.install_path}/Edit Scripts/Modsvaskr_ExportedDumpInfo.csv", encoding: 'windows-1251:utf-8').each do |row|
+          esp_name, record_type = row[0..1]
+          if record_type.downcase == 'cell'
+            cell_type, cell_name, cell_x, cell_y = row[3..6]
+            if cell_type == 'cow'
+              if cell_x.nil?
+                log "!!! Invalid record: #{row}"
+              else
+                esp_name.downcase!
+                exterior_cells[esp_name] = {} unless exterior_cells.key?(esp_name)
+                exterior_cells[esp_name][cell_name] = [] unless exterior_cells[esp_name].key?(cell_name)
+                exterior_cells[esp_name][cell_name] << [Integer(cell_x), Integer(cell_y)]
+              end
+            end
+          end
+        end
+        # Test only exterior cells that have been changed by mods, and make sure we test the minimum, knowing that each cell loaded in game tests 5x5 cells around
+        vanilla_esps = @game.game_esps
+        vanilla_exterior_cells = vanilla_esps.inject({}) do |merged_worldspaces, esp_name|
+          merged_worldspaces.merge(exterior_cells[esp_name]) do |worldspace, ext_cells1, ext_cells2|
+            (ext_cells1 + ext_cells2).sort.uniq
+          end
+        end
+        changed_exterior_cells = {}
+        exterior_cells.each do |esp_name, esp_exterior_cells|
+          unless vanilla_esps.include?(esp_name)
+            esp_exterior_cells.each do |worldspace, worldspace_exterior_cells|
+              if vanilla_exterior_cells.key?(worldspace)
+                changed_exterior_cells[worldspace] = [] unless changed_exterior_cells.key?(worldspace)
+                changed_exterior_cells[worldspace].concat(vanilla_exterior_cells[worldspace] & worldspace_exterior_cells)
+              end
+            end
+          end
+        end
+        tests = {}
+        # Value taken from the ini file
+        # TODO: Read it from there (uiGrid)
+        loaded_grid = 5
+        delta_cells = loaded_grid / 2
+        changed_exterior_cells.each do |worldspace, worldspace_exterior_cells|
+          # Make sure we select the minimum cells
+          # Use a Hash of Hashes for the coordinates to speed-up their lookup.
+          remaining_cells = {}
+          worldspace_exterior_cells.each do |(cell_x, cell_y)|
+            remaining_cells[cell_x] = {} unless remaining_cells.key?(cell_x)
+            remaining_cells[cell_x][cell_y] = nil
+          end
+          while !remaining_cells.empty?
+            cell_x, cell_ys = remaining_cells.first
+            cell_y, _nil = cell_ys.first
+            # We want to test cell_x, cell_y.
+            # Knowing that we can test it by loading any cell in the range ((cell_x - delta_cells..cell_x + delta_cells), (cell_y - delta_cells..cell_y + delta_cells)),
+            # check which cell would test the most wanted cells from our list
+            best_cell_x, best_cell_y, best_cell_score = nil, nil, nil
+            (cell_x - delta_cells..cell_x + delta_cells).each do |candidate_cell_x|
+              (cell_y - delta_cells..cell_y + delta_cells).each do |candidate_cell_y|
+                # Check the number of cells that would be tested if we were to test (candidate_cell_x, candidate_cell_y)
+                nbr_tested_cells = remaining_cells.
+                  slice(*(candidate_cell_x - delta_cells..candidate_cell_x + delta_cells)).
+                  inject(0) { |sum_cells, (_cur_cell_x, cur_cell_ys)| sum_cells + cur_cell_ys.slice(*(candidate_cell_y - delta_cells..candidate_cell_y + delta_cells)).size }
+                if best_cell_score.nil? || nbr_tested_cells > best_cell_score
+                  nbr_tested_cells = best_cell_score
+                  best_cell_x = candidate_cell_x
+                  best_cell_y = candidate_cell_y
+                end
+              end
+            end
+            # Remove the tested cells from the remaining ones
+            (best_cell_x - delta_cells..best_cell_x + delta_cells).each do |cur_cell_x|
+              if remaining_cells.key?(cur_cell_x)
+                (best_cell_y - delta_cells..best_cell_y + delta_cells).each do |cur_cell_y|
+                  remaining_cells[cur_cell_x].delete(cur_cell_y)
+                end
+                remaining_cells.delete(cur_cell_x) if remaining_cells[cur_cell_x].empty?
+              end
+            end
+            tests["#{worldspace}/#{best_cell_x}/#{best_cell_y}"] = {
+              name: "Load #{worldspace} cell #{best_cell_x}, #{best_cell_y}"
+            }
+          end
+        end
+        tests
+      end
+
+      # Get the list of tests to be run in the AutoTest mod for a given list of test names.
+      # AutoTest names are case insensitive.
+      # [API] - This method is mandatory for tests needing to be run in-game.
+      #
+      # Parameters::
+      # * *tests* (Array<String>): List of test names
+      # Result::
+      # * Hash<String, Array<String> >: List of AutoTest mod test names, per AutoTest mod tests suite
+      def auto_tests_for(tests)
+        { 'Locations' => tests }
+      end
+
+      # Set statuses based on the result of AutoTest statuses.
+      # AutoTest names are case insensitive.
+      # [API] - This method is mandatory for tests needing to be run in-game.
+      #
+      # Parameters::
+      # * *tests* (Array<String>): List of test names
+      # * *auto_test_statuses* (Hash<String, Array<[String, String]> >): Ordered list of AutoTest [test name, test status], per AutoTest tests suite
+      # Result::
+      # * Array<[String, String]>: Corresponding list of [test name, test status]
+      def parse_auto_tests_statuses_for(tests, auto_test_statuses)
+        auto_test_statuses.key?('Locations') ? auto_test_statuses['Locations'] : []
+      end
+
+    end
+
+  end
+
+end

data/lib/modsvaskr/tests_suites/interior_cell.rb

@@ -0,0 +1,76 @@
+module Modsvaskr
+
+  module TestsSuites
+
+    class InteriorCell < TestsSuite
+
+      # Discover the list of tests information that could be run.
+      # [API] - This method is mandatory
+      #
+      # Result::
+      # * Hash< String, Hash<Symbol,Object> >: Ordered hash of test information, per test name
+      def discover_tests
+        # List of interior cells, per plugin name
+        # Hash< String, Array<String> >
+        interior_cells = {}
+        @game.xedit.run_script('DumpInfo', only_once: true)
+        CSV.read("#{@game.xedit.install_path}/Edit Scripts/Modsvaskr_ExportedDumpInfo.csv", encoding: 'windows-1251:utf-8').each do |row|
+          esp_name, record_type = row[0..1]
+          if record_type.downcase == 'cell'
+            cell_type, cell_name = row[3..4]
+            if cell_type == 'coc'
+              esp_name.downcase!
+              interior_cells[esp_name] = [] unless interior_cells.key?(esp_name)
+              interior_cells[esp_name] << cell_name
+            end
+          end
+        end
+        # Test only interior cells that have been changed by mods
+        vanilla_esps = @game.game_esps
+        vanilla_interior_cells = vanilla_esps.map { |esp_name| interior_cells[esp_name] }.flatten.sort.uniq
+        Hash[interior_cells.
+          map { |esp_name, esp_cells| vanilla_esps.include?(esp_name) ? [] : vanilla_interior_cells & esp_cells }.
+          flatten.
+          sort.
+          uniq.
+          map do |cell_name|
+            [
+              cell_name,
+              {
+                name: "Load cell #{cell_name}"
+              }
+            ]
+          end
+        ]
+      end
+
+      # Get the list of tests to be run in the AutoTest mod for a given list of test names.
+      # AutoTest names are case insensitive.
+      # [API] - This method is mandatory for tests needing to be run in-game.
+      #
+      # Parameters::
+      # * *tests* (Array<String>): List of test names
+      # Result::
+      # * Hash<String, Array<String> >: List of AutoTest mod test names, per AutoTest mod tests suite
+      def auto_tests_for(tests)
+        { 'Locations' => tests }
+      end
+
+      # Set statuses based on the result of AutoTest statuses.
+      # AutoTest names are case insensitive.
+      # [API] - This method is mandatory for tests needing to be run in-game.
+      #
+      # Parameters::
+      # * *tests* (Array<String>): List of test names
+      # * *auto_test_statuses* (Hash<String, Array<[String, String]> >): Ordered list of AutoTest [test name, test status], per AutoTest tests suite
+      # Result::
+      # * Array<[String, String]>: Corresponding list of [test name, test status]
+      def parse_auto_tests_statuses_for(tests, auto_test_statuses)
+        auto_test_statuses.key?('Locations') ? auto_test_statuses['Locations'] : []
+      end
+
+    end
+
+  end
+
+end

data/lib/modsvaskr/tests_suites/npc.rb

@@ -0,0 +1,52 @@
+module Modsvaskr
+
+  module TestsSuites
+
+    class Npc < TestsSuite
+
+      # Discover the list of tests information that could be run.
+      # [API] - This method is mandatory
+      #
+      # Result::
+      # * Hash< String, Hash<Symbol,Object> >: Ordered hash of test information, per test name
+      def discover_tests
+        tests = {}
+        @game.xedit.run_script('DumpInfo', only_once: true)
+        CSV.read("#{@game.xedit.install_path}/Edit Scripts/Modsvaskr_ExportedDumpInfo.csv", encoding: 'windows-1251:utf-8').each do |row|
+          tests["#{row[0].downcase}/#{row[2].to_i(16)}"] = {
+            name: "Take screenshot of #{row[0]} - #{row[3]}"
+          } if row[1].downcase == 'npc_'
+        end
+        tests
+      end
+
+      # Get the list of tests to be run in the AutoTest mod for a given list of test names.
+      # AutoTest names are case insensitive.
+      # [API] - This method is mandatory for tests needing to be run in-game.
+      #
+      # Parameters::
+      # * *tests* (Array<String>): List of test names
+      # Result::
+      # * Hash<String, Array<String> >: List of AutoTest mod test names, per AutoTest mod tests suite
+      def auto_tests_for(tests)
+        { 'NPCs' => tests }
+      end
+
+      # Set statuses based on the result of AutoTest statuses.
+      # AutoTest names are case insensitive.
+      # [API] - This method is mandatory for tests needing to be run in-game.
+      #
+      # Parameters::
+      # * *tests* (Array<String>): List of test names
+      # * *auto_test_statuses* (Hash<String, Array<[String, String]> >): Ordered list of AutoTest [test name, test status], per AutoTest tests suite
+      # Result::
+      # * Array<[String, String]>: Corresponding list of [test name, test status]
+      def parse_auto_tests_statuses_for(tests, auto_test_statuses)
+        auto_test_statuses.key?('NPCs') ? auto_test_statuses['NPCs'] : []
+      end
+
+    end
+
+  end
+
+end

data/lib/modsvaskr/ui.rb

@@ -0,0 +1,167 @@
+require 'csv'
+require 'launchy'
+require 'curses_menu'
+require 'modsvaskr/logger'
+require 'modsvaskr/tests_runner'
+require 'modsvaskr/run_cmd'
+require 'modsvaskr/version'
+
+module Modsvaskr
+
+  class Ui
+
+    include Logger, RunCmd
+
+    # Constructor
+    #
+    # Parameters::
+    # * *config* (Config): Configuration object
+    def initialize(config:, skyrim: nil)
+      log "Launch Modsvaskr UI v#{Modsvaskr::VERSION} - Logs in #{Logger.log_file}"
+      @config = config
+    end
+
+    # Run the UI
+    def run
+      begin
+        CursesMenu.new 'Modsvaskr - Stronghold of Mods' do |main_menu|
+          @config.games.each do |game|
+            main_menu.item "#{game.name} (#{game.path})" do
+              CursesMenu.new "Modsvaskr - Stronghold of Mods > #{game.name}" do |game_menu|
+                game_menu.item 'Testing' do
+                  # Read tests info
+                  tests_runner = TestsRunner.new(game)
+                  # Selected test names, per test type
+                  # Hash< Symbol, Hash< String, nil > >
+                  selected_tests_suites = {}
+                  CursesMenu.new "Modsvaskr - Stronghold of Mods > #{game.name} > Testing" do |test_menu|
+                    tests_runner.tests_suites.each do |tests_suite|
+                      statuses_for_suite = tests_runner.statuses_for(tests_suite)
+                      all_tests_selected = selected_tests_suites.key?(tests_suite) &&
+                        selected_tests_suites[tests_suite].keys.sort == statuses_for_suite.map { |(test_name, _test_status)| test_name }.sort
+                      test_menu.item(
+                        "[#{
+                          if all_tests_selected
+                            '*'
+                          elsif selected_tests_suites.key?(tests_suite)
+                            '+'
+                          else
+                            ' '
+                          end
+                        }] #{tests_suite} - #{statuses_for_suite.select { |(_name, status)| status == 'ok' }.size} / #{statuses_for_suite.size}",
+                        actions: {
+                          'd' => {
+                            name: 'Details',
+                            execute: proc do
+                              CursesMenu.new "Modsvaskr - Stronghold of Mods > #{game.name} > Testing > Tests #{tests_suite}" do |tests_suite_menu|
+                                statuses_for_suite.each do |(test_name, test_status)|
+                                  test_selected = selected_tests_suites.key?(tests_suite) && selected_tests_suites[tests_suite].key?(test_name)
+                                  tests_suite_menu.item "[#{test_selected ? '*' : ' '}] #{test_name} - #{test_status} - #{tests_runner.test_info(tests_suite, test_name)[:name]}" do
+                                    if test_selected
+                                      selected_tests_suites[tests_suite].delete(test_name)
+                                      selected_tests_suites.delete(tests_suite) if selected_tests_suites[tests_suite].empty?
+                                    else
+                                      selected_tests_suites[tests_suite] = {} unless selected_tests_suites.key?(tests_suite)
+                                      selected_tests_suites[tests_suite][test_name] = nil
+                                    end
+                                    :menu_refresh
+                                  end
+                                end
+                                tests_suite_menu.item 'Back' do
+                                  :menu_exit
+                                end
+                              end
+                              :menu_refresh
+                            end
+                          }
+                        }
+                      ) do
+                        if all_tests_selected
+                          selected_tests_suites.delete(tests_suite)
+                        else
+                          selected_tests_suites[tests_suite] = Hash[statuses_for_suite.map { |(test_name, _test_status)| [test_name, nil] }]
+                        end
+                        :menu_refresh
+                      end
+                    end
+                    test_menu.item 'Select tests that are not ok' do
+                      selected_tests_suites = {}
+                      tests_runner.tests_suites.map do |tests_suite|
+                        tests_not_ok = {}
+                        tests_runner.statuses_for(tests_suite).each do |(test_name, test_status)|
+                          tests_not_ok[test_name] = nil unless test_status == 'ok'
+                        end
+                        selected_tests_suites[tests_suite] = tests_not_ok unless tests_not_ok.empty?
+                      end
+                      :menu_refresh
+                    end
+                    test_menu.item 'Register tests from selected test types' do
+                      selected_tests_suites.keys.each do |tests_suite|
+                        tests_runner.set_statuses_for(
+                          tests_suite,
+                          (
+                            tests_runner.discover_tests_for(tests_suite) -
+                              tests_runner.statuses_for(tests_suite).map { |(test_name, _test_status)| test_name }
+                          ).map { |test_name| [test_name, ''] }
+                        )
+                      end
+                      :menu_refresh
+                    end
+                    test_menu.item 'Unregister tests from selected test types' do
+                      selected_tests_suites.keys.each do |tests_suite|
+                        tests_runner.clear_tests_for(tests_suite)
+                      end
+                      :menu_refresh
+                    end
+                    test_menu.item 'Clear selected test statuses' do
+                      selected_tests_suites.each do |tests_suite, test_names_set|
+                        tests_runner.set_statuses_for(tests_suite, test_names_set.keys.map { |test_name| [test_name, ''] })
+                      end
+                      :menu_refresh
+                    end
+                    test_menu.item 'Run remaining selected tests' do
+                      tests_runner.run(
+                        selected_tests_suites.map do |selected_tests_suite, selected_test_names_set|
+                          [
+                            selected_tests_suite,
+                            # Make sure tests to be run are ordered from the registered list
+                            tests_runner.
+                              statuses_for(selected_tests_suite).map { |(test_name, _test_status)| test_name }.
+                              select { |test_name| selected_test_names_set.key?(test_name) }
+                          ]
+                        end
+                      )
+                      :menu_refresh
+                    end
+                    test_menu.item 'Back' do
+                      :menu_exit
+                    end
+                  end
+                end
+                game.complete_game_menu(game_menu) if game.respond_to?(:complete_game_menu)
+                game_menu.item 'Back' do
+                  :menu_exit
+                end
+              end
+            end
+          end
+          main_menu.item 'See logs' do
+            CursesMenu.new 'Modsvaskr - Stronghold of Mods > Logs' do |logs_menu|
+              File.read(Logger.log_file).split("\n").each do |line|
+                logs_menu.item line
+              end
+              logs_menu.item 'Back' do
+                :menu_exit
+              end
+            end
+          end
+          main_menu.item 'Quit' do
+            :menu_exit
+          end
+        end
+      end
+    end
+
+  end
+
+end

data/lib/modsvaskr/version.rb

@@ -0,0 +1,5 @@
+module Modsvaskr
+
+  VERSION = '0.0.1'
+
+end

data/lib/modsvaskr/xedit.rb

@@ -0,0 +1,53 @@
+require 'modsvaskr/run_cmd'
+
+module Modsvaskr
+
+  # Helper to use an instance of xEdit
+  class Xedit
+
+    include RunCmd
+
+    # String: Installation path
+    attr_reader :install_path
+
+    # Constructor
+    #
+    # Parameters::
+    # * *install_path* (String): Installation path of xEdit
+    # * *game_path* (String): Installation path of the game to use xEdit on
+    def initialize(install_path, game_path)
+      @install_path = install_path
+      @game_path = game_path
+      # Set of scripts that have been run
+      @runs = {}
+    end
+
+    # Run an xEdit script
+    #
+    # Parameters::
+    # * *script* (String): Script name, as defined in xedit_scripts (without the Modsvaskr_ prefix and .pas suffix)
+    # * *only_once* (Boolean): If true, then make sure this script is run only once by instance [default: false]
+    def run_script(script, only_once: false)
+      if false
+      # if !only_once || !@runs.key?(script)
+        FileUtils.cp "#{__dir__}/../../xedit_scripts/Modsvaskr_#{script}.pas", "#{@install_path}/Edit Scripts/Modsvaskr_#{script}.pas"
+        run_cmd(
+          {
+            dir: @install_path,
+            exe: 'SSEEdit.exe'
+          },
+          args: %W[
+            -IKnowWhatImDoing
+            -AllowMasterFilesEdit
+            -SSE
+            -autoload
+            -script:"Modsvaskr_#{script}.pas"
+          ]
+        )
+        @runs[script] = nil
+      end
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: modsvaskr
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Muriel Salvan
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-11-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: curses_menu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+description:
+email:
+- muriel@x-aeon.com
+executables:
+- modsvaskr
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/modsvaskr
+- lib/modsvaskr/config.rb
+- lib/modsvaskr/game.rb
+- lib/modsvaskr/games/skyrim_se.rb
+- lib/modsvaskr/logger.rb
+- lib/modsvaskr/run_cmd.rb
+- lib/modsvaskr/tests_runner.rb
+- lib/modsvaskr/tests_suite.rb
+- lib/modsvaskr/tests_suites/exterior_cell.rb
+- lib/modsvaskr/tests_suites/interior_cell.rb
+- lib/modsvaskr/tests_suites/npc.rb
+- lib/modsvaskr/ui.rb
+- lib/modsvaskr/version.rb
+- lib/modsvaskr/xedit.rb
+homepage: http://x-aeon.com
+licenses:
+- BSD-3-Clause
+metadata:
+  homepage_uri: http://x-aeon.com
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
+summary: 'Stronghold for mods acting like companions: The Modsvaskr'
+test_files: []