robot_wars 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14f324f88d83aab8853d7c7ac338883cac3a3e6d605854f6dfeac76abc67175c
-  data.tar.gz: 9724df9749cb271fa4d9950c642c2d6d30eef84b135f7a80dfd6350bc5d7d585
+  metadata.gz: cabecd1a75d787d30df7e8669332d89143ec82f98b3312122a8d618db2bb75b8
+  data.tar.gz: 05efc6cb5f01898fb9461f79364c4f5750f61826726e0e6696f174be30e96748
 SHA512:
-  metadata.gz: 0ae69ce16a9150d4ddf0b9425a364eb7e7ef8be97bbd29b721fa9649f9d78eb701e0f63b956e5bc154acf685691bfd6a9111a24142cb8898d13c78c8a2c60cd7
-  data.tar.gz: 279d6b5c3f98c351be802b9b5caba6fa4755e2952df821466744c25d63d57230397f5a4d2394c0a00188a4b883dc681c843fab1b7cef4596a6cb2e46141bd590
+  metadata.gz: a58ef65c02bb25d4d74155b68ec7dc7f397f0df3397248db58fc4b6bcc332062a67ee33b46603d74b595ee22d39475388a7e444776398e82638c05a498c9066e
+  data.tar.gz: 99adccb7a7b334ddf2fc2aeaf03971c4ce24a641a0c294818b9f7eb94911c206531790a7e9bc84e50e6531b219ecfaf3e097079278fa52579a543a30fc1cf752

data/README.md

@@ -1,5 +1,8 @@
 # RobotWars
 
