openra 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b648bef069d1c0a709f510f889703f24d4a6d043
-  data.tar.gz: efedb97d0a81eb63694cedc2f50672e82be71257
+  metadata.gz: f8e899e24d7c1a64648be5f39fb249439f7ff008
+  data.tar.gz: 6efadd30042d44cfd54bcaecf9594b09d5aed992
 SHA512:
-  metadata.gz: 41a705ad37119d25f18d3c5387ffb25b0e36b80d8818e55d8e0c251fe051600de56ed14c21659d93599df2b61fe4483c97fe120f1a74c12701acbd0ca6713178
-  data.tar.gz: bfe0e10cfdb0292540a3c6adf90d0873012fe5a843050845bf26348d9e2b8f60afbe2aa1a1d69f8b8be4b716cb58fac4088a944644bebf34a7ce2cefda20fca7
+  metadata.gz: b15a3518af884311eac8fda0ea5323f30af197c1e2b4e00fdf86ae2103094d666ec2ba133a8c96ad7ad6e0f3af1fd27b3008aa5f539dbce03d9c13d9da63cf79
+  data.tar.gz: 1631bcefa11178ba60eb37d4a71019e4e4383b3e33290c29f2ccde99aae410e2e51b98bf9acce0282172f15105bf1405d711d14ebea9a2f487f7b03ed0b8f7d9

data/CHANGELOG.md

@@ -1,10 +1,22 @@
 ## Unreleased
 
