linotype 0.0.3 → 0.0.4

data/lib/linotype/game.rb

@@ -2,11 +2,12 @@ module Linotype
   class Game
         
     attr_accessor :moves
-    attr_reader :current_player
+    attr_reader :current_player, :players
 
     def initialize(args={})
+      args = { player_one: Player.new, player_two: Player.new }.merge(args)
       @board = Board.new(self, tiles: create_tile_letter_array(args[:tiles]))
-      @players = [Player.new, Player.new]
+      @players = [args[:player_one], args[:player_two]]
       @current_player = @players[0]
       @moves = []
     end
@@ -27,7 +28,7 @@ module Linotype
         letter_array
       end
     end
-        
+            
     def play(*tile_coordinates)
       tiles = find_tiles(tile_coordinates)
       Move.new(self, @current_player, tiles).valid?
@@ -64,28 +65,22 @@ module Linotype
         every_play_for_word(word_to_test).each do |tiles|
           move = Move.new(self, @current_player, tiles)
           potential_moves << move
-          undo_last_move!
+          move.undo!
         end
       end
-      potential_moves.collect(&:to_hash)
+      potential_moves
     end
     
     def valid_potential_plays
-      test_potential_plays.select { |potential_play| potential_play[:valid] }
+      test_potential_plays.select { |potential_play| potential_play.valid? }
     end
     
     def best_next_play
-      valid_potential_plays.sort { |a, b| b[:score][:defended] <=> a[:score][:defended] }.first
+      valid_potential_plays.sort do |a, b|
+        current_player.strategy.score(b) <=> current_player.strategy.score(a)
+      end.first
     end
     
-    def undo_last_move!
-      if (last_move = moves.pop) && last_move.valid?
-        last_move.uncover_tiles!
-        @current_player = other_player if last_move.valid?
-      end
-      moves.last.cover_tiles! if moves.any?  
-    end
-
     def over?
       uncovered_tiles.empty? || two_passes_in_a_row?
     end
@@ -148,6 +143,10 @@ module Linotype
     def tile_rows
       @board.tiles
     end
+    
+    def all_tiles
+      tile_rows.flatten
+    end
 
     def letters
       @board.tiles.flatten.collect(&:letter)
@@ -172,16 +171,24 @@ module Linotype
     end
     
     def uncovered_tiles
-      covered_tiles(nil)
+      all_tiles.select { |tile| !tile.covered_by }
     end
     private :uncovered_tiles
     
     def defended_tiles(player)
-      tile_rows.flatten.select { |tile| tile.covered_by == player && tile.defended? }
+      tile_rows.flatten.select { |tile| player && tile.covered_by == player && tile.defended? }
     end
     
     def covered_tiles(player)
-      tile_rows.flatten.select { |tile| tile.covered_by == player }
+      tile_rows.flatten.select { |tile| player && tile.covered_by == player }
+    end
+    
+    def edge_tiles(player)
+      tile_rows.flatten.select { |tile| player && tile.edge? && tile.covered_by == player }
+    end
+    
+    def corner_tiles(player)
+      tile_rows.flatten.select { |tile| player && tile.corner? && tile.covered_by == player }
     end
     
     def two_passes_in_a_row?
@@ -189,5 +196,19 @@ module Linotype
     end
     private :two_passes_in_a_row?
     
+    def print_board
+      tile_rows.each do |row|
+        r = ""
+        row.each do |tile|
+          r << "#{tile.letter}#{tile.covered_by ? player_number(tile.covered_by) : ' '} "
+        end
+        puts r
+      end
+    end
+    
+    def print_scores
+      players.each { |player| puts "Player #{player_number(player)}: #{covered_tiles(player).count}" }
+    end
+    
   end
 end

data/lib/linotype/move.rb

@@ -1,35 +1,56 @@
 module Linotype
   class Move
     
-    attr_reader :game, :player, :invalid_reason, :score
+    attr_reader :game, :invalid_reason, :score, :tiles
+    attr_accessor :player, :previous_tile_values
     
     def initialize(game, player, tiles)
       @game = game
-      @player = player
+      self.player = player
       @tiles = tiles
+      set_previous_tile_values
       calculate_valid
       if valid?
         calculate_scores(:before)
+        @game.moves << self
         cover_tiles!
         calculate_scores(:after)
         calculate_net_scores
         @game.toggle_current_player
+      else
+        @game.moves << self
       end
-      @game.moves << self
     end
     
     def score
       @score ||= {}
     end
+    
+    def undo!
+      tiles.each { |tile| tile.covered_by = previous_tile_values[tile][:covered_by] }
+      game.moves.delete(self)
+      game.toggle_current_player if valid?
+    end
+    
+    def set_previous_tile_values
+      self.previous_tile_values = {}
+      tiles.each do |tile|
+        self.previous_tile_values[tile] = { covered_by: tile.covered_by }
+      end
+    end
         
     def calculate_scores(time)