+> **Note:** This gem is still in development. It is waiting on the
+> release of some of its dependencies before it can be published.
+
 RobotWars is a component of the [RobotLab](https://github.com/MadBomber/robot_lab)
 multi-robot LLM orchestration project: a turn-based game in which RobotLab
 robots compete on a 2D grid board until only one remains.

data/bin/rwars

@@ -0,0 +1,200 @@
+#!/usr/bin/env ruby
+# rwars — run a RobotWars match with LLM-backed warriors.
+#
+#   rwars --warriors ./warriors --width 10 --height 10
+#
+# Each warrior is one *.md prompt template (RobotLab's format: YAML
+# front matter + a personality body) in the given directory. The
+# filename (minus ".md") becomes that warrior's id. Files starting
+# with "_" are reserved for shared partials, not warriors.
+#
+# The rules of the game are NOT the templates' job: every robot gets
+# the gem's own canonical recap (RobotWars::GameRules, shipped as
+# lib/robot_wars/game_rules.md) as its RobotLab system_prompt.
+
+repo_root = File.expand_path("..", __dir__)
+ENV["BUNDLE_GEMFILE"] = File.expand_path(ENV["BUNDLE_GEMFILE"] || "Gemfile.local", repo_root)
+require "bundler/setup"
+
+require "optparse"
+require "robot_wars"
+
+# Each warrior's own *.md front matter picks its brain: the `model:`
+# field is "<provider>/<model id>" (e.g. apfel/apple-foundationmodel),
+# parsed by RobotWars::ModelSpec. --model, in the same format, forces
+# every warrior onto the same one. Nothing here names a provider or
+# model of its own — a template that names neither falls through to
+# RobotLab's config cascade.
+options = { width: 10, height: 10, max_turns: 500, seed: nil, model: nil,
+            life: RobotWars::Robot::STARTING_LIFE }
+
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: rwars --warriors DIR [options]"
+
+  opts.on("-w", "--warriors DIR", "Directory of *.md warrior brain templates (required)") do |dir|
+    options[:warriors] = dir
+  end
+  opts.on("--width N", Integer, "Board width (default: #{options[:width]})") { |n| options[:width] = n }
+  opts.on("--height N", Integer, "Board height (default: #{options[:height]})") { |n| options[:height] = n }
+  opts.on("--size WxH", "Board size shorthand, e.g. 12x12 (overrides --width/--height)") do |size|
+    options[:width], options[:height] = size.split(/x/i, 2).map(&:to_i)
+  end
+  opts.on("--max-turns N", Integer, "Stop after N turns if nobody has won yet (default: #{options[:max_turns]})") do |n|
+    options[:max_turns] = n
+  end
+  opts.on("--seed N", Integer, "Seed the random number generator for a reproducible match") { |n| options[:seed] = n }
+  opts.on("--life N", Integer, "Starting life for every robot (default: #{options[:life]})") { |n| options[:life] = n }
+  opts.on("--model PROVIDER/MODEL", "Force every warrior onto this model, overriding its own front matter") do |m|
+    options[:model] = m
+  end
+  opts.on("--version", "Show the robot_wars gem version") do
+    puts "rwars #{RobotWars::VERSION}"
+    exit
+  end
+  opts.on("-h", "--help", "Show this help") do
+    puts opts
+    exit
+  end
+end
+
+parser.parse!(ARGV)
+
+unless options[:warriors]
+  warn parser
+  abort "\nerror: --warriors DIR is required"
+end
+
+abort "error: --life must be positive; got #{options[:life]}" unless options[:life].positive?
+
+warriors_dir = File.expand_path(options[:warriors])
+abort "error: #{warriors_dir} is not a directory" unless File.directory?(warriors_dir)
+
+brain_files = Dir.glob(File.join(warriors_dir, "*.md")).reject { |path| File.basename(path).start_with?("_") }
+abort "error: no *.md files found in #{warriors_dir}" if brain_files.empty?
+abort "error: need at least 2 warriors to fight; found #{brain_files.size}" if brain_files.size < 2
+
+# Setting PM.configure directly here would be overwritten the moment
+# RobotLab.config is first touched (lazily, inside RobotLab::Robot#new) —
+# it reapplies its own default prompts_dir. Going through RobotLab's own
+# config makes our setting durable against that lazy reload. Quieting
+# ruby_llm's default :debug logging the same way, since a game shouldn't
+# dump every raw API request/response to stdout by default.
+RobotLab.config.template_path = warriors_dir
+RobotLab.config.ruby_llm.log_level = :warn
+RobotLab.config.after_load
+
+random       = options[:seed] ? Random.new(options[:seed]) : Random.new
+board        = RobotWars::Board.new(width: options[:width], height: options[:height])
+warrior_ids  = brain_files.map { |path| File.basename(path, ".md") }
+game         = RobotWars::Game.start(board: board, robot_ids: warrior_ids, life: options[:life], random: random)
+
+# Resolve each warrior's "<provider>/<model id>" up front: --model wins
+# over front matter, front matter over nothing. RobotLab would otherwise
+# hand the front matter's combined string to RubyLLM verbatim as a model
+# id, so the split into provider + bare model must happen here.
+override = RobotWars::ModelSpec.parse(options[:model])
+specs = game.robots.to_h do |robot|
+  [robot, override || RobotWars::ModelSpec.from_template(File.join(warriors_dir, "#{robot.id}.md"))]
+end
+
+# Providers that live outside ruby_llm itself (apfel, lms, ...) ship as
+# ruby_llm-providers-<name> gems and register themselves when required;
+# built-in providers are already in the registry and need nothing.
+specs.values.compact.map(&:provider).compact.uniq.each do |provider|
+  next if RubyLLM::Provider.providers.key?(provider)
+
+  begin
+    require "ruby_llm/providers/#{provider}"
+  rescue LoadError
+    abort "error: unknown provider #{provider.inspect} — not built into ruby_llm " \
+          "and no ruby_llm/providers/#{provider} library could be loaded"
+  end
+end
+
+warriors = game.robots.to_h do |robot|
+  # Constructor kwargs beat front matter, which is what makes the parsed
+  # bare model id (and --model's universal override) win over the raw
+  # "<provider>/<model>" string still sitting in the template.
+  build_options = { name: robot.id, template: robot.id.to_sym,
+                    system_prompt: RobotWars::GameRules.text }
+  if (spec = specs.fetch(robot))
+    build_options[:model]    = spec.model
+    build_options[:provider] = spec.provider if spec.provider
+  end
+
+  llm_robot = RobotLab.build(**build_options)
+  [robot, RobotWars::Warrior.new(robot: robot, pilot: RobotWars::LLMPilot.new(llm_robot: llm_robot))]
+end
+
+puts <<~HEADER
+  RobotWars — #{warrior_ids.size} warriors on a #{board.width}x#{board.height} board
+  warriors: #{warrior_ids.join(', ')}
+HEADER
+
+last_report = nil
+until game.over? || game.turn_number >= options[:max_turns]
+  # Every pilot's prompt goes out concurrently — the calls are
+  # I/O-bound waits, so a turn costs the slowest brain rather than the
+  # sum of all of them. Sensing reports are built up front on the main
+  # thread (they read shared game state); each thread then only talks
+  # to its own warrior's chat. Battleship-style: an attacker is told on
+  # its NEXT turn whether last turn's shot found a robot (HIT) or an
+  # empty square (MISS).
+  threads = game.alive_robots.to_h do |robot|
+    sensing = RobotWars::SensingReport.new(
+      game: game, robot: robot,
+      attack_outcome: last_report&.attack_outcome_for(robot)
+    ).to_s
+
+    thread = Thread.new do
+      # A brain failure is reported once, by the abort below — not as a
+      # raw stack trace the moment the thread dies.
+      Thread.current.report_on_exception = false
+      warriors.fetch(robot).decide(sensing)
+    end
+    [robot, thread]
+  end
+
+  # Thread#value re-raises a failed brain's exception here, preserving
+  # the serial loop's abort behavior.
+  actions = threads.to_h do |robot, thread|
+    [robot, thread.value]
+  rescue StandardError => e
+    abort "error: #{robot.id}'s brain failed to respond (#{e.class}: #{e.message})"
+  end
+
+  # Origins must be read before resolution — afterward a robot may have
+  # moved, been displaced, or died off the board.
+  origins = actions.keys.to_h { |robot| [robot, game.occupancy.position_of(robot)] }
+
+  report = game.play_turn(actions)
+  puts "turn #{game.turn_number}: #{game.alive_robots.map { |r| "#{r.id}=#{r.life}" }.join(', ')}"
+  # Recap what each warrior declared this turn — every robot that was
+  # alive when actions were collected, including any the turn just
+  # eliminated — then the conflicts those declarations caused, in the
+  # order they resolve: rule 21 solo conflicts during the movement
+  # phase, then the square conflicts.
+  actions.each do |robot, action|
+    line = "  #{robot.id}: #{action.describe(origins.fetch(robot))}"
+    owned = report.claimed_squares_for(robot).map { |square| "(#{square.x},#{square.y})" }
+    line << " — now owns #{owned.join(', ')}" unless owned.empty?
+    puts line
+  end
+  (report.solo_conflicts + report.conflicts).each { |conflict| puts "  #{conflict}" }
+  # Ranged shots resolve last; show each attacker's Battleship-style
+  # outcome (the same feedback its next sensing report will carry).
+  actions.each_key do |robot|
+    outcome = report.attack_outcome_for(robot)
+    puts "  #{robot.id}'s attack was a #{outcome.to_s.upcase}" if outcome
+  end
+  last_report = report
+end
+
+puts "---"
+if game.tie?
+  puts "Tie — the last warriors fell in the same turn."
+elsif game.over?
+  puts "Winner: #{game.winner.id} (#{game.winner.life} life) after #{game.turn_number} turns."
+else
+  puts "Stopped after #{game.turn_number} turns (max-turns reached) — #{game.alive_robots.size} warriors still standing."
+end

data/lib/robot_wars/version.rb

@@ -1,3 +1,3 @@
 module RobotWars
-  VERSION = "0.1.0".freeze
+  VERSION = "0.1.1".freeze
 end

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: robot_wars
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Dewayne VanHoozer
-bindir: exe
+bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
@@ -28,7 +28,8 @@ description: 'A turn-based game built on the RobotLab framework: each robot occu
   between turns, and the last robot remaining wins.'
 email:
 - dvanhoozer@gmail.com
-executables: []
+executables:
+- rwars
 extensions: []
 extra_rdoc_files: []
 files:
@@ -40,6 +41,7 @@ files:
 - README.md
 - RULES.md
 - Rakefile
+- bin/rwars
 - docs/game_board.svg
 - examples/01_random_match.rb
 - examples/warriors/opportunist.md