rbot 0.9.9

data/data/rbot/plugins/roshambo.rb

@@ -0,0 +1,54 @@
+# Play the game of roshambo (rock-paper-scissors)
+# Copyright (C) 2004 Hans Fugal
+# Distributed under the same license as rbot itself
+require 'time'
+class RoshamboPlugin < Plugin
+  def initialize
+    super 
+    @scoreboard = {}
+  end
+  def help(plugin, topic="")
+    "roshambo <rock|paper|scissors> => play roshambo"
+  end
+  def privmsg(m)
+    # simultaneity
+    choice = choose
+
+    # init scoreboard
+    if (not @scoreboard.has_key?(m.sourcenick) or (Time.now - @scoreboard[m.sourcenick]['timestamp']) > 3600)
+      @scoreboard[m.sourcenick] = {'me'=>0,'you'=>0,'timestamp'=>Time.now}
+    end
+    case m.params
+    when 'rock','paper','scissors'
+      s = score(choice,m.params)
+      @scoreboard[m.sourcenick]['timestamp'] = Time.now
+      myscore=@scoreboard[m.sourcenick]['me']
+      yourscore=@scoreboard[m.sourcenick]['you']
+      case s
+      when 1
+	yourscore=@scoreboard[m.sourcenick]['you'] += 1
+	m.reply "#{choice}. You win. Score: me #{myscore} you #{yourscore}"
+      when 0
+	m.reply "#{choice}. We tie. Score: me #{myscore} you #{yourscore}"
+      when -1
+	myscore=@scoreboard[m.sourcenick]['me'] += 1
+	m.reply "#{choice}! I win! Score: me #{myscore} you #{yourscore}"
+      end
+    else
+      m.reply "incorrect usage: " + help(m.plugin)
+    end
+  end
+      
+  def choose
+    ['rock','paper','scissors'][rand(3)]
+  end
+  def score(a,b)
+    beats = {'rock'=>'scissors', 'paper'=>'rock', 'scissors'=>'paper'}
+    return -1 if beats[a] == b
+    return 1 if beats[b] == a
+    return 0
+  end
+end
+plugin = RoshamboPlugin.new
+plugin.register("roshambo")
+plugin.register("rps")

data/data/rbot/plugins/rot13.rb

@@ -0,0 +1,10 @@
+class RotPlugin < Plugin
+  def help(plugin, topic="")
+    "rot13 <string> => encode <string> to rot13 or back"
+  end
+  def rot13(m, params)
+    m.reply params[:string].tr("A-Za-z", "N-ZA-Mn-za-m");
+  end
+end
+plugin = RotPlugin.new
+plugin.map 'rot13 :string'

data/data/rbot/plugins/roulette.rb

