nerdword 0.0.1

data/lib/board.rb

@@ -0,0 +1,102 @@
+class Board
+  def initialize(values, letter_multipliers = {}, word_multipliers = {})
+    @values = values
+    @letter_multipliers = letter_multipliers
+    @word_multipliers = word_multipliers
+    @history = []
+  end
+
+  def play(move)
+    index = generate_index(@history)
+    moves = find_moves(move, index)
+    @history << move
+    score = moves.inject(0) { |score, move| score + score_move(move, index) }
+    tiles_used = calculate_tiles_used(move, index)
+    if tiles_used.length == 7
+      score += 50
+    end
+    [score, tiles_used]
+  end
+
+  private
+
+  def find_moves(move, index)
+    moves = [move]
+
+    direction = move.direction
+    orthogonal_direction = Direction.opposite(direction)
+
+    move.word.length.times do |i|
+      current = move.position.shift(i, direction)
+      next if index[current] # not placed by us, so don't look for adjacent letters
+
+      behind = current.previous(orthogonal_direction)
+      ahead = current.next(orthogonal_direction)
+
+      if index[behind] || index[ahead]
+        total_index = generate_index(@history + [move])
+        move_start = find_move_start(current, orthogonal_direction, total_index)
+        prefix = Move.new(total_index[move_start], move_start, orthogonal_direction)
+        moves << find_move(prefix, total_index)
+      end
+    end
+
+    moves
+  end
+
+  def find_move_start(position, direction, index)
+    prev = position.previous(direction)
+
+    if index[prev]
+      find_move_start(prev, direction, index)
+    else
+      position
+    end
+  end
+
+  def find_move(prefix, index)
+    ahead = prefix.position.shift(prefix.word.length, prefix.direction)
+
+    if index[ahead]
+      find_move(Move.new(prefix.word + index[ahead], prefix.position, prefix.direction), index)
+    else
+      prefix
+    end
+  end
+
+  def generate_index(history)
+    index = {}
+
+    history.each do |move|
+      move.word.each_char.with_index do |char, i|
+        index[move.position.shift(i, move.direction)] = move.word[i]
+      end
+    end
+
+    index
+  end
+
+  def score_move(move, index)
+    word_multiplier = 1
+    score = move.word.each_char.with_index.inject(0) do |score, (c, i)|
+      pos = move.position.shift(i, move.direction)
+      if index[pos]
+        score + @values[c]
+      else
+        word_multiplier *= @word_multipliers.fetch(pos, 1)
+        score + @values[c] * @letter_multipliers.fetch(pos, 1)
+      end
+    end * word_multiplier
+    score
+  end
+
+  def calculate_tiles_used(move, index)
+    used = []
+    move.word.each_char.with_index do |char, i|
+      next if index[move.position.shift(i, move.direction)]
+      used << char
+    end
+
+    used
+  end
+end

data/lib/direction.rb

@@ -0,0 +1,12 @@
+module Direction
+  HORIZONTAL = "Horizontal".freeze
+  VERTICAL = "Vertical".freeze
+
+  def self.opposite(direction)
+    if direction == HORIZONTAL
+      VERTICAL
+    else
+      HORIZONTAL
+    end
+  end
+end

data/lib/move.rb

@@ -0,0 +1,21 @@
+class Move
+  attr_reader :word, :position, :direction
+
+  def initialize(word, position, direction)
+    @word = word
+    @position = position
+    @direction = direction
+  end
+
+  def ==(other)
+    [word, position, direction] == [other.word, other.position, other.direction]
+  end
+
+  def eql?(other)
+    [word, position, direction].eql?[other.word, other.position, other.direction]
+  end
+
+  def hash
+    [word, position, direction].hash
+  end
+end

data/lib/not_random.rb

@@ -0,0 +1,5 @@
+class NotRandom
+  def rand(*args)
+    0
+  end
+end

data/lib/player.rb

