rbot 0.9.14 → 0.9.15

data/data/rbot/plugins/digg.rb

@@ -9,7 +9,7 @@ class DiggPlugin < Plugin
   def help(plugin, topic="")
     "digg [<max>=5] => show digg headlines, [<max>=5] => return up to <max> headlines (use a negative number to show all the headlines on one line)"
   end
-  
+
   def digg(m, params)
     max = params[:limit].to_i
     debug "max is #{max}"
@@ -32,11 +32,11 @@ class DiggPlugin < Plugin
     max = 8 if max > 8
     matches = Array.new
     doc.elements.each("rss/channel/item") {|e|
-      matches << [ e.elements["title"].text, 
+      matches << [ e.elements["title"].text,
                    Time.parse(e.elements["pubDate"].text).strftime('%a @ %I:%M%p') ]
       done += 1
       break if done >= max
-    } 
+    }
     if oneline
       m.reply matches.collect{|mat| mat[0]}.join(" | ")
     else

data/data/rbot/plugins/eightball.rb

@@ -10,7 +10,7 @@ class EightBallPlugin < Plugin
   end
   def eightball(m, params)
     answers = @answers[rand(@answers.length)]
-    action = "shakes the magic 8-ball... #{answers}"
+    action = "shakes the magic 8-ball for #{m.source} ... #{answers}"
     @bot.action m.replyto, action
   end
 end

data/data/rbot/plugins/factoids.rb

@@ -120,7 +120,7 @@ class FactoidsPlugin < Plugin
     super
 
     # TODO config
-    @dir = File.join(@bot.botclass,"factoids")
+    @dir = datafile
     @filename = "factoids.rbot"
     @factoids = FactoidList.new
     @triggers = Set.new
@@ -341,7 +341,7 @@ class FactoidsPlugin < Plugin
     if params[:words].nil_or_empty? and params[:rx].nil_or_empty?
       m.reply _("I know %{total} facts" % { :total => total })
     else
-      if params[:words].empty?
+      unless params.key? :words and not params[:words].empty?
         rx = Regexp.new(params[:rx].to_s, true)
       else
         rx = words2rx(params[:words])
@@ -349,7 +349,11 @@ class FactoidsPlugin < Plugin
       known = @factoids.grep(rx)
       reply = []
       if known.empty?
-        reply << _("I know nothing about %{words}" % params)
+        if params.key? :words
+          reply << _("I know nothing about %{words}" % params)
+        else params.key? :rx
+          reply << _("I know nothing matching %{rx}" % params)
+        end
       else
         max_facts = @bot.config['factoids.search_results']
         len = known.length
@@ -379,7 +383,12 @@ class FactoidsPlugin < Plugin
       return if @triggers.empty?
       query = $1.strip.downcase
       if @triggers.include?(query)
-        facts(m, :words => query.split)
+        words = query.split
+        words.instance_variable_set(:@string_value, query)
+        def words.to_s
+          @string_value
+        end
+        facts(m, :words => words)
       end
     else
       return if m.address? # we don't learn stuff directed at us which is not an explicit learn command

data/data/rbot/plugins/figlet.rb

@@ -58,10 +58,10 @@ class FigletPlugin < Plugin
 
   def test_figlet
     #check that figlet is present
-    @has[:figlet] = !!(Utils.safe_exec("#{figlet_path} -v") ; $?)
+    @has[:figlet] = Utils.try_exec("#{figlet_path} -v")
 
     # check that figlet actually has the font installed
-    @has[:figlet_font] = !!(Utils.safe_exec("#{figlet_path} -f #{figlet_font} test test test") ; $?)
+    @has[:figlet_font] = Utils.try_exec("#{figlet_path} -f #{figlet_font} test test test")
 
     # set the commandline params
     @params[:figlet] = ['-k', '-w', MAX_WIDTH.to_s, '-C', 'utf8']
@@ -72,10 +72,10 @@ class FigletPlugin < Plugin
 
   def test_toilet
     #check that toilet is present
-    @has[:toilet] = !!(Utils.safe_exec("#{toilet_path} -v") ; $?)
+    @has[:toilet] = Utils.try_exec("#{toilet_path} -v")
 
     # check that toilet actually has the font installed
