boggle 0.0.2

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/*
+*.gem
+.bundle
+.DS_Store

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in trails.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2011 Kirk Scheibelhut <kjs@scheibo.com>
+
+Permission  is  hereby granted, free of charge, to any person ob-
+taining a copy of  this  software  and  associated  documentation
+files  (the "Software"), to deal in the Software without restric-
+tion, including without limitation the rights to use, copy, modi-
+fy, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is  fur-
+nished to do so, subject to the following conditions:
+
+The  above  copyright  notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF  ANY  KIND,
+EXPRESS  OR  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE  AND  NONIN-
+FRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER  IN  AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN  THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,43 @@
+# Boggle
+
+Very dirty program to let you play 4x4 boggle and learn new words. Has the following options:
+
+		opts = Trollop::options do
+		  opt :define, "Show a definition dump at the end", :short => 'd'
+		  opt :interactive, "Continue printing games", :short => 'i'
+		  opt :dictionary, "Change the default dictionary", :default => 'dicts/just_words.dict'
+		  opt :board, "Give a string as input to be the board", :default => ""
+		end
+
+Where `--interactive` has yet to be implemented, but the idea behind if would be that instead of loading up a dict each time you could continue to play with the same dictionary. Has no timer going on right now, just use a watch to time the three minutes. Use 'XYZZY' to exit any prompt (TODO: should be control-D or something as well).
+
+As it stands, with a full scrabble dictionary load (dicts/osw.txt) it takes about 2.6 seconds to load up on
+
+	Darwin mac.local 10.6.0 Darwin Kernel Version 10.6.0: Wed Nov 10 18:13:17 PST 2010; root:xnu-1504.9.26~3/RELEASE_I386 i386
+
+with intel core 2 duo 2.4ghz. It takes about 200MB of ram to load the dictionary into memory. With this dictionary a given board takes around 0.14 seconds to solve (same specs). 'just_words' only has around 40k words as opposed to 260k, so it ends up being considerably faster. There are some ways to optimize the solving, but at 0.14 seconds thats not really the problem, the problem is the loading which even then isn't *horrid*.
+
+## Usage
+
+Not actually a gem, just
+
+    git clone git://github.com/scheibo/boggle.git
+    cd boggle
+    ./boggle
+
+## Future
+
+- timer (3 min countdown)
+- interactive mode (save loading the dict)
+- Ctrl+D to exit
+
+## Copyright
+
+Hopefully Parker Brothers (Hasbro) isn't going to get mad I've recreated their game. All copyright, trademarks, etc belong to them.
+
+All the dictionaries are property of whoever compiled them, and hopefully I'm not breaking any copyright by including them in this program (I just took most of them off of [wordlists.sourceforge.com](http://wordlists.sourceforge.com)).
+
+As for the code to the game itself:
+
+`boggle` is Copyright (c) 2011 [Kirk Scheibelhut](http://scheibo.com/about) and distributed under the MIT license.<br />
+See the `LICENSE` file for further details regarding licensing and distribution.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/boggle

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+lib = File.expand_path('../../lib', __FILE__)
+$:.unshift(lib) if File.directory?(lib) && !$:.include?(lib)
+
+require 'boggle'
+require 'optparse'
+
+opts = {}
+ARGV.options do |argv|
+  argv.banner = "Usage: boggle [options]"
+  argv.on("-d", "--define", "Show a definition dump at the end") { |d| opts[:define] = d }
+  argv.on("--dictionary", String, "Change the default dictionary") { |dict| opts[:dictionary] = dict }
+  argv.on("-b", "--board", String, "Give a string as input to be the board") { |b|  opts[:board] = b }
+  argv.on("-v", "--variant", Integer, "Give the board variant") { |v| opts[:variant] = v  }
+  argv.on("-s", "--size", Integer, "Give the size of the board to use") { |s| opts[:size] = s }
+end
+
+opts = {:dictionary => "system.dict", :board => "", :variant => 0, :size => 4}.merge opts
+opts[:size] = Math.sqrt(opts[:board].size).to_i if !opts[:board].empty?
+Boggle::Game.new(Boggle::Board.new(opts), opts).start

data/boggle.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "boggle/version"
+
+Gem::Specification.new do |s|
+  s.name        = "boggle"
+  s.version     = Boggle::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Kirk Scheibelhut"]
+  s.email       = ["kjs@scheibo.com"]
+  s.homepage    = "https://github.com/scheibo/boggle"
+  s.summary     = "Boggle CLI app which helps improve your game"
+  s.description = s.summary
+
+  s.rubyforge_project = "boggle"
+
+  s.add_dependency "algorithms"
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "bundler", "~> 1.0.0"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.default_executable = 'boggle'
+  s.require_paths = ["lib"]
+end

data/lib/boggle.rb

@@ -0,0 +1,7 @@
+module Boggle; end
+
+require 'boggle/version'
+require 'boggle/trie'
+require 'boggle/solver'
+require 'boggle/game'
+require 'boggle/board'

data/lib/boggle/board.rb

@@ -0,0 +1,121 @@
+class Boggle::Board
+  attr_reader :size
+
+  def initialize(opts={})
+    @size = opts[:size]
+    if opts[:board].empty?
+      letters = Boggle::Board.distributions(@size, opts[:variant]).sort_by{ rand }.map { |d| d.sample }
+    else
+      letters = letters_from_string opts[:board]
+    end
+
+    @board = []
+    @size.times do
+      @board << letters.pop(@size)
+    end
+  end
+
+  def to_s
+    s = ""
+    @size.times { s<<"+"; s<<"-"*3 }; s<<"+\n"
+    @size .times do |row|
+      s << "|"
+      @size.times do |col|
+        (l=@board[row][col]) == "Qu" ? s << " #{l}|" : s << " #{l} |"
+      end
+      s<<"\n"; @size.times { s<<"+"; s<<"-"*3 }; s<<"+\n"
+    end
+    s
+  end
+
+  def [](row, col)
+    ( (row < 0) || (col < 0) || (row >= @size) || (col >= @size) ) ? nil : @board[row][col]
+  end
+
+  # deepcopy first
+  def []=(row, col, val)
+    @board[row][col]=val
+  end
+
+  def deepcopy
+    Marshal.load( Marshal.dump(self) )
+  end
+
+  def self.distributions( size, variant ) # 4,0 gives standard distrubtion
+
+    distros = [[
+      # http://everything2.com/title/Boggle
+      %w{
+        ASPFFK NUIHMQ OBJOAB LNHNRZ
+        AHSPCO RYVDEL IOTMUC LREIXD
+        TERWHV TSTIYD WNGEEH ERTTYL
+        OWTOAT AEANEG EIUNES TOESSI
+      },
+
+      # http://www.boardgamegeek.com/thread/300565/review-from-a-boggle-veteran-and-beware-differen
+      %w{
+        AAEEGN ELRTTY AOOTTW ABBJOO
+        EHRTVW CIMOTV DISTTY EIOSST
+        DELRVY ACHOPS HIMNQU EEINSU
+        EEGHNW AFFKPS HLNNRZ DEILRX
+      },
+
+      %w{
+        AACIOT AHMORS EGKLUY ABILTY
+        ACDEMP EGINTV GILRUW ELPSTU
+        DENOSW ACELRS ABJMOQ EEFHIY
+        EHINPS DKNOTU ADENVZ BIFORX
+      }
+    ],[
+
+      # http://boardgamegeek.com/thread/300883/letter-distribution
+      %w{
+        aaafrs aaeeee aafirs adennn aeeeem
+        aeegmu aegmnn afirsy bjkqxz ccenst
+        ceiilt ceilpt ceipst ddhnot dhhlor
+        dhlnor dhlnor eiiitt emottt ensssu
+        fiprsy gorrvw iprrry nootuw ooottu
+      }.map(&:upcase),
+
+      %w{
+        AAAFRS	AAEEEE	AAFIRS	ADENNN	AEEEEM
+        AEEGMU	AEGMNN	AFIRSY	BJKQXZ	CCNSTW
+        CEIILT	CEILPT	CEIPST	DHHNOT	DHHLOR
+        DHLNOR	DDLNOR	EIIITT	EMOTTT	ENSSSU
+        FIPRSY	GORRVW	HIPRRY	NOOTUW	OOOTTU
+      }
+    ]]
+
+    min_size = 4
+    distros[size-min_size].map { |dist|
+      dist.map { |die|
+        die.split(//).map { |letter|
+          # our distrubutions return Qu, not Q's
+          letter == 'Q' ? 'Qu' : letter
+        }
+      }
+    }[variant]
+  end
+
+  private
+
+  def letters_from_string(string)
+    letters = []
+    row = []
+    string.each_char do |c|
+      if c == "Q"
+        row << "Qu"
+      elsif c == "u"
+        row
+      else
+        row << c
+      end
+      if row.size == @size
+        letters << row
+        row = []
+      end
+    end
+    letters.reverse.flatten
+  end
+
+end

data/lib/boggle/game.rb

@@ -0,0 +1,165 @@
+$:.unshift(File.dirname(__FILE__) + '/../boggle')
+
+require 'zlib'
+require 'trie'
+
+class Boggle::Game
+
+  def self.create_dictionary(file_name)
+    trie = Boggle::Trie.new
+    File.open(file_name).each_line do |line|
+      idx = line.index " " # get first space
+      if idx.nil? # no definition
+        word, defn = line, "no definition available"
+      else
+        word, defn = line[0..idx-1], line[idx+1..line.size]
+      end
+      #word.chomp! # case where we had just words on the line
+
+      # skip words that are too small for boggle
+      if word.size > 2
+        trie[word.upcase] = defn
+      end
+    end
+
+    dump = Marshal.dump(trie)
+    dict_file = File.new(File.expand_path("../../../dicts/#{file_name.chomp('.txt')}.dict", __FILE__), "w")
+    dict_file = Zlib::GzipWriter.new(dict_file)
+    dict_file.write dump
+    dict_file.close
+  end
+
+  def initialize(board=nil, opts=nil)
+    if ! board.nil?
+      @board = board
+    else
+      @board = Boggle::Board.new
+    end
+    @opts = opts
+    @words = []
+    @trie = Boggle::Trie.new
+  end
+
+  def start
+    dict = @opts[:dictionary]
+    fill_trie(dict) # need to only load this once
+    s = Boggle::Solver.new(@trie)
+    @found_pairs = s.start(@board)
+
+    display
+
+    good = []
+    bad = []
+    @words.uniq.each do |w|
+      if @found_pairs.delete w
+        good << w
+      else
+        bad << w
+      end
+    end
+
+    finish good, bad
+  end
+
+  private
+
+  def score(words)
+    words.reduce(0) { |a,w| a+score_word(w) }
+  end
+
+  def finish(good, bad)
+    puts "Your score was: #{score(good)}"
+    puts "The following words were bad:"
+    bad.each { |b| print "#{b} " }
+    puts
+
+    puts "You missed the following words"
+    dump_words
+ end
+
+  def dump_words
+    already_done = []
+    words = []
+    @found_pairs.keys.sort.each do |word|
+      if @found_pairs.include? word+"S"
+        words << [word, "#{word}(S)"]
+        already_done << word+"S"
+      else
+        words << [word, word] unless already_done.include? word
+      end
+    end
+
+    # now we need to make our groups
+    groups =[[],[],[],[],[],[]] # 3, 4, 5, 6, 7, 8+
+    words.sort_by { |e| e.first.size }.each do |pk|
+      case pk[0].size
+        when 3 then groups[0] << pk[1]
+        when 4 then groups[1] << pk[1]
+        when 5 then groups[2] << pk[1]
+        when 6 then groups[3] << pk[1]
+        when 7 then groups[4] << pk[1]
+        else        groups[5] << pk[1]
+      end
+    end
+
+    puts
+    groups.each do |group|
+      break_after = 0
+      group.each do |rep|
+        print "#{rep} "
+        break_after+=rep.size
+        if break_after > 80
+          print "\n"
+          break_after = 0
+        end
+      end
+      print "\n\n" unless group.empty?
+    end
+
+    if @opts[:define]
+      @found_pairs.keys.sort.each { |word| puts "#{word}: #{@found_pairs[word]}" }
+    else
+
+      while true
+        print "Define: "
+        word = STDIN.gets.chomp.upcase
+        if word == "XYZZY"
+          break
+        else
+          puts "#{word}: #{@trie[word]}"
+        end
+      end
+
+    end
+  end
+
+  def display
+    puts @board
+    while true
+      word = STDIN.gets.chomp.upcase
+      if word == "XYZZY"
+        break
+      else
+        @words << word
+      end
+    end
+    puts "Finished, you put down #{@words.size} words"
+  end
+
+  def fill_trie(file_name)
+    file = Zlib::GzipReader.open(File.expand_path("../../../dicts/#{file_name}", __FILE__))
+    @trie = Marshal.load file.read
+    file.close
+  end
+
+  def score_word(word)
+    case word.size
+      when 0,1,2 then 0
+      when 3,4 then 1
+      when 5 then 2
+      when 6 then 3
+      when 7 then 5
+      else 11
+    end
+ end
+end

data/lib/boggle/solver.rb

@@ -0,0 +1,83 @@
+$:.unshift(File.dirname(__FILE__) + '/../boggle')
+require 'trie'
+require 'game'
+
+class Boggle::Solver
+
+   def initialize(trie)
+     @found_words = {} # going to use it like a set
+     @trie = trie
+   end
+
+   def in_trie?(prefix)
+     if (d = @trie.match(prefix.upcase)) # not nil = okay
+       if d.class == String
+         @found_words[prefix] = d
+       end
+       true
+     end
+   end
+
+   def start(board)
+     solve board
+     @found_words
+   end
+
+   def solve(board)
+     board.size.times do |row|
+       board.size.times do |col|
+         solve_frame(make_frame("", board, row, col))
+       end
+     end
+   end
+
+   private
+
+   def make_frame(prefix, board, row, col)
+     frame = []
+     frame << (prefix + board[row,col])
+     new_board = board.deepcopy
+     new_board[row,col] = nil
+     frame << new_board
+     frame << row << col
+     frame
+   end
+
+   def solve_frame(frame)
+     next_frames(frame).each do |f|
+       prefix, b, r, c = f
+
+       if in_trie? prefix
+          # continue
+          solve_frame(f)
+       end
+       # otherwise we're at a dead end!, ignore the frame
+       # and continue to the other ones
+     end
+   end
+
+   def next_frames(frame)
+     # unpack
+     pre, board, row, col = frame
+
+     frames = []
+     # row before
+     frames << (board[row-1, col-1] && make_frame(pre, board, row-1, col-1))
+     frames << (board[row-1, col  ] && make_frame(pre, board, row-1, col  ))
+     frames << (board[row-1, col+1] && make_frame(pre, board, row-1, col+1))
+
+     # same row
+     frames << (board[row  , col-1] && make_frame(pre, board, row  , col-1))
+     # frames << (board[row  , col  ] && make_frame(pre, board, row, col  ))
+     # is guaranteed to be nil, since at row,col we are empty
+     frames << (board[row  , col+1] && make_frame(pre, board, row  , col+1))
+
+     # row after
+     frames << (board[row+1, col-1] && make_frame(pre, board, row+1, col-1))
+     frames << (board[row+1, col  ] && make_frame(pre, board, row+1, col  ))
+     frames << (board[row+1, col+1] && make_frame(pre, board, row+1, col+1))
+
+     frames.compact
+   end
+
+ end

data/lib/boggle/trie.rb

@@ -0,0 +1,36 @@
+require 'algorithms'
+
+class Boggle::Trie < Containers::Trie
+
+  # returns either nil if there is nothing along that path, true
+  # if that path exists in the tree and the word itself if it is an endpoint
+
+  def match(string)
+    string = string.to_s
+    return nil if string.empty?
+    match_recursive(@root, string, 0)
+  end
+
+  def match_recursive(node, string, index)
+    return nil if node.nil?
+
+    char = string[index]
+
+    if (char < node.char)
+      match_recursive(node.left, string, index)
+    elsif (char > node.char)
+      match_recursive(node.right, string, index)
+    else
+      return nil if node.nil?
+      if index == (string.length - 1)
+        if node.last?
+          return node.value
+        else
+          return true
+        end
+      end
+      match_recursive(node.mid, string, index+1)
+    end
+  end
+
+end

data/lib/boggle/version.rb

@@ -0,0 +1,3 @@
+module Boggle
+  VERSION = "0.0.2"
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: boggle
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Kirk Scheibelhut
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-22 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: algorithms
+  requirement: &70186838444600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70186838444600
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70186838475640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70186838475640
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70186838475140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70186838475140
+description: Boggle CLI app which helps improve your game
+email:
+- kjs@scheibo.com
+executables:
+- boggle
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/boggle
+- boggle.gemspec
+- dicts/default.dict
+- dicts/scrabble.dict
+- dicts/system.dict
+- dicts/wls.tar.gz
+- lib/boggle.rb
+- lib/boggle/board.rb
+- lib/boggle/game.rb
+- lib/boggle/solver.rb
+- lib/boggle/trie.rb
+- lib/boggle/version.rb
+homepage: https://github.com/scheibo/boggle
+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: boggle
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Boggle CLI app which helps improve your game
+test_files: []