sc2ai 0.5.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b421602e2cdff4d59e4b3b4ab168f7d894a43f4474244b229ec72c78d6bf6a9
-  data.tar.gz: cbc072cb8a55cacabd0ac751ff5286f582c0145241a98343834f0c0def7c31c1
+  metadata.gz: a52a7a32bf219355f194817695d5505e47a897da5f3023ff856f4c88a66cc4d0
+  data.tar.gz: 94a565f3dc3c3f43896559664961242a9c06b30429bb41345183eb3fd680f29c
 SHA512:
-  metadata.gz: df8e5f7a8557d0f3dce348cbd9dcdc8ef8f03f88b5f00376d7972b36c223e042ed61123612642189e2722b0a62eb22f7f02a16ca5650864bdd8f3a49ddc86680
-  data.tar.gz: d5094e865be75f4b7c31b25a41ff8f021edbb4380567f304a39c1ade99d3155fa408d821c980f2751daf85eddee3f8f9c84a81557255e923db524d9570fad817
+  metadata.gz: 8275c1840c4c7a9548a08ccf90215d41d8eabea15f7915109221f0c8c1deba96847103fc7f552927304c23b702a53aab5f091d8af7a52da33d7d0c419cfe2369
+  data.tar.gz: c547597a3bfb0babfbc2765c0d9fb6af7fab9137077faaf6f419ff51cad0cdfc30dd9816bab8383e9559b1cabc88aa5ec908aaf66348e3ac5570192708c23959

data/data/sc2ai/protocol/data.proto

