linotype 0.0.2 → 0.0.3

data/README.md

@@ -19,57 +19,60 @@ Here's a basic rundown of the primary public methods:
     >   game = Linotype::Game.new
     
     >   game.board
-    =>  [
-          [ {:letter=>"I", :row=>0, :column=>0, :covered_by=>nil, :defended=>false},
-            {:letter=>"E", :row=>0, :column=>1, :covered_by=>nil, :defended=>false},
-            {:letter=>"X", :row=>0, :column=>2, :covered_by=>nil, :defended=>false},
-            {:letter=>"A", :row=>0, :column=>3, :covered_by=>nil, :defended=>false},
-            {:letter=>"C", :row=>0, :column=>4, :covered_by=>nil, :defended=>false}
-          ], 
-          [ {:letter=>"R", :row=>1, :column=>0, :covered_by=>nil, :defended=>false},
-            {:letter=>"F", :row=>1, :column=>1, :covered_by=>nil, :defended=>false},
-            {:letter=>"D", :row=>1, :column=>2, :covered_by=>nil, :defended=>false},
-            {:letter=>"S", :row=>1, :column=>3, :covered_by=>nil, :defended=>false},
-            {:letter=>"B", :row=>1, :column=>4, :covered_by=>nil, :defended=>false}
-          ],
-          [ {:letter=>"B", :row=>2, :column=>0, :covered_by=>nil, :defended=>false},
-            {:letter=>"L", :row=>2, :column=>1, :covered_by=>nil, :defended=>false},
-            {:letter=>"K", :row=>2, :column=>2, :covered_by=>nil, :defended=>false},
-            {:letter=>"Q", :row=>2, :column=>3, :covered_by=>nil, :defended=>false},
-            {:letter=>"P", :row=>2, :column=>4, :covered_by=>nil, :defended=>false}
-          ],
-          [ {:letter=>"S", :row=>3, :column=>0, :covered_by=>nil, :defended=>false},
-            {:letter=>"O", :row=>3, :column=>1, :covered_by=>nil, :defended=>false},
-            {:letter=>"K", :row=>3, :column=>2, :covered_by=>nil, :defended=>false},
-            {:letter=>"P", :row=>3, :column=>3, :covered_by=>nil, :defended=>false},
-            {:letter=>"W", :row=>3, :column=>4, :covered_by=>nil, :defended=>false}
-          ],
-          [ {:letter=>"L", :row=>4, :column=>0, :covered_by=>nil, :defended=>false},
-            {:letter=>"U", :row=>4, :column=>1, :covered_by=>nil, :defended=>false},
-            {:letter=>"J", :row=>4, :column=>2, :covered_by=>nil, :defended=>false},
-            {:letter=>"Y", :row=>4, :column=>3, :covered_by=>nil, :defended=>false},
-            {:letter=>"D", :row=>4, :column=>4, :covered_by=>nil, :defended=>false}
-          ]
-        ] 
+    =>  [[{:letter=>"N", :row=>0, :column=>0, :covered_by=>1, :defended=>true},
+          {:letter=>"S", :row=>0, :column=>1, :covered_by=>1, :defended=>false},
+          {:letter=>"L", :row=>0, :column=>2, :covered_by=>nil, :defended=>false},
+          {:letter=>"K", :row=>0, :column=>3, :covered_by=>nil, :defended=>false},
+          {:letter=>"W", :row=>0, :column=>4, :covered_by=>nil, :defended=>false}],
+         [{:letter=>"T", :row=>1, :column=>0, :covered_by=>1, :defended=>true},
+          {:letter=>"P", :row=>1, :column=>1, :covered_by=>1, :defended=>false},
+          {:letter=>"Y", :row=>1, :column=>2, :covered_by=>nil, :defended=>false},
+          {:letter=>"E", :row=>1, :column=>3, :covered_by=>1, :defended=>false},
+          {:letter=>"E", :row=>1, :column=>4, :covered_by=>nil, :defended=>false}],
+         [{:letter=>"L", :row=>2, :column=>0, :covered_by=>1, :defended=>false},
+          {:letter=>"O", :row=>2, :column=>1, :covered_by=>nil, :defended=>false},
+          {:letter=>"L", :row=>2, :column=>2, :covered_by=>nil, :defended=>false},
+          {:letter=>"Z", :row=>2, :column=>3, :covered_by=>nil, :defended=>false},
+          {:letter=>"Z", :row=>2, :column=>4, :covered_by=>nil, :defended=>false}],
+         [{:letter=>"T", :row=>3, :column=>0, :covered_by=>nil, :defended=>false},
+          {:letter=>"B", :row=>3, :column=>1, :covered_by=>nil, :defended=>false},
+          {:letter=>"W", :row=>3, :column=>2, :covered_by=>nil, :defended=>false},
+          {:letter=>"M", :row=>3, :column=>3, :covered_by=>nil, :defended=>false},
+          {:letter=>"F", :row=>3, :column=>4, :covered_by=>nil, :defended=>false}],
+         [{:letter=>"B", :row=>4, :column=>0, :covered_by=>nil, :defended=>false},
+          {:letter=>"O", :row=>4, :column=>1, :covered_by=>nil, :defended=>false},
+          {:letter=>"F", :row=>4, :column=>2, :covered_by=>nil, :defended=>false},
+          {:letter=>"M", :row=>4, :column=>3, :covered_by=>nil, :defended=>false},
+          {:letter=>"V", :row=>4, :column=>4, :covered_by=>nil, :defended=>false}]] 
     
     >   # Takes about 8 seconds on a laptop -- brute force solution
     >   game.potential_plays
     =>  ["WORD","MATCHES","FROM","DICTIONARY","IN","AN","ARRAY"]
     
