Add a higher level layer on top of the generated ruby bindings.

4 files changed, 135 insertions, 90 deletions

diff --git a/bindings/ruby/quackle_runner.rb b/bindings/ruby/quackle_runner.rb
new file mode 100644
index 0000000..d466cfc
--- /dev/null
+++ b/bindings/ruby/quackle_runner.rb
@@ -0,0 +1,110 @@
+require_relative 'quackle'
+
+# Some higher-level functions over the quackle bindings.
+
+module Quackle
+  PLAYER_TYPES = {
+    speedy: "Speedy Player",
+    championship: "Championship Player",
+    championship_20s: "Twenty Second Championship Player",
+    championship_5m: "Five Minute Championship Player",
+  }
+
+  module GCGUtils
+    def self.load_game(path)
+      gamereader = GCGIO.new
+      gamePath = Util.stdStringToQString(path)
+      gamereader.read(gamePath, Logania::MaintainBoardPreparation)
+    end
+  end
+
+  module RunnerUtils
+    def initialize_dm(lexicon, alphabet, datadir)
+      # Set up the data manager
+      dm = DataManager.new
+      dm.setComputerPlayers(ComputerPlayerCollection.fullCollection)
+      dm.setBackupLexicon(lexicon)
+      dm.setAppDataDirectory(datadir)
+
+      # Set up the alphabet
+      abc = AlphabetParameters.findAlphabetFile(alphabet)
+      abc2 = Util.stdStringToQString(abc) #convert to qstring
+      fa = FlexibleAlphabetParameters.new
+
+      fail unless fa.load(abc2)
+      dm.setAlphabetParameters(fa)
+
+      # Set up the board
+      board = BoardParameters.new
+      dm.setBoardParameters(board)
+
+      # Find the lexicon
+      dawg = LexiconParameters.findDictionaryFile(lexicon + '.dawg')
+      gaddag = LexiconParameters.findDictionaryFile(lexicon + '.gaddag')
+      dm.lexiconParameters.loadDawg(dawg)
+      dm.lexiconParameters.loadGaddag(gaddag)
+
+      dm.strategyParameters.init(lexicon)
+      return dm
+    end
+
+    def computer_player(type)
+      name = PLAYER_TYPES[type]
+      if name
+        player, found = @dm.computerPlayers.playerForName(name)
+        if not found
+          raise NameError("Could not initialize computer player #{name}")
+        end
+        player.computerPlayer
+      else
+        raise ArgumentError("Unknown computer player: #{type}")
+      end
+    end
+  end
+
+  class AIRunner
+    include RunnerUtils
+
+    attr_accessor :dm, :game, :players
+
+    def initialize(lexicon:, alphabet:, datadir:, random_seed: nil)
+      @dm = initialize_dm(lexicon, alphabet, datadir)
+      @dm.seedRandomNumbers(random_seed) if random_seed
+    end
+
+    def init_game(players)
+      @game = Game.new
+      @players = PlayerList.new
+      players.each_with_index do |(name, type), i|
+        player = Player::new(name, Player::ComputerPlayerType, i)
+        player.setComputerPlayer(computer_player(type))
+        @players << player
+      end
+
+      game.setPlayers(@players)
+      game.associateKnownComputerPlayers
+      game.addPosition
+    end
+
+    def current_position
+      game.currentPosition
+    end
+
+    def current_player
+      current_position.currentPlayer
+    end
+
+    def board
+      current_position.board
+    end
+
+    def make_move
+      game.haveComputerPlay
+    end
+
+    def game_over?
+      current_position.gameOver
+    end
+  end
+
+end
diff --git a/bindings/ruby/test1_position.rb b/bindings/ruby/test1_position.rb
index b76ca56..64ed948 100644
--- a/bindings/ruby/test1_position.rb
+++ b/bindings/ruby/test1_position.rb
@@ -1,16 +1,16 @@
 require_relative 'quackle'
-require_relative 'test_base'
+require_relative 'quackle_runner'
 
-dm = initialize_dm
+runner = Quackle::AIRunner.new(
+  lexicon: 'twl06', alphabet: 'english', datadir: '../../data', random_seed: 42)
 
 # Create a computer player
-player1 = get_computer_player(dm)
+player1 = runner.computer_player(:speedy)
 puts player1.name
 
-# Create the Game file (.gcg) reader
-gamereader = Quackle::GCGIO.new
-gamePath = Quackle::Util.stdStringToQString('../../test/positions/short_game_with_bad_moves.gcg')
-game = gamereader.read(gamePath, Quackle::Logania::MaintainBoardPreparation)
+# Load the game from a .gcg file
+path = '../../test/positions/short_game_with_bad_moves.gcg'
+game = Quackle::GCGUtils.load_game(path)
 
 # Get the current position
 position = game.currentPosition
@@ -18,19 +18,17 @@ position = game.currentPosition
 player1.setPosition(position)
 
 racks = Quackle::ProbableRackList.new