@@ -89,7 +89,7 @@ message UnitTypeData {
   optional float sight_range = 25;                                // Range unit reveals vision.
 
   repeated uint32 tech_alias = 21 [packed=false];                                // Other units that satisfy the same tech requirement.
-  optional uint32 unit_alias = 22 [packed=false];                                // The morphed variant of this unit.
+  optional uint32 unit_alias = 22;                                // The morphed variant of this unit.
 
   optional uint32 tech_requirement = 23;                          // Structure required to build this unit. (Or any with the same tech_alias)
   optional bool require_attached = 24;                            // Whether tech_requirement is an add-on.

data/data/sc2ai/protocol/raw.proto

@@ -191,7 +191,7 @@ message ActionRawUnitCommand {
     uint64 target_unit_tag = 3;
   }
   repeated uint64 unit_tags = 4 [packed=false];
-  optional bool queue_command = 5 [packed=false];
+  optional bool queue_command = 5;
 }
 
 message ActionRawCameraMove {

data/docker_build/Dockerfile.aiarenabot

@@ -0,0 +1,12 @@
+FROM aiarena/arenaclient-bot:latest AS build
+LABEL service="bot-ruby-sc2ai-local"
+
+USER root
+WORKDIR /bots/
+
+ARG DEBIAN_DISABLE_RUBYGEMS_INTEGRATION=true
+
+RUN apt-get update
+RUN apt-get install -y unzip
+
+ENTRYPOINT ["/bin/bash"]

data/docker_build/Dockerfile.ruby

@@ -4,7 +4,7 @@ LABEL service="bot-ruby-local"
 USER root
 WORKDIR /root/ruby-builder
 
-ARG RUBY_VERSION=3.4.1
+ARG RUBY_VERSION=3.4.2
 ARG DEBIAN_DISABLE_RUBYGEMS_INTEGRATION=true
 
 # Deps - Ruby build
@@ -65,7 +65,7 @@ RUN /root/ruby-builder/.ruby/bin/bundle config set --global without test develop
 RUN apt-get update
 RUN apt-get purge $(aptitude search '~i!~M!~prequired!~pimportant!~R~prequired!~R~R~prequired!~R~pimportant!~R~R~pimportant!busybox!grub!initramfs-tools' | awk '{print $2}')  --assume-yes
 RUN apt-get purge aptitude  --assume-yes
-RUN apt-get install zip openssl build-essential libopenblas0-serial libffi-dev --assume-yes
+RUN apt-get install zip openssl build-essential libffi-dev --assume-yes
 RUN apt-get autoremove --assume-yes
 RUN apt-get clean --assume-yes
 

data/docker_build/docker-compose-base-image.yml

@@ -1,4 +1,3 @@
-version: "3.9"
 services:
   bot:
     image: dysonreturns/aiarena-ruby-builder:latest

data/docker_build/docker-compose-ladderzip.yml

@@ -1,4 +1,3 @@
-version: "3.9"
 services:
   bot:
     image: dysonreturns/aiarena-ruby-builder:latest

data/docker_build/docker-compose-versus-bot.yml

@@ -0,0 +1,15 @@
+services:
+  versus_bot:
+    container_name: versus_bot_container
+    image: dysonreturns/arenaclient-bot:local
+    environment:
+      - CPPFLAGS=-DPNG_ARM_NEON_OPT=0
+    platform: "linux/amd64"
+    tty: true
+    build:
+      dockerfile: ./Dockerfile.aiarenabot
+    ports:
+      - "${SERVER_BASE_PORT}:${SERVER_BASE_PORT}/udp"
+      - "${SERVER_GAME_PORT}:${SERVER_GAME_PORT}"
+      - "${CLIENT_BASE_PORT}:${CLIENT_BASE_PORT}/udp"
+      - "${CLIENT_GAME_PORT}:${CLIENT_GAME_PORT}"

data/lib/sc2ai/api/data.rb

@@ -108,6 +108,8 @@ module Sc2
       correct_unit_type_costs
       correct_unit_type_sum
       decorate_unit_type_placement_length
+      decorate_missing_values
+      decorate_weapon_helpers
     end
 
     # @private
@@ -256,9 +258,11 @@ module Sc2
       end
     end
 
+    private
+
     # @private
     # Adds placement_length to units if applicable
-    private def decorate_unit_type_placement_length
+    def decorate_unit_type_placement_length
       @units.each_value do |unit_type_data|
         unit_type_data.placement_length = 0
         next unless unit_type_data.ability_id
@@ -269,5 +273,59 @@ module Sc2
         end
       end
     end
+
+    # @private
+    # Adds values missing from the API
+    def decorate_missing_values
+      # Battlecruiser has no weapons. Force these in by hand.
+      @units[Api::UnitTypeId::BATTLECRUISER].weapons = [
+        Api::Weapon.new(
+          type: Api::Weapon::TargetType::GROUND,
+          damage: 8.0,
+          damage_bonus: [],
+          attacks: 1,
+          range: 6.0,
+          speed: 0.224
+        ),
+        Api::Weapon.new(
+          type: Api::Weapon::TargetType::AIR,
+          damage: 5.0,
+          damage_bonus: [],
+          attacks: 1,
+          range: 6.0,
+          speed: 0.224
+        )
+      ]
+    end
+
+    # @private
+    # Adds ground_damage, air_damage, ground_range, air_range, ground_dps and air_dps
+    def decorate_weapon_helpers
+      @units.each do |unit_type_id, unit_type_data|
+        ground_weapon = unit_type_data.weapons.find do |weapon|
+          weapon.type == :GROUND || weapon.type == :ANY
+        end
+
+        air_weapon = unit_type_data.weapons.find do |weapon|
+          weapon.type == :AIR || weapon.type == :ANY
+        end
+
+        unit_type_data.ground_range = ground_weapon&.range || 0.0
+        unit_type_data.air_range = air_weapon&.range || 0.0
+
+        ground_attacks = ground_weapon&.attacks || 0
+        air_attacks = air_weapon&.attacks || 0
+        base_ground_damage = ground_weapon&.damage || 0.0
+        base_air_damage = air_weapon&.damage || 0.0
+        ground_attack_speed = ground_weapon&.speed || 1.0
+        air_attack_speed = air_weapon&.speed || 1.0
+
+        unit_type_data.ground_damage = base_ground_damage * ground_attacks
+        unit_type_data.air_damage = base_air_damage * air_attacks
+
+        unit_type_data.ground_dps = unit_type_data.ground_damage / ground_attack_speed
+        unit_type_data.air_dps = unit_type_data.air_damage / air_attack_speed
+      end
+    end
   end
 end

data/lib/sc2ai/cli/cli.rb

@@ -2,6 +2,7 @@ require "thor"
 
 require "sc2ai/cli/new"
 require "sc2ai/cli/ladderzip"
+require "sc2ai/cli/versus_bot"
 
 module Sc2
   # Command line utilities
@@ -16,36 +17,22 @@ module Sc2
 
     register(Sc2::Cli::New, "new", "new BOTNAME RACE", "Creates botname folder with bot template")
     register(Sc2::Cli::Ladderzip, "ladderzip", "ladderzip BOTNAME", "Prepares a zip via docker for supplied aiarena bot name")
+    register(Sc2::Cli::VersusBot, "vsbot", "vsbot FILENAME", "Copies target zip to docker and starts a match")
 
     # TODO: Use thor's #ask and other methods helpers of raw $stdin and puts.
     desc "setup410", "Downloads and install SC2 v4.10"
     # downloads and install SC2 v4.10
     def setup410
-      say " "
-      say "This script sets up SC2 at version 4.10, which we use competitively."
-      say "Press any key to continue..."
-      ask ""
-
-      say "You must accept the Blizzard® StarCraft® II AI and Machine Learning License at"
-      say "https://blzdistsc2-a.akamaihd.net/AI_AND_MACHINE_LEARNING_LICENSE.html"
-      say "It is PERMISSIVE and grants you freedoms over the standard EULA."
-      say "We do not record this action, but depend on software goverend by that license to continue."
-      puts 'If you accept, type "iagreetotheeula" (without quotes) and press ENTER to continue:'
-
-      while $stdin.gets.chomp != "iagreetotheeula"
-        say ""
-        puts 'Type "iagreetotheeula" (without quotes) and press ENTER to continue:'
-      end
-      say ""
-      say ""
-      say "Great decision."
-
       require "sc2ai"
       Async do
         Sc2.logger.level = :fatal
+        say " "
+        say "This script sets up SC2 at version 4.10, which we use competitively."
         say "SC2 will launch a blank window, be unresponsive, but download about 100mb in the background."
+        say ""
+        say "It will appear to hang as it updates. This is normal."
         say "Let it finish and close itself."
-        say "Press ENTER if you understand."
+        say "Press any key to continue..."
         ask ""
 
         say ""
@@ -110,23 +97,6 @@ module Sc2
       Sc2.logger.info "  interface_options: #{$bot.interface_options}"
     end
 
-    # desc "ladderzip", "Uses docker to cross-compile a compatible binary for the ladder"
-    # def ladderzip
-    # end
-
-    # desc "ladderquickzip", "Ladder zip, if you have no additional gems installed."
-    # long_desc <<-LONGDESC
-    #   `sc2ai ladderzip_basic` will download a portable ruby and gems, then copy your bot files into a zip file.
-    #
-    #   If you have added any gems which need compiling, this option is not for you.
-    #   Any gems built with native extensions will likely not be targeting the linux platform and be nonfunctional.
-    #
-    #   For a cross-platform build, use ladderzip instead. This will launch a Docker container to compile a zip for you.
-    # LONGDESC
-    # def ladderquickzip
-    #   raise Sc2::Error, "Not yet implemented."
-    # end
-
     desc "laddermatch", "Joins a ladder match as per aiarena spec"
     option :GamePort, required: true, desc: "SC2 port. Corresponds to SC2 launch option '-port'"
     option :LadderServer, required: true, desc: "SC2 server ip or hostname"
@@ -162,16 +132,6 @@ module Sc2
         $bot.play
       end.wait
     end
-
-    # desc "install APP_NAME", "install one of the available apps"   # [4]
-    # method_options :force => :boolean, :alias => :string           # [5]
-    # def install(name)
-    #   user_alias = options[:alias]
-    #   if options.force?
-    #     # do something
-    #   end
-    #   # other code
-    # end
   end
   # standard:enable Style/GlobalVars
 end

data/lib/sc2ai/cli/ladderzip.rb

@@ -78,8 +78,12 @@ module Sc2
         # create_link("./.build/#{botname}", "./bin/ladder")
       end
 
+      def create_ladderbots_json
+        template("ladderzip/ladderbots.json", "./.build/ladderbots.json")
+      end
+
       def start_container
-        cmd = "docker compose -f #{@compose_file} up bot -d --force-recreate"
+        cmd = "docker compose -f #{@compose_file} up versus_bot -d --force-recreate"
         Kernel.system(cmd)
       end
 
@@ -95,6 +99,7 @@ module Sc2
         ignore_pattern -= include_pattern
 
         include_pattern.collect! { |pt| pt.delete_prefix("!") }
+        include_pattern.collect! { |pt| pt + "**/*" if pt.ends_with?("/") }
 
         files = Dir.glob("**/*")
 

data/lib/sc2ai/cli/versus_bot.rb

@@ -0,0 +1,305 @@
+module Sc2
+  # Command line utilities
+  class Cli < Thor
+    # Command line action allowing your bot to play vs a ladder bot via docker
+    class VersusBot < Thor::Group
+      # standard:disable Style/GlobalVars
+      include Thor::Actions
+
+      # Define arguments and options
+      argument :filename, desc: "Path to zip. Relative or absolute."
+      argument :map, desc: "Absolute path or shot name, i.e. 'ThunderbirdAIE', 'ThunderbirdAIE.SC2Map'.", default: "ThunderbirdAIE"
+      desc "Sends a bot zip to the ladder and makes it play against us"
+
+      def get_botname
+        @enemy_botname = File.basename(filename, ".zip")
+      end
+
+      def docker_exists
+        if Kernel.system("docker --version", out: File::NULL, err: File::NULL)
+          say_status("docker", "found", :green)
+        else
+          say_status("docker", "not found", :red)
+          say("Please install 'docker' and/or ensure it's in your PATH to continue.")
+          raise SystemExit
+        end
+
+        if Kernel.system("docker info", out: File::NULL, err: File::NULL)
+          say_status("docker engine", "found", :green)
+        else
+          say("  ")
+          say_status("docker engine", "offline", :red)
+          say("Please start docker engine. If you have Docker Desktop installed, open it before retrying.")
+          raise SystemExit
+        end
+      end
+
+      def bot_validation
+        if Pathname("./boot.rb").exist?
+          say_status("detected boot.rb", "found", :green)
+        else
+          say_status("detected boot.rb", "not found", :red)
+          raise Sc2::Error, "boot.rb not found. Bot started from wrong directory."
+        end
+
+        ENV.delete("AIARENA")
+        require "./boot"
+
+        if $bot.is_a? Sc2::Player
+          say_status("instance $bot", $bot.class, :green)
+        else
+          say_status("instance $bot", $bot.class, :red)
+          raise Sc2::Error, "$bot instance nil or not Sc2::Player. Review boot.rb to ensure it creates $bot."
+        end
+      end
+
+      def self.source_paths
+        [Pathname(".").expand_path.to_s]
+      end
+
+      def self.source_root
+        Paths.template_root.to_s
+      end
+
+      def port_configuration
+        # Start with basic port setup
+        @port_config = Sc2::Ports.port_config_auto(num_players: 2)
+        say_status("port config", "configured", :green)
+        ENV["SERVER_BASE_PORT"] = @port_config.server_port_set.base_port.to_s
+        ENV["SERVER_GAME_PORT"] = @port_config.server_port_set.game_port.to_s
+        ENV["CLIENT_BASE_PORT"] = @port_config.client_port_sets.first.base_port.to_s
+        ENV["CLIENT_GAME_PORT"] = @port_config.client_port_sets.first.game_port.to_s
+
+        # @port_config_env =
+        #   "-e SERVER_BASE_PORT=#{@port_config.server_port_set.base_port} " +
+        #     "-e SERVER_GAME_PORT=#{@port_config.server_port_set.game_port} " +
+        #     "-e CLIENT_BASE_PORT=#{@port_config.client_port_sets.first.base_port} " +
+        #     "-e CLIENT_GAME_PORT=#{@port_config.client_port_sets.first.game_port} "
+
+        # # Create a modified version of ports for docker bot
+        # @client_port_config = @port_config.dup
+        # # Adjust ports for docker
+        # @client_port_config.client_port_sets[0].base_port = 8453
+        # @client_port_config.client_port_sets[0].game_port = 2359
+        #
+        # # Get dynamic assigned ports for host
+        # real_client_base_port = `docker port versus_bot_container 8453/udp`.strip.split(":").last
+        # real_client_game_port = `docker port versus_bot_container 2359`.strip.split(":").last
+        # # Fix our client ports to forward to the docker bot
+        # @port_config.client_port_sets[0].base_port = real_client_base_port.to_i
+        # @port_config.client_port_sets[0].game_port = real_client_game_port.to_i
+      end
+
+      def set_compose_file
+        say_status("docker", "build local play container", :cyan)
+        @compose_file = Sc2::Paths.gem_root
+          .join("docker_build", "docker-compose-versus-bot.yml")
+          .expand_path.to_s
+        @compose_args = "-f #{@compose_file} #{@port_config_env}"
+        cmd = "docker compose #{@compose_args} build"
+        Kernel.system(cmd)
+      end
+
+      def versus_bot_validation
+        if Pathname(filename).exist?
+          say_status("checking zip #{filename}", "found", :green)
+        else
+          say_status("checking zip #{filename}", "not found", :red)
+          raise Sc2::Error, "#{filename} not found. Try an absolute path if relative will not detect."
+        end
+      end
+
+      def contains_ladderbot_json
+        # Max size of the portion where zip filenames are stored
+        max_end_of_cd_size = (1 << 16) - 1 + 22 + 20
+        searching_for_file = "ladderbots.json" # what we want to find
+        found = File.open(Pathname(filename).realpath, "rb") do |f|
+          # Borrowed code, will search near the end of a zip
+          if f.size > max_end_of_cd_size
+            f.seek(-max_end_of_cd_size, IO::SEEK_END)
+          end
+          content = f.read
+          content.include?(searching_for_file)
+        end
+
+        if found
+          say_status("zip contains ladderbots.json", "found", :green)
+        else
+          say_status("zip contains ladderbots.json", "not found", :red)
+          puts "#{filename} should contain ladderbots.json. Add the file to the zip and try again."
+          raise SystemExit
+        end
+      end
+
+      def start_container
+        say_status("docker", "starting bot container", :cyan)
+        cmd = "docker compose #{@compose_args} up versus_bot -d" ## { rand(20) == 0 ?  "--force-recreate" : "" }
+        Kernel.system(cmd)
+      end
+
+      def copy_opponent_zip
+        say_status("docker", "copying opponent...", :cyan)
+        cmd = "docker compose #{@compose_args} cp #{Pathname(filename).realpath} versus_bot:/bots/"
+        Kernel.system(cmd)
+      end
+
+      def extract_opponent
+        say_status("docker", "extracting opponent...", :cyan)
+        cmd = "docker compose #{@compose_args} exec --workdir /bots versus_bot unzip -o #{Pathname(filename).basename} -d #{@enemy_botname}"
+        Kernel.system(cmd)
+      end
+
+      def pull_ladderbots_json
+        require "tempfile"
+
+        say_status("docker", "pulling enemy 'ladderbots.json'", :cyan)
+
+        @temp_path = Tempfile.new("enemy_ladderbots.json").path
+
+        cmd = "docker compose #{@compose_args} cp versus_bot:/bots/#{@enemy_botname}/ladderbots.json #{@temp_path}"
+        Kernel.system(cmd)
+        if File.exist?(@temp_path)
+          say_status("docker", "pulled 'ladderbots.json' ok", :green)
+        else
+          say_status("docker", "error pulling 'ladderbots.json'", :red)
+          exit
+        end
+      end
+
+      def parse_enemy_config
+        say_status("docker", "configuring enemy", :cyan)
+        json = JSON.parse(File.read(@temp_path))
+        bot_json = json["Bots"][@enemy_botname]
+        @enemy_runtime = bot_json["Type"].downcase # "BinaryCpp",
+        @enemy_race = bot_json["Race"].upcase.to_sym
+        @enemy_filename = bot_json["FileName"]
+        @command = case @enemy_runtime
+        when "cppwin32"
+          "wine #{@enemy_filename}.exe"
+        when "cpplinux", "binarycpp"
+          "/bots/#{@enemy_filename}/#{@enemy_filename}"
+        when "dotnetcore"
+          "dotnet #{@enemy_filename}.dll"
+        when "java"
+          "java -jar #{@enemy_filename}.jar"
+        when "nodejs"
+          "node #{@enemy_filename}.js"
+        when "python"
+          "python run.py"
+        else
+          @enemy_filename
+        end
+
+        # Make executable
+        if %w[cpplinux binarycpp].include?(@enemy_runtime)
+          cmd = "docker compose #{@compose_args} exec --workdir /bots/#{@enemy_botname} versus_bot chmod +x #{@command}"
+          Kernel.system(cmd)
+        end
+
+        # Make data dir
+        say_status("docker", "ensure data directory exists", :cyan)
+        cmd = "docker compose #{@compose_args} exec --workdir /bots/#{@enemy_botname} versus_bot sh -c \"mkdir data && chmod +w data\""
+        Kernel.system(cmd)
+      end
+
+      def run_match
+        Async do
+          Sc2.logger.level = :info
+
+          client = Sc2::ClientManager.obtain(0)
+          enemy_client = Sc2::ClientManager.obtain(1)
+
+          if Gem.win_platform?
+            sleep(10)
+          end
+
+          # Ladder specific overrides
+          $bot.realtime = false
+          $bot.opponent_id = @enemy_botname
+
+          say_status("host", "connecting...", :cyan)
+          $bot.connect(host: client.host, port: client.port)
+          say_status("host", "creating game...", :cyan)
+          $bot.create_game(map: MapFile.new(map.to_s), players: [
+            $bot,
+            Sc2::Player.new(race: @enemy_race, name: @enemy_botname, type: Api::PlayerType::PARTICIPANT)
+          ], realtime: false)
+
+          begin
+            Async do
+              say_status("host", "joining game...", :cyan)
+              $bot.join_game(
+                server_host: client.host,
+                port_config: @port_config
+              )
+              $bot.add_listener($bot, klass: Sc2::Connection::StatusListener)
+              $bot.play
+
+              begin
+                safe_player_name = $bot.name.gsub(/\s*[^A-Za-z0-9.-]\s*/, "_").downcase
+                response = $bot.api.save_replay
+                path = Pathname(Paths.bot_data_replay_dir).join("autosave-#{safe_player_name}-vs-#{@enemy_botname}.SC2Replay")
+                f = File.new(path, "wb:ASCII-8BIT")
+                f.write_nonblock(response.data)
+                f.close
+              rescue
+                # Replay save failed
+              end
+              $bot.disconnect
+            end
+
+            Async do
+              say_status("opponent", "joining game...", :cyan)
+
+              # 192... ip
+              # host_ladder_ip = `docker compose #{@compose_args} exec versus_bot sh -c "getent ahostsv4 host.docker.internal | grep STREAM"`.split(" ").first.strip
+              # Local ip
+              # host_ladder_ip = `docker inspect -f '{{range.NetworkSettings.Networks}}{{.Gateway}}{{end}}' versus_bot_container`.strip
+              enemy_command = [@command,
+                # "--LadderServer #{client.host}",
+                # "--RealTime 0"
+                "--LadderServer host.docker.internal",
+                "--GamePort #{enemy_client.port}",
+                "--StartPort #{@port_config.start_port}",
+                "--OpponentId 00000000-0000-0000-0000-000000000000"]
+                .join(" ")
+
+              # cmd = "docker compose #{@compose_args} exec --workdir /bots/#{@enemy_botname} versus_bot bash -c '#{enemy_command}'"
+              cmd = "docker compose #{@compose_args} exec --workdir /bots/#{@enemy_botname} versus_bot bash -c '#{enemy_command}'"
+
+              puts cmd
+              process_options = {}
+              if Gem.win_platform?
+                process_options[:new_pgroup] = true
+              else
+                process_options[:pgroup] = true
+              end
+              # ::Async::Process.spawn(cmd, **process_options)
+              unless Kernel.system(cmd)
+                say_status("opponent", "exited with bad status", :red)
+                raise SystemExit
+              end
+            end
+          rescue => e
+            say_status("error", e.message, :red)
+            raise SystemExit
+            # Replay save failed
+          end
+        end.wait
+      ensure
+        ClientManager.stop_all
+      end
+
+      def stop_container
+        cmd = "docker stop versus_bot_container"
+        Kernel.system(cmd)
+      end
+
+      def bye
+        say "Game over."
+      end
+    end
+
+    # standard:enable Style/GlobalVars
+  end
+end

data/lib/sc2ai/connection/requests.rb

@@ -110,8 +110,9 @@ module Sc2
       #       game_info = observer.api.game_info
       #     end
       #   ensure
+      #     observer.disconnect
       #     Sc2::ClientManager.stop(0)
-      #   end
+      #   end.wait
       # @param replay_path [String] path to replay
       # @param replay_data [String] alternative to file, binary string of replay_file.read
       # @param map_data [String] optional binary string of SC2 map if not present in paths
@@ -195,6 +196,7 @@ module Sc2
 
       # Snapshot of the current game state. Primary source for raw information
       # @param game_loop [Integer] you wish to wait for (realtime only)
+      # @return [Api::ResponseObservation]
       def observation(game_loop: nil)
         # Sc2.logger.debug { "#{self.class}.#{__method__} game_loop: #{game_loop}" }
         if game_loop.nil?
@@ -275,6 +277,7 @@ module Sc2
       # Advances the game simulation by step_count. Not used in realtime mode.
       # Only constant step size supported - subsequent requests use cache.
       def step(step_count = 1)
+        step_count = step_count.to_i
         @_cached_request_step ||= {}
         @_cached_request_step[step_count] ||= Api::Request.new(
           step: Api::RequestStep.new(count: step_count)

data/lib/sc2ai/local_play/client_manager.rb

@@ -10,7 +10,7 @@ module Sc2
 
     class << self
       extend Forwardable
-      def_delegators :instance, :obtain, :get, :start, :stop, :stop_all
+      def_delegators :instance, :obtain, :get, :start, :stop, :stop_all, :host
     end
 
     # Gets client for player X or starts an instance
@@ -63,6 +63,8 @@ module Sc2
       end
     end
 
+    attr_accessor :host
+
     private
 
     attr_accessor :clients, :ports

data/lib/sc2ai/local_play/match.rb

@@ -68,7 +68,7 @@ module Sc2
           ensure
             Sc2.logger.debug { "Game over, disconnect players." }
             # Suppress interrupt errors #$stderr.reopen File.new(File::NULL, "w")
-            player.quit if Gem.win_platform?
+            player.quit if [Paths::PF_WINDOWS, Paths::PF_WSL1, Paths::PF_WSL2].include?(Paths.platform)
             player.disconnect
             ClientManager.stop(player_index) # unless keep_clients_alive
           end
@@ -95,7 +95,7 @@ module Sc2
       response = player.api.save_replay
       path = Pathname(Paths.bot_data_replay_dir).join("autosave-#{safe_player_name}.SC2Replay")
       f = File.new(path, "wb:ASCII-8BIT")
-      f.write(response.data)
+      f.write_nonblock(response.data)
       f.close
     end