upwords 0.1.1

data/exe/upwords

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'upwords'
+
+Upwords::Game.new.run

data/lib/upwords.rb

@@ -0,0 +1,48 @@
+require 'set'
+require 'curses'
+
+require 'upwords/version'
+
+require 'upwords/board'
+require 'upwords/letter_bank'
+require 'upwords/letter_rack'
+require 'upwords/dictionary'
+
+require 'upwords/shape'
+require 'upwords/move'
+require 'upwords/move_manager'
+
+require 'upwords/cursor'
+
+require 'upwords/word'
+require 'upwords/player'
+require 'upwords/graphics'
+require 'upwords/game'
+
+module Upwords
+  # Raised when player makes an illegal move
+  class IllegalMove < StandardError
+  end
+
+  # Letters available in 10 x 10 version of Upwords
+  ALL_LETTERS = {
+    8 => ["E"],
+    7 => ["A", "I", "O"],
+    6 => ["S"],
+    5 => ["D", "L", "M", "N", "R", "T", "U"],
+    4 => ["C"],
+    3 => ["B", "F", "G", "H", "P"],
+    2 => ["K", "W", "Y"],
+    1 => ["J", "Qu", "V", "X", "Z"]
+  }.flat_map {|count, letters| letters * count}
+
+  # Curses Key Constants
+  ESCAPE = 27
+  SPACE = ' '
+  DELETE = 127
+  ENTER = 10
+
+  # Official Scrabble Player Dictionary file
+  OSPD_FILE = File.join(File.dirname(__FILE__), "../data/ospd.txt")
+  
+end

data/lib/upwords/board.rb

@@ -0,0 +1,131 @@
+module Upwords
+  class Board
+    
+    attr_accessor :max_height, :size
+
+    # creates a 10 x 10 board
+    def initialize(size=10, max_height=5)
+      if !size.positive?
+        raise ArgumentError, "Board size must be greater than zero!"
+      else
+        @size = size
+        @max_height = max_height
+        @grid = Hash.new do |h, (row, col)|
+          if row < 0 || col < 0 || num_rows <= row || num_columns <= col
+            raise IllegalMove, "#{row}, #{col} is out of bounds!"
+          else
+            h[[row, col]] = []    # Initialize with empty array
+          end
+        end
+      end
+    end
+    
+    def empty?
+      @grid.empty? || @grid.each_key.all? {|k| @grid[k].empty?}
+    end
+
+    def nonempty_space?(row, col)
+      @grid.key?([row, col]) && stack_height(row, col) > 0
+    end
+
+    # maximum letters than can be stacked in one space
+    def min_word_length
+      2
+    end
+
+    def num_rows
+      @size
+    end
+    
+    def num_columns
+      @size
+    end
+
+    # Defines a 2x2 square in the middle of the board (in the case of the 10 x 10 board)
+    # The top left corner of the square is the initial cursor position
+    # The square itself defines the region where at least one of the first letters must be placed
+    def middle_square
+      [1, 0].product([1, 0]).map do |r, c|
+        [(num_rows) / 2 - r, (num_columns) / 2 - c]
+      end
+    end
+
+    def stack_height(row, col)
+      @grid[[row, col]].size
+    end
+
+    def play_move(move)
+      move.play(self)
+    end
+
+    def undo_move(move)
+      move.remove_from(self)
+    end
+
+    def can_play_letter?(letter, row, col, raise_exception = false)
+      if stack_height(row, col) == max_height
+        raise IllegalMove, "You cannot stack any more letters on this space" if raise_exception
+      elsif top_letter(row, col) == letter
+        raise IllegalMove, "You cannot stack a letter on the same letter!" if raise_exception
+      else 
+        return true
+      end
+      return false
+    end
+
+    def play_letter(letter, row, col)
+      if can_play_letter?(letter, row, col, raise_exception = true)
+        @grid[[row, col]] << letter
+        return [[row, col], letter] # Return position after successfully playing a move
+      end  
+    end
+
+    def remove_top_letter(row, col)
+      @grid[[row, col]].pop
+    end
+    
+    # show top letter in board space
+    def top_letter(row, col)
+      get_letter(row, col, 1)
+    end
+
+    def get_letter(row, col, depth=1)
+      @grid[[row, col]][-depth]
+    end
+
+    def word_positions
+      row_word_posns + column_word_posns
+    end
+
+    def nonempty_spaces
+      coordinates.select {|row, col| nonempty_space?(row, col)}.to_set
+    end
+
+    def coordinates
+      (0...num_rows).to_a.product((0...num_columns).to_a)
+    end    
+
+    def self.build(moves, size=10, max_height=5)
+      moves.reduce(Board.new(size, max_height)) do |board, move|
+        board.play_move(move)
+      end
+    end
+
+    private
+
+    def collect_word_posns(&block)
+      SortedSet.new(nonempty_spaces).divide(&block).select do |w| 
+        w.length >= min_word_length
+      end.to_set
+    end
+
+    def row_word_posns
+      collect_word_posns {|(r1,c1),(r2,c2)| (c1 - c2).abs == 1 && r1 == r2 }
+    end
+
+    def column_word_posns
+      collect_word_posns {|(r1,c1),(r2,c2)| (r1 - r2).abs == 1 && c1 == c2 }
+    end
+    
+  end
+end