@@ -0,0 +1,36 @@
+class Player
+  def initialize(board, pouch, rack = [])
+    @board = board
+    @pouch = pouch
+    @score = 0
+    @rack = rack
+  end
+
+  def play(move)
+    score, tiles_used = @board.play(move)
+    @score += score
+    remove_tiles(tiles_used)
+  end
+
+  def score
+    @score
+  end
+
+  def draw
+    need = 7 - @rack.length
+    @rack.concat(@pouch.draw(need))
+  end
+
+  def exchange(tiles)
+    remove_tiles(tiles)
+    @rack.concat(@pouch.exchange(tiles))
+  end
+
+  private
+
+  def remove_tiles(tiles)
+    tiles.each do |tile|
+      @rack.slice!(@rack.index(tile))
+    end
+  end
+end

data/lib/position.rb

@@ -0,0 +1,38 @@
+require "direction"
+
+class Position
+  attr_reader :col, :row
+
+  def initialize(col, row)
+    @col = col
+    @row = row
+  end
+
+  def shift(offset, direction)
+    if direction == Direction::HORIZONTAL
+      Position.new(col + offset, row)
+    else
+      Position.new(col, row + offset)
+    end
+  end
+
+  def previous(direction)
+    shift(-1, direction)
+  end
+
+  def next(direction)
+    shift(1, direction)
+  end
+
+  def ==(other)
+    [col, row] == [other.col, other.row]
+  end
+
+  def eql?(other)
+    [col, row].eql?([other.col, other.row])
+  end
+
+  def hash
+    [col, row].hash
+  end
+end

data/lib/pouch.rb

@@ -0,0 +1,23 @@
+class Pouch
+  def initialize(tiles, rng = Random.new)
+    @tiles = tiles
+    @rng = rng
+  end
+
+  def draw(num)
+    shuffle
+    @tiles.shift(num)
+  end
+
+  def exchange(tiles)
+    new_tiles = draw(tiles.length)
+    @tiles.concat(tiles)
+    new_tiles
+  end
+
+  private
+
+  def shuffle
+    @tiles.sort_by! { @rng.rand }
+  end
+end

data/spec/board_spec.rb