@@ -0,0 +1,147 @@
+RouletteHistory = Struct.new("RouletteHistory", :games, :shots, :deaths, :misses, :wins)
+
+class RoulettePlugin < Plugin
+  def initialize
+    super
+    reset_chambers
+    @players = Array.new
+  end
+  def help(plugin, topic="")
+    "roulette => play russian roulette - starts a new game if one isn't already running. One round in a six chambered gun. Take turns to say roulette to the bot, until somebody dies. roulette reload => force the gun to reload, roulette stats => show stats from all games, roulette stats <player> => show stats for <player>, roulette clearstats => clear stats (config level auth required)"
+  end
+  def clearstats(m, params)
+    @registry.clear
+    m.okay
+  end
+
+  def roulette(m, params)
+    if m.private?
+      m.reply "you gotta play roulette in channel dude"
+      return
+    end
+
+    playerdata = nil
+    if @registry.has_key?(m.sourcenick)
+      playerdata = @registry[m.sourcenick]
+    else
+      playerdata = RouletteHistory.new(0,0,0,0,0)
+    end
+    
+    unless @players.include?(m.sourcenick)
+      @players << m.sourcenick
+      playerdata.games += 1
+    end
+    playerdata.shots += 1
+    
+    shot = @chambers.pop
+    if shot
+      m.reply "#{m.sourcenick}: chamber #{6 - @chambers.length} of 6 => *BANG*"
+      playerdata.deaths += 1
+      @players.each {|plyr|
+        next if plyr == m.sourcenick
+        pdata = @registry[plyr]
+        next if pdata == nil
+        pdata.wins += 1
+        @registry[plyr] = pdata
+      }
+    else
+      m.reply "#{m.sourcenick}: chamber #{6 - @chambers.length} of 6 => +click+"
+      playerdata.misses += 1
+    end
+
+    @registry[m.sourcenick] = playerdata
+    
+    if shot || @chambers.empty?
+      reload(m)
+    end
+  end
+  def reload(m, params = {})
+    @bot.action m.replyto, "reloads"
+    reset_chambers
+    # all players win on a reload
+    # (allows you to play 3-shot matches etc)
+    @players.each {|plyr|
+      pdata = @registry[plyr]
+      next if pdata == nil
+      pdata.wins += 1
+      @registry[plyr] = pdata
+    }
+    @players = Array.new
+  end
+  def reset_chambers
+    @chambers = [false, false, false, false, false, false]
+    @chambers[rand(@chambers.length)] = true
+  end
+  def playerstats(m, params)
+    player = params[:player]
+    pstats = @registry[player]
+    if pstats.nil?
+      m.reply "#{player} hasn't played enough games yet"
+    else
+      m.reply "#{player} has played #{pstats.games} games, won #{pstats.wins} and lost #{pstats.deaths}. #{player} pulled the trigger #{pstats.shots} times and found the chamber empty on #{pstats.misses} occasions."
+    end
+  end
+  def stats(m, params)
+    total_players = 0
+    total_games = 0
+    total_shots = 0
+    
+    died_most = [nil,0]
+    won_most = [nil,0]
+    h_win_percent = [nil,0]
+    l_win_percent = [nil,0]
+    h_luck_percent = [nil,0]
+    l_luck_percent = [nil,0]
+    @registry.each {|k,v|
+      total_players += 1
+      total_games += v.deaths
+      total_shots += v.shots
+      
+      win_rate = v.wins.to_f / v.games * 100
+      if h_win_percent[0].nil? || win_rate > h_win_percent[1] && v.games > 2
+        h_win_percent = [[k], win_rate]
+      elsif win_rate == h_win_percent[1] && v.games > 2
+        h_win_percent[0] << k
+      end
+      if l_win_percent[0].nil? || win_rate < l_win_percent[1] && v.games > 2
+        l_win_percent = [[k], win_rate]
+      elsif win_rate == l_win_percent[1] && v.games > 2
+        l_win_percent[0] << k
+      end
+
+      luck = v.misses.to_f / v.shots * 100
+      if h_luck_percent[0].nil? || luck > h_luck_percent[1] && v.games > 2
+        h_luck_percent = [[k], luck]
+      elsif luck == h_luck_percent[1] && v.games > 2
+        h_luck_percent[0] << k
+      end
+      if l_luck_percent[0].nil? || luck < l_luck_percent[1] && v.games > 2
+        l_luck_percent = [[k], luck]
+      elsif luck == l_luck_percent[1] && v.games > 2
+        l_luck_percent[0] << k
+      end
+
+      if died_most[0].nil? || v.deaths > died_most[1]
+        died_most = [[k], v.deaths]
+      elsif v.deaths == died_most[1]
+        died_most[0] << k
+      end
+      if won_most[0].nil? || v.wins > won_most[1]
+        won_most = [[k], v.wins]
+      elsif v.wins == won_most[1]
+        won_most[0] << k
+      end
+    }
+    if total_games < 1
+      m.reply "roulette stats: no games played yet"
+    else
+      m.reply "roulette stats: #{total_games} games completed, #{total_shots} shots fired at #{total_players} players. Luckiest: #{h_luck_percent[0].join(',')} (#{sprintf '%.1f', h_luck_percent[1]}% clicks). Unluckiest: #{l_luck_percent[0].join(',')} (#{sprintf '%.1f', l_luck_percent[1]}% clicks). Highest survival rate: #{h_win_percent[0].join(',')} (#{sprintf '%.1f', h_win_percent[1]}%). Lowest survival rate: #{l_win_percent[0].join(',')} (#{sprintf '%.1f', l_win_percent[1]}%). Most wins: #{won_most[0].join(',')} (#{won_most[1]}). Most deaths: #{died_most[0].join(',')} (#{died_most[1]})."
+    end
+  end
+end
+plugin = RoulettePlugin.new
+plugin.map 'roulette reload', :action => 'reload'
+plugin.map 'roulette stats :player', :action => 'playerstats'
+plugin.map 'roulette stats', :action => 'stats'
+plugin.map 'roulette clearstats', :action => 'clearstats', :auth => 'config'
+plugin.map 'roulette'

data/data/rbot/plugins/rss.rb.disabled

