linotype 0.0.1

data/lib/linotype/game.rb

@@ -0,0 +1,107 @@
+module Linotype
+  class Game
+        
+    def initialize
+      @board = Board.new_random(self)
+      @players = [Player.new, Player.new]
+      @current_player = @players[0]
+      @moves = []
+    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
+      end
+      @moves << move
+      @current_player == move.player ? false : true
+    end
+
+    def over?
+      uncovered_tiles.empty? || two_passes_in_a_row?
+    end
+    
+    def winner
+      scores.inject(nil) { |winner, p| p[1] > winner.to_i ? p[0] : winner } if over?
+    end
+
+    def scores
+      @players.inject({}) { |scores, player| scores[player_number(player)] = score(player); scores }
+    end
+
+    def board
+      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
+    
+    def score(player)
+      covered_tiles(player).count
+    end
+
+    def valid_moves
+      @moves.select(&:valid?)
+    end
+    
+    def invalid_moves
+      @moves.select(&:invalid?)
+    end
+    
+    def dictionary
+      Linotype::Dictionary.loaded
+    end
+
+    def tile_rows
+      @board.tiles
+    end
+
+    def letters
+      @board.tiles.flatten.collect(&:letter)
+    end
+
+    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]]
+        raise ArgumentError, "The board does not have a tile at that location" unless tile
+        tile
+      end
+    end
+    private :find_tiles
+    
+    def toggle_current_player
+      @current_player = other_player
+    end
+    private :toggle_current_player
+    
+    def uncovered_tiles
+      covered_tiles(nil)
+    end
+    private :uncovered_tiles
+    
+    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
+    end
+    private :two_passes_in_a_row?
+    
+  end
+end

data/lib/linotype/move.rb