@@ -0,0 +1,118 @@
+require "board"
+require "move"
+require "position"
+
+describe Board do
+  it "scores a move" do
+    values = { ?C => 2, ?A => 4, ?T => 8 }
+    board = Board.new(values)
+
+    score, _ = board.play(Move.new("CAT", Position.new(0, 0), Direction::HORIZONTAL))
+
+    score.should eq(14)
+  end
+
+  it "scores a multi-word move" do
+    values = { ?C => 4, ?A => 1, ?T => 1, ?I => 1, ?N => 2 }
+    board = Board.new(values)
+
+    board.play(Move.new("CAT", Position.new(0, 0), Direction::HORIZONTAL))
+    score, _ = board.play(Move.new("TIN", Position.new(1, 1), Direction::HORIZONTAL))
+
+    score.should eq(8)
+  end
+
+  it "returns the tiles used to make the play" do
+    values = { ?C => 1, ?A => 4, ?T => 8, ?S => 1 }
+    board = Board.new(values)
+
+    _, tiles_used1 = board.play(Move.new("CAT", Position.new(0, 0), Direction::HORIZONTAL))
+    _, tiles_used2 = board.play(Move.new("CATS", Position.new(0, 0), Direction::HORIZONTAL))
+
+    tiles_used1.should eq(%w{C A T})
+    tiles_used2.should eq(%w{S})
+  end
+
+  it "scores letter multipliers" do
+    values = { ?C => 2, ?A => 4, ?T => 8 }
+    letter_multipliers = { Position.new(0, 0) => 2 }
+    board = Board.new(values, letter_multipliers)
+
+    score, _ = board.play(Move.new("CAT", Position.new(0, 0), Direction::HORIZONTAL))
+
+    score.should eq(16)
+  end
+
+  it "scores letter multipliers in every word formed" do
+    values = Hash.new(1)
+    letter_multipliers = { Position.new(1, 1) => 2 }
+    board = Board.new(values, letter_multipliers)
+
+    board.play(Move.new("CAT", Position.new(0, 0), Direction::HORIZONTAL))
+    score, _ = board.play(Move.new("TIN", Position.new(1, 1), Direction::HORIZONTAL))
+
+    score.should eq(9)
+  end
+
+  it "only counts letter multipliers played this turn" do
+    values = { ?C => 2, ?A => 4, ?T => 8, ?S => 1 }
+    letter_multipliers = { Position.new(0, 0) => 2 }
+    board = Board.new(values, letter_multipliers)
+
+    board.play(Move.new("CAT", Position.new(0, 0), Direction::HORIZONTAL))
+    score, _ = board.play(Move.new("CATS", Position.new(0, 0), Direction::HORIZONTAL))
+
+    score.should eq(15)
+  end
+
+  it "scores word multipliers" do
+    values = { ?C => 2, ?A => 4, ?T => 8 }
+    word_multipliers = { Position.new(0, 0) => 2 }
+    board = Board.new(values, {}, word_multipliers)
+
+    score, _ = board.play(Move.new("CAT", Position.new(0, 0), Direction::HORIZONTAL))
+
+    score.should eq(28)
+  end
+
+  it "scores word multipliers in every word formed" do
+    values = Hash.new(1)
+    word_multipliers = { Position.new(1, 1) => 2 }
+    board = Board.new(values, {}, word_multipliers)
+
+    board.play(Move.new("CAT", Position.new(0, 0), Direction::HORIZONTAL))
+    score, _ = board.play(Move.new("TIN", Position.new(1, 1), Direction::HORIZONTAL))
+
+    score.should eq(12)
+  end
+
+  it "doesn't count word multipliers twice" do
+    values = { ?C => 2, ?A => 4, ?T => 8, ?S => 1 }
+    word_multipliers = { Position.new(0, 0) => 2 }
+    board = Board.new(values, {}, word_multipliers)
+
+    board.play(Move.new("CAT", Position.new(0, 0), Direction::HORIZONTAL))
+    score, _ = board.play(Move.new("CATS", Position.new(0, 0), Direction::HORIZONTAL))
+
+    score.should eq(15)
+  end
+
+  it "scores a 50 point bingo bonus" do
+    values = Hash.new(1)
+    board = Board.new(values)
+
+    score, _ = board.play(Move.new("RAMRODS", Position.new(0, 0), Direction::HORIZONTAL))
+
+    score.should eq(57)
+  end
+
+  it "only gives bingo bonus if 7 tiles are used" do
+    values = Hash.new(1)
+    board = Board.new(values)
+
+    board.play(Move.new("RAM", Position.new(0, 0), Direction::HORIZONTAL))
+    score, _ = board.play(Move.new("RAMRODS", Position.new(1, 0), Direction::HORIZONTAL))
+
+    score.should eq(7)
+  end
+end

data/spec/game_spec.rb