+### Added
+
+* [detect-production-macros] A new command to detect production macros ([AMHOL](https://github.com/AMHOL))
+
+### Fixed
+
+* [core] Fix error when sync info does not exactly precede the start game order ([AMHOL](https://github.com/AMHOL))
+
+[Compare v1.4.0...HEAD](https://github.com/AMHOL/openra-ruby/compare/v1.4.0...HEAD)
+
+## v1.4.0
+
 ### Fixed
 
 * [replay-data] Output timestamps in ISO8601 (thanks to [dragunoff](https://github.com/dragunoff)) ([AMHOL](https://github.com/AMHOL))
 
-[Compare v1.3.0...HEAD](https://github.com/AMHOL/openra-ruby/compare/v1.3.0...HEAD)
+[Compare v1.3.0...v1.4.0](https://github.com/AMHOL/openra-ruby/compare/v1.3.0...v1.4.0)
 
 ## v1.3.0
 

data/README.md

@@ -2,7 +2,12 @@
 
 Unofficial gem for [OpenRA](https://openra.net); a free, open-source real-time strategy game engine for early Westwood games such as Command & Conquer: Red Alert written in C#
 
-Currently the only operation implemented by this gem is to parse and extract data from replay files, if this is not what you're looking for, please see the [Other tools](#other-tools) section, perhaps what you need has already been implemented elsewhere.
+Currently this gem implements the following commands:
+
+* replay-data - parse and extract data from replay files
+* detect-production-macros - parse replay data and attempt to detect production macro usage by players
+
+If this is not what you're looking for, please see the [Other tools](#other-tools) section, perhaps what you need has already been implemented elsewhere.
 
 ### Installation
 ```sh
@@ -19,7 +24,8 @@ gem update openra
 ### Example usage
 
 ```sh
-openra replay-data /payh/to/replay.orarep [--format json|pretty-json|yaml]
+openra replay-data /path/to/replay.orarep [--format json|pretty-json|yaml]
+openra detect-production-macros /path/to/replay.orarep [--format json|pretty-json|yaml]
 ```
 
 ### Other tools

data/lib/openra/cli.rb

@@ -4,7 +4,8 @@ require 'json'
 require 'hanami/cli'
 require 'openra/version'
 require 'openra/replays'
-require 'openra/cli/commands/replay_data/formatters'
+require 'openra/cli/commands/formatters'
+require 'openra/cli/commands/detect_production_macros'
 require 'openra/cli/commands/replay_data'
 require 'openra/cli/commands/version'
 require 'openra/cli/command_registry'

data/lib/openra/cli/command_registry.rb

@@ -4,6 +4,7 @@ module Openra
       extend Hanami::CLI::Registry
 
       register 'replay-data', Commands::ReplayData
+      register 'detect-production-macros', Commands::DetectProductionMacros
       register 'version', Commands::Version
     end
   end

data/lib/openra/cli/commands/detect_production_macros.rb

@@ -0,0 +1,130 @@
+module Openra
+  class CLI
+    module Commands
+      class DetectProductionMacros < Hanami::CLI::Command
+        ARRAY_HASH = ->(hash, key) { hash[key] = [] }
+
+        desc 'Detect whether players are using production macros'
+
+        argument :replay, required: true, desc: 'Path of the replay file to read data from'
+        option :format, default: 'json', values: %w(json pretty-json yaml), desc: 'Output format'
+
+        def call(replay:, **options)
+          replay = Openra::Replays::Replay.new(replay)
+          commands = Hash.new(&ARRAY_HASH)
+
+          replay.orders.each do |order|
+            case order.command
+            when 'StartProduction'
+              commands[order.client_index.to_s] << {
+                target: order.target_string.to_s,
+                msec: order.frame * replay.frametime_multiplier
+              }
+            end
+          end
+
+          data = {
+            players: replay.players.select(&:is_human).map { |player|
+              player_commands = commands_with_delay(commands[player.index])
+              production_stats = production_stats(player_commands)
+              sequences = detect_sequences(player_commands)
+
+              {
+                index: player.index,
+                name: player.name,
+                team: player.team,
+                outcome: player.outcome,
+                production_stats: production_stats,
+                sequences: sequences,
+                suspected_macros: suspected_macros(production_stats, sequences)
+              }
+            }
+          }
+
+          puts FORMATTERS.fetch(options[:format]).call(data)
+        end
+
+        private
+
+        def commands_with_delay(commands)
+          commands.inject do |last_command, command|
+            command[:delay] = command[:msec] - last_command[:msec]
+            command
+          end
+
+          # Drop the first command, as we don't have a delay for that
+          commands.drop(1)
+        end
+
+        def detect_sequences(player_commands)
+          sequences = []
+          groups = player_commands.each_with_object(Hash.new(&ARRAY_HASH)).with_index do |(command, hash), index|
+            hash[command[:delay]] << command.merge(index: index)
+          end
+
+          groups.each_pair do |delay, commands|
+            sequence = []
+
+            commands.inject do |last_command, command|
+              if last_command[:index].next == command[:index]
+                sequence << command
+              elsif sequence.length > 1
+                sequences << {
+                  delay: delay,
+                  sequence: sequence.map { |c| c[:target] }
+                }
+                sequence = []
+              end
+
+              command
+            end
+          end
+
+          sequences = sequences.uniq.map do |sequence|
+            sequence.merge(
+              occurences: sequences.count { |current| current == sequence }
+            )
+          end
+
+          sequences.select { |sequence| sequence[:occurences] > 1 }.sort do |a, b|
+            b[:occurences] <=> a[:occurences]
+          end
+        end
+
+        def production_stats(player_commands)
+          order_delays = player_commands.map { |command| command[:delay] }
+
+          {
+            order_delay: {
+              min: order_delays.min,
+              max: order_delays.max,
+              mean: mean(order_delays),
+              median: median(order_delays)
+            }
+          }
+        end
+
+        def suspected_macros(production_stats, sequences)
+          suspicious_sequences = sequences.count do |sequence|
+            sequence[:delay] < 100 &&
+              sequence[:sequence].length > 3 &&
+              sequence[:sequence].uniq.length > 2
+          end
+
+          production_stats[:order_delay][:min] < 50 || suspicious_sequences > 0
+        end
+
+        def mean(ints)
+          ints.sum / ints.length
+        end
+
+        def median(ints)
+          ints = ints.sort
+          middle_index = (ints.length - 1) / 2.0
+
+          (ints[middle_index.floor] + ints[middle_index.ceil]) / 2
+        end
+      end
+    end
+  end
+end

data/lib/openra/cli/commands/formatters.rb

@@ -0,0 +1,33 @@
+module Openra
+  class CLI
+    module Commands
+      module Formatters
+        class JSON
+          def call(data)
+            ::JSON.dump(data)
+          end
+        end
+
+        class PrettyJSON
+          def call(data)
+            ::JSON.pretty_generate(data)
+          end
+        end
+
+        class YAML
+          def call(data)
+            ::YAML.dump(
+              Openra::Struct::Functions[:deep_stringify_keys].(data)
+            )
+          end
+        end
+      end
+
+      FORMATTERS = {
+        'json' => Formatters::JSON.new,
+        'pretty-json' => Formatters::PrettyJSON.new,
+        'yaml' => Formatters::YAML.new,
+      }.freeze
+    end
+  end
+end

data/lib/openra/cli/commands/replay_data.rb

@@ -2,12 +2,6 @@ module Openra
   class CLI
     module Commands
       class ReplayData < Hanami::CLI::Command
-        FORMATTERS = {
-          'json' => Formatters::JSON.new,
-          'pretty-json' => Formatters::PrettyJSON.new,
-          'yaml' => Formatters::YAML.new,
-        }.freeze
-
         desc 'Output replay data to stdout'
 
         argument :replay, required: true, desc: 'Path of the replay file to read data from'
@@ -16,7 +10,7 @@ module Openra
         def call(replay:, **options)
           replay = Openra::Replays::Replay.new(replay)
 
-          replay_data = {
+          data = {
             mod: replay.metadata.mod,
             version: replay.metadata.version,
             server_name: utf8(replay.global_settings.server_name),
@@ -92,7 +86,7 @@ module Openra
                 Openra::YAML.load(order.target)
               ).clients
             when 'PlaceBuilding'
-              client_hash = replay_data[:clients].find do |candidate|
+              client_hash = data[:clients].find do |candidate|
                 candidate[:index] == order.client_index.to_s
               end
 
@@ -105,19 +99,19 @@ module Openra
                 }
               }
             when 'Message'
-              replay_data[:chat] << {
+              data[:chat] << {
                 channel: 'server',
                 name: nil,
                 message: utf8(order.target)
               }
             when 'Chat'
-              replay_data[:chat] << {
+              data[:chat] << {
                 channel: 'global',
                 name: utf8(client.name),
                 message: utf8(order.target)
               }
             when 'TeamChat'
-              replay_data[:chat] << {
+              data[:chat] << {
                 channel: client.team,
                 name: utf8(client.name),
                 message: utf8(order.target)
@@ -125,7 +119,7 @@ module Openra
             end
           end
 
-          puts FORMATTERS.fetch(options[:format]).call(replay_data)
+          puts FORMATTERS.fetch(options[:format]).call(data)
         end
 
         private

data/lib/openra/replays/replay.rb

@@ -56,7 +56,10 @@ module Openra
 
         start_game_order = orders.find { |order| order[:command] == 'StartGame' }
         start_game_index = orders.index(start_game_order)
-        start_game_sync_order = orders[start_game_index.pred]
+        pre_game_orders = orders[0..start_game_index]
+        start_game_sync_order = pre_game_orders.reverse.find do |order|
+          order[:command] == 'SyncInfo'
+        end
 
         @sync_info = Openra::Struct::SyncInfo.new(
           Openra::YAML.load(start_game_sync_order.target)

data/lib/openra/version.rb

@@ -1,3 +1,3 @@
 module Openra
-  VERSION = '1.4.0'.freeze
+  VERSION = '1.5.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openra
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Andy Holland
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-17 00:00:00.000000000 Z
+date: 2018-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -133,8 +133,9 @@ files:
 - lib/openra.rb
 - lib/openra/cli.rb
 - lib/openra/cli/command_registry.rb
+- lib/openra/cli/commands/detect_production_macros.rb
+- lib/openra/cli/commands/formatters.rb
 - lib/openra/cli/commands/replay_data.rb
-- lib/openra/cli/commands/replay_data/formatters.rb
 - lib/openra/cli/commands/version.rb
 - lib/openra/replays.rb
 - lib/openra/replays/file.rb

data/lib/openra/cli/commands/replay_data/formatters.rb

@@ -1,29 +0,0 @@
-module Openra
-  class CLI
-    module Commands
-      class ReplayData < Hanami::CLI::Command
-        module Formatters
-          class JSON
-            def call(data)
-              ::JSON.dump(data)
-            end
-          end
-
-          class PrettyJSON
-            def call(data)
-              ::JSON.pretty_generate(data)
-            end
-          end
-
-          class YAML
-            def call(data)
-              ::YAML.dump(
-                Openra::Struct::Functions[:deep_stringify_keys].(data)
-              )
-            end
-          end
-        end
-      end
-    end
-  end
-end