-    @has[:toilet_font] = !!(Utils.safe_exec("#{toilet_path} -f #{toilet_font} test test test") ; $?)
+    @has[:toilet_font] = Utils.try_exec("#{toilet_path} -f #{toilet_font} test test test")
 
     # set the commandline params
     @params[:toilet] = ['-k', '-w', MAX_WIDTH.to_s, '-E', 'utf8', '--irc']

data/data/rbot/plugins/forecast.rb

@@ -8,7 +8,7 @@
 
 require 'soap/wsdlDriver'
 # TODO why not use HttpUtil instead of open-uri?
-require 'open-uri' 
+require 'open-uri'
 require 'rexml/document'
 require 'erb'
 
@@ -48,7 +48,7 @@ class Forecast
         return parse(retrieve),Time.new
     end
 private
-    def retrieve 
+    def retrieve
         forecast = @forecaster.NDFDgenByDay(
             @lat,@long,Time.now.strftime("%Y-%m-%d"),2,"24 hourly")
         (REXML::Document.new(forecast)).root
@@ -105,7 +105,7 @@ class ForecastPlugin < Plugin
             end
         end
     end
-    
+
     def get_forecast(m,loc)
       begin
         @cache_mutex.synchronize do

data/data/rbot/plugins/fortune.rb

@@ -7,14 +7,17 @@ class FortunePlugin < Plugin
   Config.register Config::StringValue.new('fortune.path',
     :default => '',
     :desc => "Full path to the fortune executable")
+  Config.register Config::ArrayValue.new('fortune.options',
+    :default => ['-n', '350', '-s'],
+    :desc => "Options to be passed on to fortune")
 
   def help(plugin, topic="")
     "fortune [<category>] => get a (short) fortune, optionally specifying fortune category || fortune categories => show categories"
   end
 
-  def find_fortune
+  def find_fortune(m)
     fortune = @bot.config['fortune.path']
-    return fortune if fortune
+    return fortune if fortune and not fortune.empty?
 
     ["/usr/bin/fortune",
      "/usr/share/bin/fortune",
@@ -28,7 +31,7 @@ class FortunePlugin < Plugin
     end
 
     return nil unless fortune
-      
+
     # Try setting the config entry
     config_par = {:key => 'fortune.path', :value => [fortune], :silent => true }
     debug "Setting fortune.path to #{fortune}"
@@ -44,12 +47,15 @@ class FortunePlugin < Plugin
 
   ## Pick a fortune
   def fortune(m, params)
-    db = params[:db]
-    fortune = find_fortune
+    fortune = find_fortune(m)
     m.reply "fortune executable not found (try setting the 'fortune.path' variable)" unless fortune
 
+    command = [fortune] + @bot.config['fortune.options']
+    command << params[:db]
+    command.compact!
+
     begin
-      ret = Utils.safe_exec(fortune, "-n", "350", "-s", db)
+      ret = Utils.safe_exec(*command)
 
       ## cleanup ret
       ret = ret.split(/\n+/).map do |l|
@@ -75,7 +81,7 @@ class FortunePlugin < Plugin
 
   # Print the fortune categories
   def categories(m, params)
-    fortune = find_fortune
+    fortune = find_fortune(m)
     m.reply "fortune executable not found (try setting the 'fortune.path' variable)" unless fortune
 
     ## list all fortune databases
@@ -88,7 +94,7 @@ class FortunePlugin < Plugin
     ## say 'em!
     m.reply "Fortune categories: #{categories.join ', '}"
   end
- 
+
 end
 plugin = FortunePlugin.new
 plugin.map 'fortune categories', :action => "categories"

data/data/rbot/plugins/freshmeat.rb

@@ -88,7 +88,7 @@ class FreshmeatPlugin < Plugin
       m.reply reply
     }
   end
-  
+
   def freshmeat(m, params)
     max = params[:limit].to_i
     max = 8 if max > 8