-      score["defended_#{time}".to_sym] = @game.defended_tiles(player).count
-      score["covered_#{time}".to_sym] = @game.covered_tiles(player).count
+      self.score["defended_#{time}".to_sym] = @game.defended_tiles(player).count
+      self.score["covered_#{time}".to_sym] = @game.covered_tiles(player).count
+      self.score["edges_#{time}".to_sym] = @game.edge_tiles(player).count
+      self.score["corners_#{time}".to_sym] = @game.corner_tiles(player).count
     end
     
     def calculate_net_scores
-      score[:defended] = score[:defended_after] - score[:defended_before]
-      score[:covered] = score[:covered_after] - score[:covered_before]
+      self.score[:defended] = score[:defended_after] - score[:defended_before]
+      self.score[:covered] = score[:covered_after] - score[:covered_before]
+      self.score[:edges] = score[:edges_after] - score[:edges_before]
+      self.score[:corners] = score[:corners_after] - score[:corners_before]
     end
            
     def valid?

data/lib/linotype/player.rb

@@ -1,5 +1,14 @@
 module Linotype
   class Player
     
+    DEFAULT_STRATEGY = ->(move) { (move.score[:defended] * 2) + move.score[:covered] }
+
+    attr_accessor :strategy
+
+    def initialize(args={})
+      args = { strategy: DEFAULT_STRATEGY }.merge(args)
+      self.strategy = args[:strategy]
+    end
+    
   end
 end

data/lib/linotype/simulator.rb

@@ -0,0 +1,29 @@
+module Linotype
+  class Simulator
+    
+    attr_accessor :player_one, :player_two, :game
+    
+    def initialize(strategy_one, strategy_two)
+      self.player_one = Player.new(strategy: strategy_one)
+      self.player_two = Player.new(strategy: strategy_two)
+    end
+    
+    def simulate!
+      self.game = Game.new(player_one: player_one, player_two: player_two)
+      puts "Let's start the simulator"
+      while !game.over?
+        if best_next_play = game.best_next_play        
+          puts "Player #{game.player_number(game.current_player)} will play: #{best_next_play.word}"
+          game.play(*best_next_play.to_hash[:coordinates])
+        else
+          puts "Player #{game.player_number(game.current_player)} will pass."
+          game.play
+        end
+        game.print_board
+        game.print_scores
+      end
+      game
+    end
+    
+  end
+end

data/lib/linotype/strategy.rb

@@ -0,0 +1,31 @@
+module Linotype
+  class Strategy
+    
+    LETTERPRESS_FAN_HEURISTIC = ->(move) do
+      move.score[:covered] + move.score[:defended] + move.score[:edges] + move.score[:corners]
+    end
+    
+    MAX_SIX_LETTERS = ->(move) do
+      move.word.length <= 6 ? move.word.length + move.score[:covered] : 0
+    end
+    
+    MAX_FIVE_LETTERS = ->(move) do
+      move.word.length <= 5 ? move.word.length + move.score[:covered] : 0
+    end
+    
+    MAX_THREE_LETTERS = ->(move) do
+      move.word.length <= 3 ? move.word.length + move.score[:covered] : 0
+    end    
+    
+    attr_accessor :scoring_algorithm
+    
+    def initialize(scoring_algorithm)
+      self.scoring_algorithm = scoring_algorithm
+    end
+    
+    def score(move)
+      scoring_algorithm.call move
+    end
+    
+  end
+end

data/lib/linotype/tile.rb

@@ -19,6 +19,10 @@ module Linotype
       }
     end
     
+    def board
+      @board
+    end
+    
     def to_a
       [row, column]
     end
@@ -39,6 +43,14 @@ module Linotype
       @column ||= @board.column(self)
     end
     
+    def edge?
+      (row == 0 || row == board.row_count - 1) || (column == 0 || column == board.column_count - 1)
+    end
+    
+    def corner?
+      (row == 0 || row == board.row_count - 1) && (column == 0 || column == board.column_count - 1)
+    end
+    
     def previous?(coordinate_type)
       send(coordinate_type) > 0
     end

data/lib/linotype/version.rb

@@ -1,3 +1,3 @@
 module Linotype
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/linotype.rb

@@ -4,8 +4,7 @@ require "linotype/board"
 require "linotype/move"
 require "linotype/player"
 require "linotype/tile"
+require "linotype/strategy"
+require "linotype/simulator"
 require "linotype/dictionary/dictionary"
 
-module Linotype
-      
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: linotype
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-30 00:00:00.000000000 Z
+date: 2012-10-31 00:00:00.000000000 Z
 dependencies: []
 description: ! '  linotype implements that game mechanic of Letterpress for iOS by
   atebits software. The program was written to support the automation of letterpress
@@ -36,6 +36,8 @@ files:
 - lib/linotype/game.rb
 - lib/linotype/move.rb
 - lib/linotype/player.rb
+- lib/linotype/simulator.rb
+- lib/linotype/strategy.rb
 - lib/linotype/tile.rb
 - lib/linotype/version.rb
 - linotype.gemspec