-    >   game.play({ row: 3, column: 1 }, {row: 3, column: 0})
+    >   next_play = game.best_next_play
+    
+    >   game.play(*next_play[:coordinates])
     =>  true
     
-    >   game.moves
-    =>  [{:player=>1, :word=>"OS", :valid=>true, :invalid_reason=>nil, :player_sequence=>1, :total_sequence=>1}
+    >   game.moves.last.to_hash
+    =>  { :player=>1,
+          :word=>"SPLENT",
+          :valid=>true,
+          :coordinates=>[[0, 1], [1, 1], [2, 0], [1, 3], [0, 0], [1, 0]],
+          :invalid_reason=>nil,
+          :player_sequence=>1,
+          :total_sequence=>1,
+          :score => {
+            :defended_before=>0,
+            :covered_before=>0,
+            :defended_after=>2,
+            :covered_after=>6,
+            :defended=>2,
+            :covered=>6}
+          }
 
     >   game.scores
     =>  {1=>2, 2=>0}
-    
-    >   game.play({ row: 1, column: 0 }, {row: 1, column: 1})
-    =>  false
-    
-    >   game.moves.last
-    =>  {:player=>2, :word=>"RF", :valid=>false, :invalid_reason=>"is not in dictionary", :player_sequence=>1, :total_sequence=>1} 
 
     #   pass by playing a nil move
     >   game.play
@@ -89,10 +92,8 @@ The default dictionary is based on the the [Internet Scrabble Club's TWL06 dicti
 
 ## Feature Ideas
 
-* Game board loading from string
 * Game board loading from iOS screen shot
 * Word suggestions (faster)
-* Game simulation with strategy suggestion
 * One player command line game
 * Vowel/consonant ratio setting for random boards
 * Built in dictionaries for different languages or topics

data/lib/linotype/board.rb

@@ -9,8 +9,12 @@ module Linotype
       @tiles = args[:tiles].collect { |row| row.collect { |tile|  Tile.new(self, tile) } }
     end
         
-    def self.new_random(game, rows=5, columns=5)
-      new(game, tiles: rows.times.collect { columns.times.collect { ('A'..'Z').to_a[rand(0..25)] } })
+    def self.new_random(game)
+      new(game, new_random_letters)
+    end
+    
+    def self.new_random_letters(rows=5, columns=5)
+      rows.times.collect { columns.times.collect { ('A'..'Z').to_a[rand(0..25)] } }
     end
 
     def row_count

data/lib/linotype/game.rb

@@ -1,22 +1,89 @@
 module Linotype
   class Game
         
-    def initialize
-      @board = Board.new_random(self)
+    attr_accessor :moves
+    attr_reader :current_player
+
+    def initialize(args={})
+      @board = Board.new(self, tiles: create_tile_letter_array(args[:tiles]))
       @players = [Player.new, Player.new]
       @current_player = @players[0]
       @moves = []
     end
+    
+    def create_tile_letter_array(letter_arg)
+      case letter_arg
+      when nil
+        Board.new_random_letters
+      when Array
+        letter_arg
+      when String
+        square_size = Math.sqrt(letter_arg.length).ceil
+        letter_array = [[]]
+        letter_arg.each_char do |letter|
+          letter_array << [] if letter_array.last.size == square_size
+          letter_array.last << letter.upcase
+        end
+        letter_array
+      end
+    end
         
     def play(*tile_coordinates)
       tiles = find_tiles(tile_coordinates)
-      move = Move.new(self, @current_player, tiles)
-      if move.valid?
-        move.cover_tiles!
-        toggle_current_player
+      Move.new(self, @current_player, tiles).valid?
+    end
+    
+    def every_play_for_word(word)
+      tiles_per_letter = {}
+      word.chars.to_a.uniq.each do |unique_letter|
+        tiles_per_letter[unique_letter] = []
+        tile_rows.flatten.select { |tile| tile.letter == unique_letter }.each do |matching_tile|
+          tiles_per_letter[unique_letter] << matching_tile
+        end
+      end
+      variations = tiles_per_letter.values.inject(1) { |vars, tiles| tiles.count * vars }
+      plays = []
+      v = 0
+      variations.times { plays << []; v += 1 }
+      word.chars.each do |letter|
+        play_number = 0
+        repetitions = variations / tiles_per_letter[letter].count
+        tiles_per_letter[letter].each do |tile|
+          repetitions.times do
+            plays[play_number] << tile
+            play_number += 1
+          end
+        end
       end
-      @moves << move
-      @current_player == move.player ? false : true
+      plays.select { |play| play.uniq.count == play.count }
+    end
+    
+    def test_potential_plays
+      potential_moves = []
+      potential_plays.each do |word_to_test|
+        every_play_for_word(word_to_test).each do |tiles|
+          move = Move.new(self, @current_player, tiles)
+          potential_moves << move
+          undo_last_move!
+        end
+      end
+      potential_moves.collect(&:to_hash)
+    end
+    
+    def valid_potential_plays
+      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
+    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?
@@ -35,10 +102,6 @@ module Linotype
       tile_rows.collect { |row| row.collect { |tile| tile.to_hash } }
     end
     
-    def moves
-      @moves.collect { |move| move.to_hash }
-    end
-
     def player_number(player)
       @players.index(player) + 1
     end
@@ -47,8 +110,27 @@ module Linotype
       covered_tiles(player).count
     end
     
-    def potential_plays
-      @potential_plays ||= dictionary.words.select { |word| (word.chars.to_a - letters).empty? }
+    def potential_plays(remaining_letters=letters)
+      @potential_plays ||= calc_potential_plays(remaining_letters)
+    end
+    
+    def calc_potential_plays(remaining_letters)
+      plays = []
+      letter_group = letters.group_by { |l| l }
+      dictionary.words.each do |word|
+        if word_match(letter_group, word)
+          plays << word
+        end
+      end
+      plays
+    end
+    
+    def word_match(letter_group, word)
+      word_letter_group = word.chars.to_a.group_by { |c| c }
+      word.each_char do |letter|
+        return false unless (letter_group[letter] && letter_group[letter].count >= word_letter_group[letter].count)
+      end
+      true
     end
 
     def valid_moves
@@ -74,13 +156,11 @@ module Linotype
     def other_player
       @players.index(@current_player) == 0 ? @players[1] : @players[0]
     end
-    private :other_player
         
     def find_tiles(tile_coordinates)
-      puts tile_coordinates.inspect
       return [] if tile_coordinates.empty?
       tile_coordinates.collect do |tile_coordinate|
-        tile = tile_rows[tile_coordinate[:row]][tile_coordinate[:column]]
+        tile = tile_rows[tile_coordinate[0]][tile_coordinate[1]]
         raise ArgumentError, "The board does not have a tile at that location" unless tile
         tile
       end
@@ -90,17 +170,19 @@ module Linotype
     def toggle_current_player
       @current_player = other_player
     end
-    private :toggle_current_player
     
     def uncovered_tiles
       covered_tiles(nil)
     end
     private :uncovered_tiles
     
+    def defended_tiles(player)
+      tile_rows.flatten.select { |tile| tile.covered_by == player && tile.defended? }
+    end
+    
     def covered_tiles(player)
       tile_rows.flatten.select { |tile| tile.covered_by == player }
     end
-    private :covered_tiles
     
     def two_passes_in_a_row?
       valid_moves.count >= 2 && valid_moves[-2,2].select { |move| move.pass? }.count == 2

data/lib/linotype/move.rb

@@ -1,15 +1,37 @@
 module Linotype
   class Move
     
-    attr_reader :game, :player, :invalid_reason
+    attr_reader :game, :player, :invalid_reason, :score
     
     def initialize(game, player, tiles)
       @game = game
       @player = player
       @tiles = tiles
       calculate_valid
+      if valid?
+        calculate_scores(:before)
+        cover_tiles!
+        calculate_scores(:after)
+        calculate_net_scores
+        @game.toggle_current_player
+      end
+      @game.moves << self
+    end
+    
+    def score
+      @score ||= {}
+    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
     end
-       
+    
+    def calculate_net_scores
+      score[:defended] = score[:defended_after] - score[:defended_before]
+      score[:covered] = score[:covered_after] - score[:covered_before]
+    end
+           
     def valid?
       !!@valid
     end
@@ -27,7 +49,12 @@ module Linotype
     end
     
     def cover_tiles!
-      @tiles.each { |tile| tile.covered_by = @player unless tile.defended? }
+      @previously_defended_tiles = @tiles.select { |tile| tile.defended? }
+      (@tiles - @previously_defended_tiles).each { |tile| tile.covered_by = @player }
+    end
+    
+    def uncover_tiles!
+      (@tiles - @previously_defended_tiles).each { |tile| tile.covered_by = nil }
     end
     
     def to_hash
@@ -35,9 +62,11 @@ module Linotype
         player: game.player_number(@player),
         word: word,
         valid: valid?,
+        coordinates: @tiles.collect(&:to_a),
         invalid_reason: @invalid_reason,
         player_sequence: game.valid_moves.select { |move| move.player == @player }.index(self).to_i + 1,
-        total_sequence: game.valid_moves.index(self).to_i + 1
+        total_sequence: game.valid_moves.index(self).to_i + 1,
+        score: score
       }
     end
         

data/lib/linotype/tile.rb

@@ -19,6 +19,10 @@ module Linotype
       }
     end
     
+    def to_a
+      [row, column]
+    end
+    
     def game
       @board.game
     end

data/lib/linotype/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: linotype
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors: