upwords 0.1.1

data/lib/upwords/graphics.rb

@@ -0,0 +1,149 @@
+# require 'colored'
+
+module Upwords
+  class Graphics < Curses::Window
+    
+    def initialize(game)
+      super(0,0,0,0)
+      @game = game
+      @board = @game.board
+      @cursor = @game.cursor 
+      @message = ''
+      @rack_visibility = false
+    end
+    
+    def refresh
+      clear
+      self << self.to_s
+      super
+    end
+    
+    def to_s
+      (draw_board + draw_message).zip(draw_stats).map do |board_row, stats_row|
+        (board_row.to_s) + (stats_row.to_s)
+      end.join("\n")
+    end
+
+    def message=(new_message)
+      if new_message.nil?
+        @message = ""
+      else
+        @message = new_message 
+      end
+    end
+
+    def show_rack
+      @rack_visibility = true
+    end
+
+    def hide_rack
+      @rack_visibility = false
+    end
+
+    def toggle_rack_visibility
+      @rack_visibility = !@rack_visibility
+    end
+
+    private
+    
+    def format_letter(row, col)
+      letter = @board.top_letter(row, col)
+      if letter.nil?
+        letter = "  "
+      # add blank space after all other letters except Qu
+      elsif letter != "Qu"
+        letter += " "
+      end
+      letter
+    end
+
+    def draw_player_name
+      "#{@game.current_player.name}'s turn"
+    end
+
+    def draw_score(player)
+      "#{player.name}'s Score: #{player.score}" 
+    end
+
+    def draw_last_turn(player)
+      "Last Move: #{player.last_turn}"
+    end
+
+    def draw_letter_rack
+      "Letters: #{@game.current_player.show_rack(!@rack_visibility)} "
+    end
+
+    def draw_space(row, col, cursor_posn)
+      cursor = cursor_posn == [row, col] ? "*" : " "
+      "#{cursor}#{format_letter(row, col)} "
+    end
+
+    def draw_row(row, cursor_posn)
+      ["|",
+       (0...@board.num_columns).map do |col|
+         draw_space(row, col, cursor_posn)
+       end.join("|"),
+       "|"].join
+    end
+
+    # This will also display the stack height for now
+    def draw_divider(row, col, show_height=true)
+      height = @board.stack_height(row, col)
+      if show_height && height > 0
+        height = height.to_s
+      else
+        height = "-"
+      end
+      "---#{height}"
+    end
+
+    def draw_row_divider(row, show_height=true)
+      ["+",
+       (0...@board.num_columns).map do |col|
+         draw_divider(row, col, show_height)
+       end.join("+"),
+       "+"].join
+    end
+    
+    # print grid of top letter on each stack and stack height
+    def draw_board
+      b = [draw_row_divider(0, false)]
+      
+      (0...@board.num_rows).each do |i|
+        b << draw_row(i, @cursor.posn)
+        b << draw_row_divider(i)
+      end
+
+      b.to_a
+    end
+    
+    def draw_message
+      ["", @message.to_s]
+    end
+
+    def draw_stats
+      ["--------------------",
+       draw_score(@game.players[0]),
+       "",
+       draw_letter_rack,
+       "--------------------",
+       "",
+       @game.player_count > 1 ?draw_score(@game.players[1]) : "",
+       "",         
+       @game.player_count > 2 ? draw_score(@game.players[2]) : "",
+       "",
+       @game.player_count > 3 ? draw_score(@game.players[3]) : "",
+       "",
+       "----------------------",
+       "|      Controls      |",
+       "----------------------",
+       "Show Letters   [SPACE]",
+       "Undo Last Move [DEL]",
+       "Submit Move    [ENTER]",
+       "Swap Letter    [+]",
+       "Skip Turn      [-]",
+       "Quit Game      [SHIFT+Q]"].map{|s| "   #{s}"} # Left padding
+    end
+
+  end
+end

data/lib/upwords/letter_bank.rb

@@ -0,0 +1,22 @@
+module Upwords
+  class LetterBank
+
+    def initialize(letters=[])
+      @bank = letters.dup
+    end
+
+    def empty?
+      @bank.empty?
+    end
+
+    def draw
+      unless self.empty?
+        @bank.delete_at(rand(@bank.size))
+      end
+    end
+
+    def deposit(letter)
+      @bank << letter
+    end  
+  end
+end

data/lib/upwords/letter_rack.rb

@@ -0,0 +1,51 @@
+module Upwords
+  class LetterRack
+    
+    attr_reader :capacity, :letters
+    
+    def initialize(capacity=7)
+      @letters = []
+      @capacity = capacity
+    end
+
+    def size
+      @letters.size
+    end
+
+    def full?
+      size == capacity
+    end
+
+    def empty?
+      @letters.empty?
+    end
+        
+    def has_letter?(letter)
+      @letters.include? letter 
+    end
+    
+    def add(letter)
+      if full?
+        raise IllegalMove, "Rack is full!"
+      else
+        @letters << letter        
+      end
+    end
+
+    def remove(letter)
+      if has_letter?(letter)
+        @letters.delete_at(@letters.index(letter))
+      else
+        raise IllegalMove, "You don't have this letter!"
+      end
+    end
+
+    def show
+      @letters.join(' ')
+    end
+
+    def show_masked
+      @letters.map {'*'}.join(' ')
+    end
+  end
+end

data/lib/upwords/move.rb

@@ -0,0 +1,98 @@
+module Upwords
+  class Move
+    
+    def initialize(tiles = [])
+      @shape = Shape.new(tiles.map {|(row, col), letter| [row, col]})
+      @move = tiles.to_h
+    end
+
+    # TODO: remove dict from word class
+    # TODO: move score and new word methods to board class?
+    def score(board, player)
+      new_words(board).reduce(player.rack_capacity == @move.size ? 20 : 0) do |total, word|
+        total += word.score
+      end
+    end
+
+    # TODO: Add the following legal move checks:
+    # - Move is not a simple pluralization? (e.g. Cat -> Cats is NOT a legal move)
+    def legal?(board, dict, raise_exception = false)
+      legal_shape?(board, raise_exception) && legal_words?(board, dict, raise_exception)
+    end
+
+    def legal_shape?(board, raise_exception = false)
+      @shape.legal?(board, raise_exception)
+    end
+
+    def can_play_letters?(board, raise_exception = false)
+      @move.all? do |(row, col), letter|
+        board.can_play_letter?(letter, row, col, raise_exception)
+      end
+    end
+
+    # TODO: Add the following legal move checks:
+    # - Move is not a simple pluralization? (e.g. Cat -> Cats is NOT a legal move)
+    def legal_words?(board, dict, raise_exception = false)
+
+      if can_play_letters?(board, raise_exception)    
+        bad_words = self.new_illegal_words(board, dict)
+        if bad_words.empty?
+          return true
+        else
+          raise IllegalMove, "#{bad_words.join(', ')} #{bad_words.size==1 ? 'is not a legal word' : 'are not legal words'}!" if raise_exception
+        end
+      end
+
+      return false
+    end
+
+    def position?(row, col)
+      @move.key?([row, col])
+    end
+
+    def [](row, col)
+      @move[[row, col]]
+    end
+    
+    def play(board)
+      @move.reduce(board) do |b, (posn, letter)| 
+        b.play_letter(letter, *posn)
+        b
+      end
+    end
+
+    # TODO: consider move main subroutine to Shape class?
+    def remove_from(board)
+      if @move.any? {|(row, col), letter| board.top_letter(row, col) != letter}
+        raise IllegalMove, "Move does not exist on board and therefore cannot be removed!"
+      else
+        (@move.each_key).reduce(board) do |b, posn| 
+          b.remove_top_letter(*posn)
+          b
+        end
+      end
+    end
+
+    # TODO: handle exceptions when board cannot be updated with new move
+    # TODO: move score and new word methods to board class?
+    def new_words(board)
+      # HACK: update board with new move
+      words = (board.play_move(self).word_positions).select do |word_posns|
+        word_posns.any? {|row, col| position?(row, col)}
+        
+      end.map do |word_posns|
+        Word.new(word_posns, board)
+      end
+
+      # HACK: remove move from board
+      remove_from(board)
+
+      words
+    end
+
+    def new_illegal_words(board, dict)
+      new_words(board).reject {|word| dict.legal_word?(word.to_s)}
+    end
+
+  end
+end

data/lib/upwords/move_manager.rb

@@ -0,0 +1,64 @@
+module Upwords
+  class MoveManager
+    
+    def initialize(board, dictionary) 
+      @board = board
+      @dict = dictionary
+      @pending_move = []
+      @move_history = [] # TODO: Add filled board spaces as first move if board is not empty
+    end
+
+    # --------------------------------
+    # Player-Board Interaction Methods
+    # --------------------------------
+    def add(player, letter, row, col)
+      # TODO: remove the need for @pending_move.map
+      if (@pending_move.map {|m| m[0]}).include?([row, col])
+        raise IllegalMove, "You can't stack on a space more than once in a single turn!"
+      elsif
+        @pending_move << player.play_letter(@board, letter, row, col)
+      end
+    end
+
+    def undo_last(player)
+      if @pending_move.empty?
+        raise IllegalMove, "No moves to undo!"
+      else
+        player.take_from(@board, *@pending_move.pop[0]) # TODO: make Tile class
+      end
+    end
+
+    def undo_all(player)
+      until @pending_move.empty? do
+        undo_last(player)
+      end
+    end
+
+    def submit(player)
+      if @pending_move.empty?
+        raise IllegalMove, "You haven't played any letters!"
+      elsif legal?
+        player.score += pending_score(player)
+        @move_history << Move.new(@pending_move)
+        @pending_move.clear
+      end
+    end
+
+    # TODO: cache prev board in local variable...
+    def pending_words
+      prev_board = Board.build(@move_history, @board.size, @board.max_height)
+      Move.new(@pending_move).new_words(prev_board)
+    end
+    
+    def pending_score(player)
+      prev_board = Board.build(@move_history, @board.size, @board.max_height)
+      Move.new(@pending_move).score(prev_board, player)
+    end
+
+    def legal?
+      prev_board = Board.build(@move_history, @board.size, @board.max_height)
+      Move.new(@pending_move).legal?(prev_board, @dict, raise_exception = true)
+    end
+
+  end
+end