data/lib/upwords/cursor.rb

@@ -0,0 +1,39 @@
+module Upwords
+  class Cursor
+    attr_reader :x, :y
+    
+    def initialize(max_y, max_x, init_y = 0, init_x = 0)
+      @max_y = max_y
+      @max_x = max_x
+
+      # TODO: Handle case where init_y, x are outside bounds
+      @y = init_y 
+      @x = init_x
+    end
+
+    def up
+      move(-1, 0)
+    end
+
+    def down
+      move(1, 0)
+    end
+
+    def left
+      move(0, -1)
+    end
+
+    def right
+      move(0, 1)
+    end
+
+    def move(dy, dx)
+      @y = (y + dy) % @max_y
+      @x = (x + dx) % @max_x 
+    end 
+
+    def posn
+      [y, x]
+    end
+  end
+end

data/lib/upwords/dictionary.rb

@@ -0,0 +1,31 @@
+module Upwords
+  class Dictionary
+
+    def initialize(words = [])
+      @legal_words = Set.new(words.map {|w| w.upcase})
+    end
+    
+    def self.import(filepath)
+      dict = Dictionary.new
+      File.foreach(filepath) do |line|
+        dict << line.chomp
+      end
+      dict
+    end
+
+    def legal_word? word
+      @legal_words.member? (word.upcase)
+    end
+
+    def add_word word
+      @legal_words.add? (word.upcase)
+    end
+
+    alias_method :<<, :add_word
+
+    def remove_word word
+      @legal_words.delete? (word.upcase)
+    end
+    
+  end
+end

data/lib/upwords/game.rb