@@ -0,0 +1,164 @@
+require "player"
+require "board"
+require "move"
+require "position"
+require "pouch"
+require "not_random"
+
+describe "Game" do
+  def positions_for(*rows)
+    positions = {}
+    rows.each.with_index do |row, i|
+      row.each_char.with_index do |col, j|
+        unless col == " "
+          positions[Position.new(j, i)] = col.to_i
+        end
+      end
+    end
+    positions
+  end
+
+  # View Game: http://www.scrabble-assoc.com/games/nsc2000/1
+  # The game has fUZES scored incorrectly, but we get it right.
+  it "plays a whole game" do
+    tiles = %w{
+      G I N O O T T
+      A E O Q R S U
+      A I M N O T U
+      A E F G I T O
+      D E E I L P V
+      A A B L Y
+      A A D D O
+      E E R
+      A C E H U
+      F I P R W
+      M O U
+      E I J L N
+      E S
+      D I N O
+      H R Z
+      A C E K T T W
+      f I S
+      a N B
+      E G N X
+      L R V
+      R S Y
+      E I
+    }
+
+    values = {
+      ?A => 1,
+      ?B => 3,
+      ?C => 3,
+      ?D => 2,
+      ?E => 1,
+      ?F => 4,
+      ?G => 2,
+      ?H => 4,
+      ?I => 1,
+      ?J => 8,
+      ?K => 5,
+      ?L => 1,
+      ?M => 3,
+      ?N => 1,
+      ?O => 1,
+      ?P => 3,
+      ?Q => 10,
+      ?R => 1,
+      ?S => 1,
+      ?T => 1,
+      ?U => 1,
+      ?V => 4,
+      ?W => 4,
+      ?X => 8,
+      ?Y => 4,
+      ?Z => 10,
+      ?a => 0,
+      ?f => 0
+    }
+
+    letter_multipliers = positions_for(
+      "   2       2   ",
+      "     3   3     ",
+      "      2 2      ",
+      "2      2      2",
+      "               ",
+      " 3   3   3   3 ",
+      "  2   2 2   2  ",
+      "   2       2   ",
+      "  2   2 2   2  ",
+      " 3   3   3   3 ",
+      "               ",
+      "2      2      2",
+      "      2 2      ",
+      "     3   3     ",
+      "   2       2   "
+    )
+
+    word_multipliers = positions_for(
+      "3      3      3",
+      " 2           2 ",
+      "  2         2  ",
+      "   2       2   ",
+      "    2     2    ",
+      "               ",
+      "               ",
+      "3      2      3",
+      "               ",
+      "               ",
+      "    2     2    ",
+      "   2       2   ",
+      "  2         2  ",
+      " 2           2 ",
+      "3      3      3"
+    )
+
+    shuffle = NotRandom.new
+    board = Board.new(values, letter_multipliers, word_multipliers)
+    pouch = Pouch.new(tiles, shuffle)
+
+    p1_rack = []
+    p2_rack = []
+    p1 = Player.new(board, pouch, p1_rack)
+    p2 = Player.new(board, pouch, p2_rack)
+
+    moves = [
+      Move.new("TOOTING", Position.new(3, 7), Direction::HORIZONTAL),
+      Move.new("EQUATORS", Position.new(3, 3), Direction::VERTICAL),
+      Move.new("MOUNTAIN", Position.new(8, 4), Direction::VERTICAL),
+      Move.new("FOGIE", Position.new(7, 0), Direction::VERTICAL),
+      Move.new("LIVED", Position.new(7, 10), Direction::VERTICAL),
+      Move.new("BAA", Position.new(2, 8), Direction::VERTICAL),
+      Move.new("DOPED", Position.new(9, 1), Direction::VERTICAL),
+      Move.new("RELAY", Position.new(1, 5), Direction::VERTICAL),
+      Move.new("AHA", Position.new(0, 5), Direction::VERTICAL),
+      Move.new("PEWIT", Position.new(4, 10), Direction::VERTICAL),
+      Move.new("QUA", Position.new(3, 4), Direction::HORIZONTAL),
+      Move.new("FLINT", Position.new(0, 14), Direction::HORIZONTAL),
+      Move.new("MEOW", Position.new(1, 12), Direction::HORIZONTAL),
+      Move.new("REJOINED", Position.new(6, 13), Direction::HORIZONTAL),
+      Move.new("CHEZ", Position.new(12, 11), Direction::VERTICAL),
+      Move.new("WACKO", Position.new(5, 3), Direction::VERTICAL),
+      Move.new("fUZES", Position.new(10, 14), Direction::HORIZONTAL),
+      Move.new("BEN", Position.new(9, 9), Direction::VERTICAL),
+      Move.new("SEX", Position.new(10, 4), Direction::VERTICAL),
+      Move.new("VAR", Position.new(10, 8), Direction::VERTICAL),
+      Move.new("GYRO", Position.new(4, 1), Direction::HORIZONTAL),
+      Move.new("DEaLT", Position.new(9, 1), Direction::HORIZONTAL),
+      Move.new("SIR", Position.new(11, 5), Direction::VERTICAL),
+      Move.new("IT", Position.new(13, 0), Direction::HORIZONTAL)
+    ]
+
+    moves.each_slice(2) do |move1, move2|
+      p1.draw
+      p2.draw
+      p1.play(move1)
+      p2.play(move2)
+    end
+
+    p1_unplayed = values.values_at(*p1_rack).inject(0, :+)
+
+    p1.score.should eq(422)
+    (p2.score + p1_unplayed * 2).should eq(409)
+  end
+end