data/lib/upwords/player.rb

@@ -0,0 +1,159 @@
+module Upwords
+  class Player
+
+    attr_reader :name, :cpu
+    attr_accessor :score, :last_turn
+
+    def initialize(name, rack_capacity=7, cpu=false)
+      @name = name
+      @rack = LetterRack.new(rack_capacity)
+      @score = 0
+      @last_turn = nil
+      @cpu = cpu
+    end
+
+    def cpu?
+      @cpu
+    end
+
+    def letters
+      @rack.letters.dup
+    end
+
+    def show_rack(masked = false)
+      masked ? @rack.show_masked : @rack.show
+    end
+
+    def rack_full?
+      @rack.full?
+    end
+
+    def rack_empty?
+      @rack.empty?
+    end
+
+    def rack_capacity
+      @rack.capacity
+    end
+
+    def take_letter(letter)
+      @rack.add(letter)
+    end
+
+    def take_from(board, row, col)
+      if board.stack_height(row, col) == 0
+        raise IllegalMove, "No letters in #{row}, #{col}!"
+      else
+        take_letter(board.remove_top_letter(row, col))
+      end
+    end
+
+    def play_letter(board, letter, row, col)
+      rack_letter = @rack.remove(letter)
+      begin
+        board.play_letter(rack_letter, row, col)
+      rescue IllegalMove => exn
+        take_letter(rack_letter)
+        raise IllegalMove, exn
+      end
+    end
+
+    def swap_letter(letter, letter_bank)
+      if letter_bank.empty?
+        raise IllegalMove, "Letter bank is empty!"
+      else
+        trade_letter = @rack.remove(letter)
+        take_letter(letter_bank.draw)
+        letter_bank.deposit(trade_letter)
+      end
+    end
+
+    def refill_rack(letter_bank)
+      until rack_full? || letter_bank.empty? do
+        take_letter(letter_bank.draw)
+      end
+    end
+    
+    # ----------------
+    # CPU Move Methods
+    # ----------------
+    
+    def straight_moves(board)
+      rows = board.num_rows
+      cols = board.num_columns
+      
+      # Get single-position moves
+      one_space_moves = board.coordinates.map {|posn| [posn]}
+      
+      # Get board positions grouped by rows
+      (0...rows).map do |row| 
+        (0...cols).map {|col| [row, col]}
+        
+        # Get horizontal multi-position moves
+      end.flat_map do |posns|
+        (2..(letters.size)).flat_map {|sz| posns.combination(sz).to_a}
+        
+        # Collect all possible straight moves 
+      end.reduce(one_space_moves) do |all_moves, move|
+        all_moves << move << move.map {|posn| posn.rotate}
+      end
+    end
+    
+    # TODO: Strip out move filters and have the client provide them in a block
+    def legal_move_shapes(board, &filter) 
+      straight_moves(board).select(&filter)
+    end
+    
+    def standard_legal_shape_filter(board)
+      proc do |move_arr|
+        Shape.new(move_arr).legal?(board)
+      end
+    end
+    
+    def legal_shape_letter_permutations(board, &filter)
+      # Cache result of letter permutation computation for each move size
+      letter_perms = Hash.new {|ps, sz| ps[sz] = letters.permutation(sz).to_a}
+      
+      legal_move_shapes(board, &filter).reduce([]) do |all_moves, move|
+        letter_perms[move.size].reduce(all_moves) do |move_perms, perm|
+          move_perms << move.zip(perm)
+        end
+      end
+    end
+
+    def cpu_move(board, dict, sample_size = 1000, min_score = 0)
+      all_possible_moves = (self.legal_shape_letter_permutations(board, &self.standard_legal_shape_filter(board)))      
+      all_possible_moves.shuffle!
+
+      top_score = 0
+      top_score_move = nil
+
+      # TODO: write test for this method
+      while top_score_move.nil? || (top_score < min_score) do
+
+        ([sample_size, all_possible_moves.size].min).times do
+                    
+          move_arr = all_possible_moves.pop
+          move = Move.new(move_arr)
+
+          if move.legal_words?(board, dict)
+
+            move_score = move.score(board, self)
+
+            if move_score >= top_score
+              top_score = move_score
+              top_score_move = move_arr
+            end
+
+          end
+        end
+
+        # Decrement minimum required score after each cycle to help prevent long searches
+        min_score = [(min_score - 1), 0].max
+      end
+
+      top_score_move
+    end
+    
+  end
+end