-unseenbag = position.unseenBag
-if unseenbag.size <= dm.parameters.rackSize + 3
-  enum = Quackle::Enumerator.new(unseenbag)
+unseen_bag = position.unseenBag
+if unseen_bag.size <= runner.dm.parameters.rackSize + 3
+  enum = Quackle::Enumerator.new(unseen_bag)
   enum.enumerate(racks)
   racks.each do |rack|
     puts rack
   end
 end
 
-movesToShow = 10
-
-puts "Board state: \n%s" % position.board.toString
-puts "Move made: %s" % position.moveMade.toString
+puts "Board state: \n%s" % position.board
+puts "Move made: %s" % position.moveMade
 puts "Current player: %s" % position.currentPlayer.storeInformationToString
 puts "Turn number: %i" % position.turnNumber
 
@@ -38,5 +36,5 @@ movelist = player1.moves(10)
 
 # Show 10 moves suggested by computer player
 movelist.each do |move|
-  puts move.toString
+  puts move
 end
diff --git a/bindings/ruby/test2_selfplay.rb b/bindings/ruby/test2_selfplay.rb
index 3cc101b..33d08ce 100644
--- a/bindings/ruby/test2_selfplay.rb
+++ b/bindings/ruby/test2_selfplay.rb
@@ -1,47 +1,19 @@
-require_relative 'quackle'
-require_relative 'test_base'
+require_relative 'quackle_runner'
 
+runner = Quackle::AIRunner.new(
+  lexicon: 'twl06', alphabet: 'english', datadir: '../../data', random_seed: 42)
 
-dm = initialize_dm
+runner.init_game([["Compy1", :speedy],
+                  ["Compy2", :speedy]])
 
-p1 = get_computer_player(dm)
-p2 = get_computer_player(dm)
+while not runner.game_over?
+  player = runner.current_player
+  puts "Player: #{player.name}"
+  puts "Rack : #{player.rack}"
 
-# Create computer players
-player1 = Quackle::Player.new('Compy1', Quackle::Player::ComputerPlayerType, 0)
-player1.setComputerPlayer(p1)
-puts player1.name
-
-player2 = Quackle::Player.new('Compy2', Quackle::Player::ComputerPlayerType, 1)
-player2.setComputerPlayer(p2)
-puts player2.name
-
-dm.seedRandomNumbers(42)
-
-game = Quackle::Game.new
-players = Quackle::PlayerList.new
-
-players << player1
-players << player2
-
-game.setPlayers(players)
-game.associateKnownComputerPlayers
-game.addPosition
-
-
-50.times do
-  if game.currentPosition.gameOver
-    puts 'GAME OVER'
-    break
-  end
-
-  player = game.currentPosition.currentPlayer
-  puts 'Player: ' + player.name
-  puts 'Rack : ' + player.rack.toString
-
-  move = game.haveComputerPlay
-  puts 'Move: ' + move.toString
-  puts "Board: \n" + game.currentPosition.board.toString
+  move = runner.make_move
+  puts "Move: #{move}"
+  puts "Board: \n #{runner.board}"
 
   sleep(1)
 end
diff --git a/bindings/ruby/test_base.rb b/bindings/ruby/test_base.rb
deleted file mode 100644
index 6fa7f05..0000000
--- a/bindings/ruby/test_base.rb
+++ /dev/null
@@ -1,35 +0,0 @@
-def initialize_dm(lexicon: 'twl06', alphabet: 'english', datadir: '../../data')
-  # Set up the data manager
-  dm = Quackle::DataManager.new
-  dm.setComputerPlayers(Quackle::ComputerPlayerCollection.fullCollection)
-  dm.setBackupLexicon(lexicon)
-  dm.setAppDataDirectory(datadir)
-
-  # Set up the alphabet
-  abc = Quackle::AlphabetParameters.findAlphabetFile(alphabet)
-  abc2 = Quackle::Util.stdStringToQString(abc) #convert to qstring
-  fa = Quackle::FlexibleAlphabetParameters.new
-
-  fail unless fa.load(abc2)
-  dm.setAlphabetParameters(fa)
-
-  # Set up the board
-  board = Quackle::BoardParameters.new
-  dm.setBoardParameters(board)
-
-  # Find the lexicon
-  dawg = Quackle::LexiconParameters.findDictionaryFile(lexicon + '.dawg')
-  gaddag = Quackle::LexiconParameters.findDictionaryFile(lexicon + '.gaddag')
-  dm.lexiconParameters.loadDawg(dawg)
-  dm.lexiconParameters.loadGaddag(gaddag)
-
-  dm.strategyParameters.init(lexicon)
-  return dm
-end
-
-def get_computer_player(dm, name: 'Speedy Player')
-  player, found = dm.computerPlayers.playerForName(name)
-  fail unless found
-  player.computerPlayer
-end
-