@@ -0,0 +1,84 @@
+module Linotype
+  class Move
+    
+    attr_reader :game, :player, :invalid_reason
+    
+    def initialize(game, player, tiles)
+      @game = game
+      @player = player
+      @tiles = tiles
+      calculate_valid
+    end
+       
+    def valid?
+      !!@valid
+    end
+    
+    def invalid?
+      !valid?
+    end
+    
+    def word
+      @tiles.collect(&:letter).join
+    end
+    
+    def pass?
+      @tiles.empty?
+    end
+    
+    def cover_tiles!
+      @tiles.each { |tile| tile.covered_by = @player unless tile.defended? }
+    end
+    
+    def to_hash
+      {
+        player: game.player_number(@player),
+        word: word,
+        valid: valid?,
+        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
+      }
+    end
+        
+    def calculate_valid
+      if pass?
+        @valid = true
+      elsif !uses_game_tiles?
+        @invalid_reason = "does not use game tile letters"
+      elsif !in_dictionary?
+        @invalid_reason = "is not in dictionary"
+      elsif !new_word_in_game?
+        @invalid_reason = "has been played before"
+      elsif !enough_characters?
+        @invalid_reason = "is too short"
+      elsif prefix_of_previous_word?
+        @invalid_reason = "is a prefix of a previously played word"
+      else
+        @valid = true
+      end
+    end
+        
+    def in_dictionary?
+      game.dictionary.valid?(word)
+    end
+    
+    def uses_game_tiles?
+      letters = game.letters
+      word.each_char { |letter| return false unless letters.delete(letter) }
+    end
+    
+    def new_word_in_game?
+      !game.valid_moves.collect(&:word).include?(word)
+    end
+    
+    def enough_characters?
+      word.length >= 2
+    end
+    
+    def prefix_of_previous_word?
+      game.valid_moves.find { |move| move.word =~ /\A#{word}/ }
+    end
+                
+  end
+end

data/lib/linotype/player.rb

@@ -0,0 +1,5 @@
+module Linotype
+  class Player
+    
+  end
+end

data/lib/linotype/tile.rb

@@ -0,0 +1,63 @@
+module Linotype
+  class Tile
+    
+    attr_accessor :covered_by
+    attr_reader :letter
+    
+    def initialize(board, letter=random_letter)
+      @board = board
+      @letter = letter
+    end
+    
+    def to_hash
+      {
+        letter:     @letter,
+        row:        row,
+        column:     column,
+        covered_by: (game.player_number(covered_by) if covered_by),
+        defended:   defended?
+      }
+    end
+    
+    def game
+      @board.game
+    end
+    
+    def random_letter
+      ('A'..'Z').to_a[rand(0..25)]
+    end
+    
+    def row
+      @row ||= @board.row(self)
+    end
+    
+    def column
+      @column ||= @board.column(self)
+    end
+    
+    def previous?(coordinate_type)
+      send(coordinate_type) > 0
+    end
+    
+    def next?(coordinate_type)
+      send(coordinate_type) < @board.send("#{coordinate_type}_count") - 1
+    end
+    
+    def adjacent_tiles
+      @adjacent_tiles ||= calculate_adjacent_tiles
+    end
+        
+    def defended?
+      adjacent_tiles.select { |tile| tile.covered_by == covered_by && covered_by }.count == adjacent_tiles.count
+    end
+    
+    def calculate_adjacent_tiles
+      @adjacent_tiles = []
+      @adjacent_tiles << @board.tiles[row - 1][column] if previous?(:row)
+      @adjacent_tiles << @board.tiles[row + 1][column] if next?(:row)
+      @adjacent_tiles << @board.tiles[row][column - 1] if previous?(:column)
+      @adjacent_tiles << @board.tiles[row][column + 1] if next?(:column)
+      @adjacent_tiles
+    end
+  end
+end

data/lib/linotype/version.rb

@@ -0,0 +1,3 @@
+module Linotype
+  VERSION = "0.0.1"
+end

data/lib/linotype.rb

@@ -0,0 +1,11 @@
+require "linotype/version"
+require "linotype/game"
+require "linotype/board"
+require "linotype/move"
+require "linotype/player"
+require "linotype/tile"
+require "linotype/dictionary/dictionary"
+
+module Linotype
+      
+end

data/linotype.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'linotype/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "linotype"
+  gem.version       = Linotype::VERSION
+  gem.authors       = ["Sean Devine"]
+  gem.email         = ["barelyknown@icloud.com"]
+  gem.description   = <<-eos
+  linotype is a small program that implements that game mechanic of Letterpress for iOS by atebits software http://www.atebits.com/letterpress/ The program was written to support the automation of letterpress gameplay and to power command line or web-based versions of the game. It was inspired by a tweet by Andy Baio about cheating in letterpress. https://twitter.com/waxpancake/statuses/261966416507465728 The game uses the words file comes with Mac OS X, but any word file can be used.
+  eos
+  gem.summary       = %q{Small ruby program that implements the game mechanic of the letterpress iOS game.}
+  gem.homepage      = "https://github.com/barelyknown/linotype"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: linotype
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Sean Devine
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-28 00:00:00.000000000 Z
+dependencies: []
+description: ! '  linotype is a small program that implements that game mechanic of
+  Letterpress for iOS by atebits software http://www.atebits.com/letterpress/ The
+  program was written to support the automation of letterpress gameplay and to power
+  command line or web-based versions of the game. It was inspired by a tweet by Andy
+  Baio about cheating in letterpress. https://twitter.com/waxpancake/statuses/261966416507465728
+  The game uses the words file comes with Mac OS X, but any word file can be used.
+
+'
+email:
+- barelyknown@icloud.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/linotype.rb
+- lib/linotype/board.rb
+- lib/linotype/dictionary/dictionary.rb
+- lib/linotype/dictionary/words.txt
+- lib/linotype/game.rb
+- lib/linotype/move.rb
+- lib/linotype/player.rb
+- lib/linotype/tile.rb
+- lib/linotype/version.rb
+- linotype.gemspec
+homepage: https://github.com/barelyknown/linotype
+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.24
+signing_key: 
+specification_version: 3
+summary: Small ruby program that implements the game mechanic of the letterpress iOS
+  game.
+test_files: []