@@ -0,0 +1,325 @@
+module Upwords
+  class Game
+    attr_reader :board, :cursor, :players
+    
+    def initialize(display_on = true, max_players = 4)
+      @max_players = max_players
+      @display_on = display_on
+      @board = Board.new(10, 5)
+      @letter_bank = LetterBank.new(ALL_LETTERS.dup)
+      @cursor = Cursor.new(@board.num_rows,
+                           @board.num_columns,
+                           *@board.middle_square[0])
+      @dict = Dictionary.import(OSPD_FILE)
+      @moves = MoveManager.new(@board, @dict)
+      @players = []
+      @running = false
+      @submitted = false
+    end
+    
+    # =========================================
+    # Player Methods
+    # =========================================
+
+    def current_player
+      @players.first
+    end
+
+    def max_players
+      @max_players
+    end
+
+    def player_count
+      player_count = @players.size
+    end
+
+    def add_player(name = nil, cpu = false)
+      if player_count >= max_players
+        raise StandardError, "No more players can join"
+      else
+        if name.nil? || name.size == 0
+          name = "Player #{player_count + 1}" 
+        end
+        @players << Player.new(name, rack_capacity=7, cpu)
+      end
+      @players.each {|p| p.refill_rack(@letter_bank) }
+    end
+
+    def add_players(player_names = nil)
+      print "\n"
+      num_players = 0
+
+      # Select how many players will be in the game
+      # TODO: Add a command-line flag to allow players to skip this step
+      until (1..@max_players).include?(num_players) do
+        print "How many players will play? (1-#{@max_players})\n"
+        num_players = gets.chomp.to_i
+        print "\n"
+        if !(1..@max_players).include?(num_players)
+          print "Invalid selection: #{num_players}\n\n"
+        end
+      end
+
+      # Name each player and choose if they are humans or computers
+      # TODO: Add a command-line flag to set this
+      (1..num_players).each do |idx|
+        print "What is Player #{idx}'s name?\n"
+        name = gets.chomp
+        print "Is Player #{idx} or a computer? (y/n)\n"
+        cpu = gets.chomp
+        add_player(name, cpu.upcase == "Y")
+        print "\n"
+      end
+    end
+
+    # =========================================
+    # Graphics Methods
+    # =========================================
+
+    def init_window
+      Curses.noecho
+      Curses.curs_set(0) 
+      Curses.init_screen
+      # Curses.start_color
+
+      @win = Graphics.new(self)
+      @win.keypad(true)
+    end
+    
+    def display_on?
+      @display_on
+    end
+    
+    def refresh_graphics
+      if display_on? && running?
+        @win.refresh
+      end
+    end
+
+    def update_message msg
+      if display_on?
+        @win.message = msg
+        refresh_graphics
+      end
+    end
+
+    def clear_message
+      update_message standard_message
+    end
+
+    def standard_message
+      "#{current_player.name}'s pending words: #{pending_result}"
+    end
+
+    def pending_result
+      new_words = @moves.pending_words
+
+      unless new_words.empty?
+        new_words.map do |w|
+          "#{w} (#{w.score})"
+        end.join(", ") + " (Total = #{@moves.pending_score(current_player)})"
+      end
+    end
+    
+    # =========================================
+    # Game Loops & Non-Input Procedures
+    # =========================================
+
+    def running?
+      @running
+    end
+
+    def run
+      @running = true
+      
+      # Add players
+      add_players
+
+      # Start graphics
+      init_window if @display_on
+      clear_message
+
+      # Start main loop
+      while running? do
+        begin
+          # ------ CPU MOVE --------
+          if current_player.cpu?
+            update_message "#{current_player.name} is thinking..."
+            cpu_move = current_player.cpu_move(@board, @dict, 50, 10)
+            
+            if !cpu_move.nil?
+              cpu_move.each do |posn, letter|
+                @moves.add(current_player, letter, *posn)
+              end
+              submit_moves(need_confirm=false)
+            else
+              skip_turn(need_confirm=false)
+            end
+          else
+            read_input(@win.getch)
+          end
+
+          if @submitted
+            # TODO: remove magic string from last move message
+            if @players.all? {|p| p.last_turn == "skipped turn"} || @letter_bank.empty? && current_player.rack_empty?
+              game_over
+              @running = false
+            else    
+              next_turn
+            end
+          end
+          
+          refresh_graphics
+          
+        rescue IllegalMove => exception
+          update_message "#{exception.message} (press any key to continue...)"
+          @win.getch if display_on?
+          clear_message
+        end
+      end
+      
+    end
+
+    def read_input(key)
+      case key
+      when 'Q'
+        exit_game
+      when SPACE
+        toggle_rack_visibility
+      when DELETE
+        undo_moves
+      when ENTER
+        submit_moves
+      when Curses::KEY_UP
+        @cursor.up
+      when Curses::KEY_DOWN
+        @cursor.down
+      when Curses::KEY_LEFT
+        @cursor.left
+      when Curses::KEY_RIGHT
+        @cursor.right
+      when '+'
+        swap_letter
+      when '-'
+        skip_turn
+      when /[[:alpha:]]/
+        @moves.add(current_player, modify_letter_input(key), @cursor.y, @cursor.x)
+        clear_message
+      end
+    end
+    
+    def next_turn
+      @players.rotate!
+      @win.hide_rack if display_on?
+      clear_message
+      @submitted = false
+    end
+
+    # =========================================
+    # Methods Related to Key Inputs
+    # =========================================
+
+    # Capitalize letters, and convert 'Q' and 'q' to 'Qu'
+    def modify_letter_input(letter)
+      if letter =~ /[Qq]/
+        'Qu'
+      else
+        letter.capitalize
+      end
+    end
+
+    def confirm_action?(question_text)
+      if display_on?
+        update_message "#{question_text} (y/n)"
+        inp = @win.getch
+        clear_message
+        inp == 'y' || inp == 'Y'
+      else
+        true # Never ask for confirm if the display_on is off
+      end
+    end
+
+    # =========================================
+    # Game Procedures Bound to some Key Input
+    # =========================================
+
+    def undo_moves
+      @moves.undo_last(current_player)
+      clear_message
+    end
+
+    def submit_moves(need_confirm=true)
+      if !need_confirm || (confirm_action? "Are you sure you want to submit?")
+        @moves.submit(current_player)
+        current_player.refill_rack(@letter_bank)
+        @submitted = true
+        clear_message
+
+        # TODO: remove magic string from last move message
+        current_player.last_turn = "played word"
+      end
+    end
+
+    # TODO: Test this method...
+    def swap_letter(need_confirm=true)
+      update_message "Pick a letter to swap... "
+      letter = @win.getch
+
+      if letter =~ /[[:alpha:]]/
+        letter = modify_letter_input(letter)
+        if !need_confirm || (confirm_action? "Swap '#{letter}' for another?")
+          @moves.undo_all(current_player)
+          current_player.swap_letter(letter, @letter_bank)
+          @submitted = true
+
+          # TODO: remove magic string from last move message
+          current_player.last_turn = "swapped letter"
+        end
+      end
+    end
+
+    def skip_turn(need_confirm=true)
+      if !need_confirm || (confirm_action? "Are you sure you want to skip your turn?")
+        @moves.undo_all(current_player)
+        @submitted = true
+
+        # TODO: remove magic string from last move message
+        current_player.last_turn = "skipped turn"
+      end
+    end
+
+    def exit_game(need_confirm=true)
+      if !need_confirm || (confirm_action? "Are you sure you want to exit the game?")
+        @running = false
+        @win.close if display_on?
+      end
+    end
+
+    def toggle_rack_visibility 
+      @win.toggle_rack_visibility
+    end
+
+    def game_over
+      update_message "The game is over. Press any key to continue to see who won..."
+      @win.getch if display_on?
+
+      # Subtract 5 points for each tile remaining
+      @players.each do |p|
+        p.score -= p.letters.size * 5
+      end
+
+      top_score = @players.map {|p| p.score}.max
+      winners = @players.select{|p| p.score == top_score}.map{|p| p.name}
+
+      if winners.size == 1 
+        update_message "And the winner is... #{winners[0]} with #{top_score} points!"
+      else
+        update_message "We have a tie! #{winners.join(', ')} all win with #{top_score} points!"
+      end
+
+      @win.getch if display_on?
+      exit_game(need_confirm=false)
+    end
+
+  end
+end