@@ -134,5 +134,5 @@ end
 plugin = FreshmeatPlugin.new
 plugin.map 'freshmeat search :limit *search', :action => 'search_freshmeat',
             :defaults => {:limit => 4}, :requirements => {:limit => /^\d+$/}
-plugin.map 'freshmeat :limit', :defaults => {:limit => 4}, 
+plugin.map 'freshmeat :limit', :defaults => {:limit => 4},
                                :requirements => {:limit => /^\d+$/}

data/data/rbot/plugins/games/azgame.rb

@@ -35,6 +35,34 @@ class AzGame
     def @range.to_s
       return "%s -- %s" % self
     end
+    if @rules[:list]
+      @check_method = "is_#{@rules[:addlang]}?"
+      # trick: if addlang was not in rules, this will be is_? which is
+      # not a method of the plugin
+      if @check_method and not @plugin.respond_to? @check_method
+        @check_method = nil
+      end
+      @check = Proc.new do |w|
+        wl = @rules[:list].include?(w)
+        if !wl and @check_method
+          if wl = @plugin.send(@check_method, w)
+            debug "adding #{w} to #{@rules[:addfile]}"
+            begin
+              File.open(@rules[:addfile], "a") do |f|
+                f.puts w
+              end
+            rescue Exception => e
+              error "failed to add #{w} to #{@rules[:addfile]}"
+              error e
+            end
+          end
+        end
+        wl
+      end
+    else
+      @check_method = "is_#{@lang}?"
+      @check = Proc.new { |w| @plugin.send(@check_method, w) }
+    end
   end
 
   def check(word)
@@ -47,7 +75,7 @@ class AzGame
     return [:out, @range] if w < @range.first or w > @range.last
     return [:ignore, @range] if w == @range.first or w == @range.last
     # This is potentially slow (for languages that check online)
-    return [:noexist, @range] unless @plugin.send("is_#{@lang}?", w)
+    return [:noexist, @range] unless @check.call(w)
     debug "we like it"
     # Check again if there was a winner in the mean time,
     # and bail out if there was
@@ -122,21 +150,36 @@ class AzGamePlugin < Plugin
     },
     }
 
-    japanese_wordlist = "#{@bot.botclass}/azgame/wordlist-japanese"
-    if File.exist?(japanese_wordlist)
-      words = File.readlines(japanese_wordlist) \
-                             .map {|line| line.strip} .uniq
+    @autoadd_base = datafile "autoadd-"
+  end
+
+  def initialize_wordlist(params)
+    lang = params[:lang]
+    addlang = params[:addlang]
+    autoadd = @autoadd_base + addlang.to_s
+    if Wordlist.exist?(lang)
+      # wordlists are assumed to be UTF-8, but we need to strip the BOM, if present
+      words = Wordlist.get(lang)
+      if addlang and File.exist?(autoadd)
+        word += File.readlines(autoadd).map {|line| line.sub("\xef\xbb\xbf",'').strip}
+      end
+      words.uniq!
+      words.sort!
       if(words.length >= 4) # something to guess