@@ -0,0 +1,414 @@
+# RSS feed plugin for RubyBot
+# (c) 2004 Stanislav Karchebny <berkus@madfire.net>
+# (c) 2005 Ian Monroe <ian@monroe.nu>
+# (c) 2005 Mark Kretschmann <markey@web.de>
+# Licensed under MIT License.
+
+# TODO
+# checks feeds very often - does it use HEAD to check it needs to d/l?
+# some usage issues
+# why can't I do this here? :
+# Class String
+#   def foo
+#   foo
+#   end
+# end
+
+require 'rss/parser'
+require 'rss/1.0'
+require 'rss/2.0'
+require 'rss/dublincore'
+begin
+require 'rss/dublincore/2.0'
+rescue LoadError => e
+  puts "rss plugin: no dublincore 2.0 found, should be okay tho"
+end
+
+
+class RSSFeedsPlugin < Plugin
+    @@watchThreads = Hash.new
+
+    # Keep a 1:1 relation between commands and handlers
+    @@handlers = {
+        "rss" => "handle_rss",
+        "addrss" => "handle_addrss",
+        "rmrss" => "handle_rmrss",
+        "listrss" => "handle_listrss",
+        "listwatches" => "handle_listrsswatch",
+        "rewatch" => "handle_rewatch",
+        "watchrss" => "handle_watchrss",
+        "rmwatch" => "handle_rmwatch"
+    }
+
+    def name
+      'rss'
+    end
+
+    def initialize
+        super
+        @feeds = Hash.new
+        @watchList = Hash.new
+
+        if FileTest.exists?("#{@bot.botclass}/rss/feeds")
+          IO.foreach("#{@bot.botclass}/rss/feeds") { |line|
+              s = line.chomp.split("|", 2)
+              @feeds[s[0]] = s[1]
+          }
+        end
+        
+        if FileTest.exists?("#{@bot.botclass}/rss/watchlist")
+          IO.foreach("#{@bot.botclass}/rss/watchlist") { |line|
+              s = line.chomp.split("|", 3)
+              @watchList[s[0]] = [s[1], s[2]]
+              watchRss( s[2], s[0], s[1] )
+          }
+        end
+    end
+
+    def cleanup
+        kill_threads
+    end
+
+    def save
+        Dir.mkdir("#{@bot.botclass}/rss") if not FileTest.directory?("#{@bot.botclass}/rss")
+        File.open("#{@bot.botclass}/rss/feeds", "w") { |file|
+            @feeds.each { |k,v|
+                file.puts(k + "|" + v)
+            }
+        }
+        File.open("#{@bot.botclass}/rss/watchlist", "w") { |file|
+            @watchList.each { |url, d|
+                feedFormat = d[0] || ''
+                whichChan = d[1] || 'markey'
+                file.puts(url + '|' + feedFormat + '|' + whichChan)
+            }
+        }
+    end
+
+    def kill_threads
+        Thread.critical=true
+        # Abort all running threads.
+        @@watchThreads.each { |url, thread|
+            puts "Killing thread for #{url}"
+            thread.kill
+        }
+#         @@watchThreads.each { |url, thread|
+#             puts "Joining on killed thread for #{url}"
+#             thread.join
+#         }
+        @@watchThreads = Hash.new
+        Thread.critical=false
+    end
+
+    def help(plugin,topic="")
+        "RSS Reader: rss name [limit] => read a named feed [limit maximum posts, default 5], addrss [force] name url => add a feed, listrss => list all available feeds, rmrss name => remove the named feed, watchrss url [type] => watch a rss feed for changes (type may be 'amarokblog', 'amarokforum', 'mediawiki', 'gmame' or empty - it defines special formatting of feed items), rewatch => restart all rss watches, rmwatch url => stop watching for changes in url"
+    end
+
+    def privmsg(m)
+        meth = self.method(@@handlers[m.plugin])
+        meth.call(m)
+    end
+
+    def handle_rss(m)
+        unless m.params
+            m.reply("incorrect usage: " + help(m.plugin))
+            return
+        end
+        limit = 5
+        if m.params =~ /\s+(\d+)$/
+            limit = $1.to_i
+            if limit < 1 || limit > 15
+                m.reply("weird, limit not in [1..15], reverting to default")
+                limit = 5
+            end
+            m.params.gsub!(/\s+\d+$/, '')
+        end
+        unless @feeds.has_key?(m.params)
+            m.reply(m.params + "? what is that feed about?")
+            return
+        end
+
+        m.reply("Please wait, querying...")
+        title = ''
+        items = fetchRSS(m.replyto, @feeds[m.params], title)
+        if(items == nil)
+            return
+        end
+        m.reply("Channel : #{title}")
+        # FIXME: optional by-date sorting if dates present
+        items[0...limit].each do |item|
+            printRSSItem(m.replyto,item)
+        end
+    end
+
+    def handle_addrss(m)
+        unless m.params
+            m.reply "incorrect usage: " + help(m.plugin)
+            return
+        end
+        if m.params =~ /^force /
+            forced = true
+            m.params.gsub!(/^force /, '')
+        end
+        feed = m.params.scan(/^(\S+)\s+(\S+)$/)
+        unless feed.length == 1 && feed[0].length == 2
+            m.reply("incorrect usage: " + help(m.plugin))
+            return
+        end
+        if @feeds.has_key?(feed[0][0]) && !forced
+            m.reply("But there is already a feed named #{feed[0][0]} with url #{@feeds[feed[0][0]]}")
+            return
+        end
+        feed[0][0].gsub!("|", '_')
+        @feeds[feed[0][0]] = feed[0][1]
+        m.reply("RSS: Added #{feed[0][1]} with name #{feed[0][0]}")
+    end
+
+    def handle_rmrss(m)
+        unless m.params
+            m.reply "incorrect usage: " + help(m.plugin)
+            return
+        end
+        unless @feeds.has_key?(m.params)
+            m.reply("dunno that feed")
+            return
+        end
+        @feeds.delete(m.params)
+        m.okay
+    end
+
+    def handle_rmwatch(m)
+        unless m.params
+            m.reply "incorrect usage: " + help(m.plugin)
+            return
+        end
+        unless @watchList.has_key?(m.params)
+            m.reply("no such watch")
+            return
+        end
+        unless @watchList[m.params][1] == m.replyto
+            m.reply("no such watch for this channel/nick")
+            return
+        end
+        @watchList.delete(m.params)
+        Thread.critical=true
+        if @@watchThreads[m.params].kind_of? Thread
+            @@watchThreads[m.params].kill
+            puts "rmwatch: Killed thread for #{m.params}"
+#             @@watchThreads[m.params].join
+#             puts "rmwatch: Joined killed thread for #{m.params}"
+            @@watchThreads.delete(m.params)
+        end
+        Thread.critical=false
+        m.okay
+    end
+
+    def handle_listrss(m)
+        reply = ''
+        if @feeds.length == 0
+            reply = "No feeds yet."
+        else
+            @feeds.each { |k,v|
+                reply << k + ": " + v + "\n"
+            }
+        end
+        m.reply(reply)
+    end
+
+    def handle_listrsswatch(m)
+        reply = ''
+        if @watchList.length == 0
+            reply = "No watched feeds yet."
+        else
+            @watchList.each { |url,v|
+                reply << url + " for " + v[1] + " (in format: " + (v[0]?v[0]:"default") + ")\n"
+            }
+        end
+        m.reply(reply)
+    end
+
+    def handle_rewatch(m)
+        kill_threads
+
+        # Read watches from list.
+        @watchList.each{ |url, d|
+            feedFormat = d[0]
+            whichChan = d[1]
+            watchRss(whichChan, url,feedFormat)
+        }
+        m.okay
+    end
+
+    def handle_watchrss(m)
+        unless m.params
+            m.reply "incorrect usage: " + help(m.plugin)
+            return
+        end
+        feed = m.params.scan(/^(\S+)\s+(\S+)$/)
+        url = feed[0][0]
+        feedFormat = feed[0][1]
+        if @watchList.has_key?(url)
+            m.reply("But there is already a watch for feed #{url} on chan #{@watchList[url][1]}")
+            return
+        end
+        @watchList[url] = [feedFormat, m.replyto]
+        watchRss(m.replyto, url,feedFormat)
+        m.okay
+    end
+
+    private
+    def watchRss(whichChan, url, feedFormat)
+        if @@watchThreads.has_key?(url)
+            @bot.say whichChan, "ERROR: watcher thread for #{url} is already running! #{@@watchThreads[url]}"
+            return
+        end
+        @@watchThreads[url] = Thread.new do
+            puts 'watchRss thread started.'
+            oldItems = []
+            firstRun = true
+            loop do
+                begin # exception
+                    title = ''
+                    puts 'Fetching rss feed..'
+                    newItems = fetchRSS(whichChan, url, title)
+                    if( newItems.empty? )
+                        @bot.say whichChan, "Oops - Item is empty"
+                        break
+                    end
+                    puts "Checking if new items are available"
+                    if (firstRun)
+                        firstRun = false
+                    else
+                        newItems.each do |nItem|
+                            showItem = true;
+                            oldItems.each do |oItem|
+                                if (nItem.to_s == oItem.to_s)
+                                    showItem = false
+                                end
+                            end
+                            if showItem
+                                puts "showing #{nItem.title}"
+                                printFormatedRSS(whichChan, nItem,feedFormat)
+                            else
+                                puts "not showing  #{nItem.title}"
+                                break
+                            end
+                        end
+                    end
+                oldItems = newItems
+                rescue Exception
+                    $stderr.print "IO failed: " + $! + "\n"
+                end
+
+                seconds = 150 + rand(100)
+                puts "Thread going to sleep #{seconds} seconds.."
+                sleep seconds
+            end
+        end
+    end
+
+    def printRSSItem(whichChan,item)
+        if item.kind_of?(RSS::RDF::Item)
+            @bot.say whichChan, shorten(riphtml(item.title.chomp), 20) + " @ " + item.link
+        else
+            @bot.say whichChan, "#{item.pubDate.to_s.chomp+": " if item.pubDate}#{shorten(riphtml(item.title.chomp), 20)+" :: " if item.title}#{" @ "+item.link.chomp if item.link}"
+        end
+    end
+
+    def printFormatedRSS(whichChan,item, type)
+        case type
+            when 'amarokblog'
+                @bot.say whichChan, "::#{item.category.content} just blogged at #{item.link}::"
+                @bot.say whichChan, "::#{shorten(riphtml(item.title.chomp), 20)} - #{shorten(riphtml(item.description.chomp),60)}::"
+            when 'amarokforum'
+                @bot.say whichChan, "::Forum:: #{item.pubDate.to_s.chomp+": " if item.pubDate}#{shorten(riphtml(item.title.chomp), 20)+" :: " if item.title}#{" @ "+item.link.chomp if item.link}"
+            when 'mediawiki'
+                @bot.say whichChan, "::Wiki:: #{item.title} has been edited by #{item.dc_creator}. #{shorten(riphtml(item.description.split("\n")[0].chomp),60)} #{item.link} ::"
+                puts "mediawiki #{item.title}"
+            when "gmame"
+                @bot.say whichChan, "::amarok-devel:: Message #{item.title} sent by #{item.dc_creator}. #{shorten(riphtml(item.description.split("\n")[0].chomp),60)}::"
+            else
+                printRSSItem(whichChan,item)
+        end
+    end
+
+    def fetchRSS(whichChan, url, title)
+        begin
+            # Use 60 sec timeout, cause the default is too low
+            xml = Utils.http_get(url,60,60)
+        rescue URI::InvalidURIError, URI::BadURIError => e
+            @bot.say whichChan, "invalid rss feed #{url}"
+            return
+        end
+        puts 'fetched'
+        unless xml
+            @bot.say whichChan, "reading feed #{url} failed"
+            return
+        end
+
+        begin
+            ## do validate parse
+            rss = RSS::Parser.parse(xml)
+            puts 'parsed'
+        rescue RSS::InvalidRSSError
+        ## do non validate parse for invalid RSS 1.0
+            begin
+                rss = RSS::Parser.parse(xml, false)
+            rescue RSS::Error
+                @bot.say whichChan, "parsing rss stream failed, whoops =("
+                return
+            end
+        rescue RSS::Error
+            @bot.say whichChan, "parsing rss stream failed, oioi"
+            return
+        rescue
+            @bot.say whichChan, "processing error occured, sorry =("
+            return
+        end
+        items = []
+        if rss.nil?
+            @bot.say whichChan, "#{m.params} does not include RSS 1.0 or 0.9x/2.0"
+        else
+            begin
+                rss.output_encoding = "euc-jp"
+            rescue RSS::UnknownConvertMethod
+                @bot.say whichChan, "bah! something went wrong =("
+                return
+            end
+            rss.channel.title ||= "Unknown"
+            title.replace(rss.channel.title)
+            rss.items.each do |item|
+                item.title ||= "Unknown"
+                items << item
+            end
+        end
+
+        if items.empty?
+            @bot.say whichChan, "no items found in the feed, maybe try weed?"
+            return
+        end
+        return items
+    end
+
+    def riphtml(str)
+      str.gsub(/<[^>]+>/, '').gsub(/&amp;/,'&').gsub(/&quot;/,'"').gsub(/&lt;/,'<').gsub(/&gt;/,'>').gsub(/&ellip;/,'...').gsub(/&apos;/, "'").gsub("\n",'')
+    end
+
+    def shorten(str, limit)
+      if str.length > limit
+          str+". " =~ /^(.{#{limit}}[^.!;?]*[.!;?])/mi
+          return $1
+      end
+      str
+    end
+end
+
+plugin = RSSFeedsPlugin.new
+plugin.register("rss")
+plugin.register("addrss")
+plugin.register("rmrss")
+plugin.register("listrss")
+plugin.register("rewatch")
+plugin.register("watchrss")
+plugin.register("listwatches")
+plugin.register("rmwatch")