data/spec/player_spec.rb

@@ -0,0 +1,68 @@
+require "player"
+require "move"
+require "position"
+
+describe Player do
+  let(:board) { mock }
+  let(:pouch) { mock }
+
+  it "draws tiles from the pouch" do
+    rack = []
+    player = Player.new(board, pouch, rack)
+
+    pouch.stub(:draw).with(7).and_return(%w{A B C})
+    player.draw
+
+    rack.should eq(%w{A B C})
+  end
+
+  it "only draws the tiles needed" do
+    rack = %w{A B C}
+    player = Player.new(board, pouch, rack)
+
+    pouch.stub(:draw).with(4).and_return(%w{D E F})
+    player.draw
+
+    rack.should eq(%w{A B C D E F})
+  end
+
+  it "exchanges tiles with new ones from the pouch" do
+    rack = %w{A B C D E F G}
+    player = Player.new(board, pouch, rack)
+
+    pouch.stub(:exchange).with(%w{A B C}).and_return(%w{X Y Z})
+    player.exchange(%w{A B C})
+
+    rack.should eq(%w{D E F G X Y Z})
+  end
+
+  it "uses up tiles to make a move" do
+    rack = %w{A B C D E}
+    player = Player.new(board, pouch, rack)
+
+    board.stub(:play).and_return([1, %w{A C E}])
+    player.play(Move.new("", Position.new(0, 0), Direction::HORIZONTAL))
+
+    rack.should eq(%w{B D})
+  end
+
+  it "records her score" do
+    player = Player.new(board, pouch)
+    move = Move.new("CAT", Position.new(0, 0), Direction::HORIZONTAL)
+    board.stub(:play).with(move).and_return([1, []])
+
+    player.play(move)
+
+    player.score.should eq(1)
+  end
+  
+  it "add the scores of multiple plays" do
+    player = Player.new(board, pouch)
+    board.stub(:play).and_return([1, []])
+
+    player.play(Move.new("CAT", Position.new(0, 0), Direction::HORIZONTAL))
+    player.play(Move.new("COT", Position.new(0, 0), Direction::VERTICAL))
+
+    player.score.should eq(2)
+  end
+end

data/spec/pouch_spec.rb

@@ -0,0 +1,22 @@
+require "pouch"
+require "not_random"
+
+describe Pouch do
+  it "allows players to draw tiles" do
+    pouch = Pouch.new(%w{A B C D E F G}, NotRandom.new)
+
+    draw1 = pouch.draw(4)
+    draw2 = pouch.draw(4)
+
+    draw1.should eq(%w{A B C D})
+    draw2.should eq(%w{E F G})
+  end
+
+  it "allows players to exchange tiles" do
+    tiles = %w{A B C D E F G}
+    pouch = Pouch.new(tiles, NotRandom.new)
+
+    pouch.exchange(%w{X Y Z}).should eq(%w{A B C})
+    tiles.should eq(%w{D E F G X Y Z})
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: nerdword
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Tom von Schwerdtner
+- Nestor Walker
+- Eric Ostrich
+- Sam Goldman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Play crossword games with your friends.
+email:
+- dev@smartlogicsolutions.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/board.rb
+- lib/direction.rb
+- lib/move.rb
+- lib/not_random.rb
+- lib/player.rb
+- lib/position.rb
+- lib/pouch.rb
+- spec/board_spec.rb
+- spec/game_spec.rb
+- spec/player_spec.rb
+- spec/pouch_spec.rb
+homepage: http://github.com/smartlogic/nerdword
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Get nerdy... with words!
+test_files:
+- spec/board_spec.rb
+- spec/game_spec.rb
+- spec/player_spec.rb
+- spec/pouch_spec.rb