-        @rules[:japanese] = {
+        rules = {
             :good => /^\S+$/,
             :list => words,
             :first => words[0],
             :last => words[-1],
+            :addlang => addlang,
+            :addfile => autoadd,
             :listener => /^\S+$/
         }
-        debug "Japanese wordlist loaded, #{@rules[:japanese][:list].length} lines; first word: #{@rules[:japanese][:first]}, last word: #{@rules[:japanese][:last]}"
+        debug "#{lang} wordlist loaded, #{rules[:list].length} lines; first word: #{rules[:first]}, last word: #{rules[:last]}"
+        return rules
       end
     end
+    return false
   end
 
   def save
@@ -233,12 +276,20 @@ class AzGamePlugin < Plugin
           m.reply _("couldn't think of anything ...")
           return
         end
+        m.reply _("got it!")
+        @games[k] = AzGame.new(self, lang, @rules[lang], word)
+      elsif !@rules.has_key?(lang) and rules = initialize_wordlist(params)
+        word = random_pick_wordlist(rules)
+        if word.empty?
+          m.reply _("couldn't think of anything ...")
+          return
+        end
+        m.reply _("got it!")
+        @games[k] = AzGame.new(self, lang, rules, word)
       else
         m.reply _("I can't play A-Z in %{lang}, sorry") % {:lang => lang}
         return
       end
-      m.reply _("got it!")
-      @games[k] = AzGame.new(self, lang, @rules[lang], word)
     end
     tr = @games[k].total_tries
     # this message building code is rewritten to make translation easier
@@ -304,10 +355,10 @@ class AzGamePlugin < Plugin
       if wc[word].key?(:when)
         tr = _("%{word} learned from %{user} on %{date}") % {:word => word, :user => wc[word][:who], :date => wc[word][:when]}
       else
-        tr = _("%{word} learned from %{user}") % {:word => word, :user => wc[word][:who]} 
+        tr = _("%{word} learned from %{user}") % {:word => word, :user => wc[word][:who]}
       end
       m.reply tr
-    when :delete 
+    when :delete
       if pars.empty?
         m.reply _("provide a word")
         return
@@ -335,17 +386,12 @@ class AzGamePlugin < Plugin
     end
   end
 
-  def is_japanese?(word)
-    @rules[:japanese][:list].include?(word)
-  end
-
   # return integer between min and max, inclusive
   def rand_between(min, max)
     rand(max - min + 1) + min
   end
 
-  def random_pick_japanese(min=nil, max=nil)
-    rules = @rules[:japanese]
+  def random_pick_wordlist(rules, min=nil, max=nil)
     min = rules[:first] if min.nil_or_empty?
     max = rules[:last]  if max.nil_or_empty?
     debug "Randomly picking word between #{min} and #{max}"
@@ -552,7 +598,14 @@ class AzGamePlugin < Plugin
     when 'play'
       return _("az => start a game if none is running, show the current word range otherwise; you can say 'az <language>' if you want to play in a language different from the current bot default")
     end
-    return _("az topics: play, rules, cancel, manage, check")
+    langs = @rules.keys
+    wls = Wordlist.list
+    return [
+      _("az topics: play, rules, cancel, manage, check"),
+      _("available languages: %{langs}") % { :langs => langs.join(", ") },
+      wls.empty? ? nil : _("available wordlists: %{wls}") % { :wls => wls.join(", ") },
+    ].compact.join(". ")
+
   end
 
 end
@@ -561,5 +614,5 @@ plugin = AzGamePlugin.new
 plugin.map 'az [:lang] word :cmd *params', :action=>'wordlist', :defaults => { :lang => nil, :cmd => 'count', :params => [] }, :auth_path => '!az::edit!'
 plugin.map 'az cancel', :action=>'stop_game', :private => false
 plugin.map 'az check :word', :action => 'manual_word_check', :private => false
-plugin.map 'az [play] [:lang]', :action=>'start_game', :private => false, :defaults => { :lang => nil }
+plugin.map 'az [play] [:lang] [autoadd :addlang]', :action=>'start_game', :private => false, :defaults => { :lang => nil, :addlang => nil }
 

data/data/rbot/plugins/games/hangman.rb

@@ -0,0 +1,499 @@
+#-- vim:sw=2:et
+#++
+#
+# :title: Hangman Plugin
+#
+# Author:: Raine Virta <rane@kapsi.fi>
+# Copyright:: (C) 2009 Raine Virta
+# License:: GPL v2
+#
+# Description:: Hangman game for rbot
+#
+# TODO:: some sort of turn-basedness, maybe
+
+module RandomWord
+  SITE = "http://coyotecult.com/tools/randomwordgenerator.php"
+
+  def self.get(count=1)
+    res = Net::HTTP.post_form(URI.parse(SITE), {'numwords' => count})
+    words = res.body.scan(%r{<a.*?\?w=(.*?)\n}).flatten
+
+    count == 1 ? words.first : words
+  end
+end
+
+module Google
+  URL   = "http://www.google.com/wml/search?hl=en&q=define:"
+  REGEX = %r{Web definitions for .*?<br/>(.*?)<br/>}
+
+  def self.define(phrase)
+    raw = Net::HTTP.get(URI.parse(URL+CGI.escape(phrase)))
+    res = raw.scan(REGEX).flatten.map { |e| e.strip }
+
+    res.empty? ? false : res.last
+  end
+end
+
+class Hangman
+  LETTER_VALUE = 5
+
+  module Scoring
+    def self.correct_word_guess(game)
+      # (2 - (amt of visible chars / word length)) * (amt of chars not visible * 5)
+      length    = game.word.size
+      visible   = game.visible_characters.size
+      invisible = length - visible
+      score     = (2-(visible/length.to_f))*(invisible*5)
+      score    *= 1.5
+      score.round
+    end
+
+    def self.incorrect_word_guess(game)
+      incorrect_letter(game)
+    end
+
+    def self.correct_letter(game)
+      ((1/Math.log(game.word.size))+1) * LETTER_VALUE
+    end
+
+    def self.incorrect_letter(game)
+      Math.log(game.word.size) * -LETTER_VALUE
+    end
+  end
+end
+
+class Hangman
+  attr_reader :misses, :guesses, :word, :scores
+
+  STAGES = [' (x_x) ', ' (;_;) ', ' (>_<) ', ' (-_-) ', ' (o_~) ', ' (^_^) ', '\(^o^)/']
+  HEALTH = STAGES.size-1
+  LETTER = /[^\W0-9_]/u
+
+  def initialize(word)
+    @word     = word
+    @guesses  = []
+    @misses   = []
+    @health   = HEALTH
+    @canceled = false
+    @solved   = false
+    @scores   = {}
+  end
+
+  def visible_characters
+    # array of visible characters
+    characters.reject { |c| !@guesses.include?(c) && c =~ LETTER }
+  end
+
+  def letters
+    # array of the letters in the word
+    characters.reject { |c| c !~ LETTER  }.map { |c| c.downcase }
+  end
+
+  def characters
+    @word.split(//u)
+  end
+
+  def face
+    STAGES[@health]
+  end
+
+  def to_s
+    # creates a string that presents the word with unknown letters shown as underscores
+    characters.map { |c|
+      @guesses.include?(c.downcase) || c !~ LETTER  ? c : "_"
+    }.join
+  end
+
+  def guess(player, str)
+    @scores[player] ||= 0
+
+    str.downcase!
+    # full word guess
+    if str !~ /^#{LETTER}$/u
+      if word.downcase == str
+        @scores[player] += Scoring::correct_word_guess(self)
+        @solved = true
+      else
+        @scores[player] += Scoring::incorrect_word_guess(self)
+        punish
+      end
+    else # single letter guess
+      return false if @guesses.include?(str) # letter has been guessed before
+
+      unless letters.include?(str)
+        @scores[player] += Scoring::incorrect_letter(self)
+        @misses << str
+        punish
+      else
+        @scores[player] += Scoring::correct_letter(self)
+      end
+
+      @guesses << str
+    end
+
+    return true
+  end
+
+  def over?
+    won? || lost? || @canceled
+  end
+
+  def won?
+    (letters - @guesses).empty? || @solved
+  end
+
+  def lost?
+    @health.zero?
+  end
+
+  def punish
+    @health -= 1
+  end
+
+  def cancel
+    @canceled = true
+  end
+end
+
+class GameManager
+  def initialize
+    @games = {}
+  end
+
+  def current(target)
+    game = all(target).last
+    game if game && !game.over?
+  end
+
+  def all(target)
+    @games[target] || @games[target] = []
+  end
+
+  def previous(target)
+    all(target).select { |game| game.over? }.last
+  end
+
+  def new(game)
+    all(game.channel) << game
+  end
+end
+
+define_structure :HangmanPlayerStats, :played, :score
+define_structure :HangmanPrivateStats, :played, :score
+
+class StatsHandler
+  def initialize(registry)
+    @registry = registry
+  end
+
+  def save_gamestats(game)
+    target = game.channel
+
+    if target.is_a?(User)
+      stats = priv_reg[target]
+      stats.played += 1
+      stats.score  += game.scores.values.last.round
+      priv_reg[target] = stats
+    elsif target.is_a?(Channel)
+      stats = chan_stats(target)
+      stats['played'] += 1
+
+      reg = player_stats(target)
+      game.scores.each do |user, score|
+        pstats = reg[user]
+        pstats.played += 1
+        pstats.score  += score.round
+        reg[user] = pstats
+      end
+    end
+  end
+
+  def player_stats(channel)
+    reg = chan_reg(channel).sub_registry('player')
+    reg.set_default(HangmanPlayerStats.new(0,0))
+    reg
+  end
+
+  def chan_stats(channel)
+    reg = chan_reg(channel).sub_registry('stats')
+    reg.set_default(0)
+    reg
+  end
+
+  def chan_reg(channel)
+    @registry.sub_registry(channel.downcase)
+  end
+
+  def priv_reg
+    reg = @registry.sub_registry('private')
+    reg.set_default(HangmanPrivateStats.new(0,0))
+    reg
+  end
+end
+
+class HangmanPlugin < Plugin
+  def initialize
+    super
+    @games = GameManager.new
+    @stats = StatsHandler.new(@registry)
+    @settings = {}
+  end
+
+  def help(plugin, topic="")
+    case topic
+    when ""
+      return _("hangman game plugin - topics: play, stop")
+    when "play"
+      return [_("hangman play on <channel> with word <word> => use in private chat with the bot to start a game with custom word\n"),
+              _("hangman play random [with [max|min] length [<|>|== <length>]] => hangman with a random word from %{site}\n"),
+              _("hangman play with wordlist <wordlist> => hangman with random word from <wordlist>")].join % { :site => RandomWord::SITE }
+    when "stop"
+      return _("hangman stop => quits the current game")
+    when "define"
+      return _("define => seeks a definition for the previous answer using google")
+    end
+  end
+
+  def get_word(params)
+    if params[:word]
+      params[:word].join(" ")
+    elsif params[:wordlist]
+      begin
+        wordlist = Wordlist.get(params[:wordlist].join("/"), :spaces => true)
+      rescue
+        raise _("no such wordlist")
+      end
+
+      wordlist[rand(wordlist.size)]
+    else # getting a random word
+      words = RandomWord::get(100)
+
+      if adj = params[:adj]
+        words = words.sort_by { |e| e.size }
+
+        if adj == "max"
+          words.last
+        else
+          words.first
+        end
+      elsif params[:relation] && params[:size]
+        words = words.select { |w| w.size.send(params[:relation], params[:size].to_i) }
+
+        unless words.empty?
+          words.first
+        else
+          m.reply _("suitable word not found in the set")
+          nil
+        end
+      else
+        words.first
+      end
+    end
+  end
+
+  def start(m, params)
+    begin
+      word = get_word(params) || return
+    rescue => e
+      m.reply e.message
+      return
+    end
+
+    if params[:channel] || m.public?
+      target = if m.public?
+        m.channel
+      else
+        params[:channel]
+      end
+
+      # is the bot on the channel?
+      unless @bot.server.channels.names.include?(target.to_s)
+        m.reply _("i'm not on that channel")
+        return
+      end
+
+      if @games.current(target)
+        m.reply _("there's already a hangman game in progress on the channel")
+        return
+      end
+
+      @bot.say target, _("%{nick} has started a hangman -- join the fun!") % {
+        :nick => m.source
+      }
+    else
+      target = m.source
+    end
+
+    game = Hangman.new(word)
+
+    class << game = Hangman.new(word)
+      attr_accessor :channel
+    end
+
+    game.channel = target
+
+    @games.new(game)
+    @settings[target] = params
+
+    @bot.say target, game_status(@games.current(target))
+  end
+
+  def stop(m, params)
+    target = m.replyto
+    if game = @games.current(target)
+      @bot.say target, _("oh well, the answer would've been %{answer}") % {
+        :answer => Bold + game.word + Bold
+      }
+
+      game.cancel
+      @stats.save_gamestats(game)
+    else
+      @bot.say target, _("no ongoing game")
+    end
+  end
+
+  def message(m)
+    target = m.replyto
+
+    if game = @games.current(target)
+      return unless m.message =~ /^[^\W0-9_]$/u || m.message =~ prepare_guess_regex(game)
+
+      if game.guess(m.source, m.message)
+        m.reply game_status(game)
+      else
+        return
+      end
+
+      if game.over?
+        sentence = if game.won?
+          _("you nailed it!")
+        elsif game.lost?
+          _("you've killed the poor guy :(")
+        end
+
+        again = _("go %{b}again%{b}?") % { :b => Bold }
+
+        scores = []
+        game.scores.each do |user, score|
+          str = "#{user.nick}: "
+          str << if score > 0
+            Irc.color(:green)+'+'
+          elsif score < 0
+            Irc.color(:brown)
+          end.to_s
+
+          str << score.round.to_s
+          str << Irc.color
+
+          scores << str
+        end
+
+        m.reply _("%{sentence} %{again} %{scores}") % {
+          :sentence => sentence, :again => again, :scores => scores.join(' ')
+        }, :nick => true
+
+        if rand(5).zero?
+          m.reply _("wondering what that means? try ´%{prefix}define´") % {
+            :prefix => @bot.config['core.address_prefix']
+          }
+        end
+
+        @stats.save_gamestats(game)
+      end
+    elsif @settings[target] && m.message =~ /^(?:again|more!?$)/i
+      start(m, @settings[target])
+    end
+  end
+
+  def prepare_guess_regex(game)
+    Regexp.new("^#{game.characters.map { |c|
+      game.guesses.include?(c) || c !~ Hangman::LETTER ? c : '[^\W0-9_]'
+    }.join("")}$")
+  end
+
+  def game_status(game)
+    str = "%{word} %{face}" % {
+      :word   => game.over? ? "#{Bold}#{game.word}#{Bold}" : game.to_s,
+      :face   => game.face,
+      :misses => game.misses.map { |e| e.upcase }.join(" ")
+    }
+
+    str << " %{misses}" % {
+      :misses => game.misses.map { |e| e.upcase }.join(" ")
+    } unless game.misses.empty?
+
+    str
+  end
+
+  def score(m, params)
+    target = m.replyto
+
+    unless params[:nick]
+      stats = if m.private?
+        @stats.priv_reg[target]
+      else
+        @stats.player_stats(target)[m.source]
+      end
+
+      unless stats.played.zero?
+        m.reply _("you got %{score} points after %{games} games") % {
+          :score => stats.score.round,
+          :games => stats.played
+        }
+      else
+        m.reply _("you haven't played hangman, how about playing it right now? :)")
+      end
+    else
+      return unless m.public?
+
+      nick = params[:nick]
+      stats = @stats.player_stats(target)[nick]
+
+      unless stats.played.zero?
+        m.reply _("%{nick} has %{score} points after %{games} games") % {
+          :nick  => nick,
+          :score => stats.score.round,
+          :games => stats.played
+        }
+      else
+        m.reply _("%{nick} hasn't played hangman :(") % {
+          :nick => nick
+        }
+      end
+    end
+  end
+
+  def stats(m, params)
+    target = m.replyto
+    stats  = @stats.chan_stats(target)
+
+    if m.public?
+      m.reply _("%{games} games have been played on %{channel}") % {
+        :games   => stats['played'],
+        :channel => target.to_s
+      }
+    else
+      score(m, params)
+    end
+  end
+
+  def define(m, params)
+    if game = @games.previous(m.replyto)
+      return unless res = Google.define(game.word)
+      m.reply "#{Bold}#{game.word}#{Bold} -- #{res}"
+    end
+  end
+end
+
+plugin = HangmanPlugin.new
+plugin.map "hangman [play] with wordlist *wordlist", :action => 'start'
+plugin.map "hangman [play] on :channel with word *word", :action => 'start'
+plugin.map "hangman [play] [random] [with [:adj] length [:relation :size]]",
+  :action => 'start',
+  :requirements => { :adj => /min|max/, :relation => /<|<=|>=|>|==/, :size => /\d+/ }
+
+plugin.map "hangman stop", :action => 'stop'
+
+plugin.map "hangman score [:nick]", :action => 'score'
+plugin.map "hangman stats", :action => 'stats'
+plugin.map "define", :action => 'define'