X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=data%2Frbot%2Fplugins%2Fgames%2Funo.rb;h=df6a1eee1bf040b6f6f7c921ae298c05a56d07c1;hb=fe217ba8960032cef8a61dafb59d1468360e8e5f;hp=56a7b99cff5b66bf852d4a15bb355c482f8fe93c;hpb=30ddc82becc5fde75f95b1f395bd66d1de4c09a3;p=user%2Fhenk%2Fcode%2Fruby%2Frbot.git

diff --git a/data/rbot/plugins/games/uno.rb b/data/rbot/plugins/games/uno.rb
index 56a7b99c..df6a1eee 100644
--- a/data/rbot/plugins/games/uno.rb
+++ b/data/rbot/plugins/games/uno.rb
@@ -10,6 +10,10 @@
 # License:: GPL v2
 #
 # Uno Game: get rid of the cards you have
+#
+# TODO documentation
+# TODO allow full form card names for play
+# TODO allow choice of rules re stacking + and playing Reverse with them
 
 class UnoGame
   COLORS = %w{Red Green Blue Yellow}
@@ -104,7 +108,7 @@ class UnoGame
       @color = 'Wild'
       raise if value and not value == '+4'
       if value
-        @value = value.dup 
+        @value = value.dup
         @shortform = 'w'+value
       else
         @value = nil
@@ -120,20 +124,20 @@ class UnoGame
 
   class Player
     attr_accessor :cards
-    attr_reader :user
+    attr_accessor :user
     def initialize(user)
       @user = user
       @cards = []
     end
     def has_card?(short)
-      cards = []
+      has = []
       @cards.each { |c|
-        cards << c if c.shortform == short
+        has << c if c.shortform == short
       }
-      if cards.empty?
+      if has.empty?
         return false
       else
-        return cards
+        return has
       end
     end
     def to_s
@@ -141,28 +145,61 @@ class UnoGame
     end
   end
 
+  # cards in stock
   attr_reader :stock
+  # current discard
   attr_reader :discard
+  # previous discard, in case of challenge
+  attr_reader :last_discard
+  # channel the game is played in
   attr_reader :channel
+  # list of players
   attr :players
+  # true if the player picked a card (and can thus pass turn)
   attr_reader :player_has_picked
+  # number of cards to be picked if the player can't play an appropriate card
   attr_reader :picker
 
-  def initialize(plugin, channel)
+  # game start time
+  attr :start_time
+
+  # the IRC user that created the game
+  attr_accessor :manager
+
+  def initialize(plugin, channel, manager)
     @channel = channel
     @plugin = plugin
     @bot = plugin.bot
     @players = []
+    @dropouts = []
     @discard = nil
+    @last_discard = nil
+    @value = nil
+    @color = nil
     make_base_stock
     @stock = []
     make_stock
     @start_time = nil
     @join_timer = nil
+    @picker = 0
+    @last_picker = 0
+    @must_play = nil
+    @manager = manager
   end
 
   def get_player(user)
-    @players.each { |p| return p if p.user == user }
+    case user
+    when User
+      @players.each do |p|
+        return p if p.user == user
+      end
+    when String
+      @players.each do |p|
+        return p if p.user.irc_downcase == user.irc_downcase(channel.casemap)
+      end
+    else
+      get_player(user.to_s)
+    end
     return nil
   end
 
@@ -174,6 +211,13 @@ class UnoGame
     @bot.notice player.user, msg, opts
   end
 
+  def notify_error(player, msg, opts={})
+    announce _("you can't do that, %{p}") % {
+      :p => player.user
+    }
+    notify player, msg, opts
+  end
+
   def make_base_stock
     @base_stock = COLORS.inject([]) do |list, clr|
       VALUES.each do |n|
@@ -200,6 +244,7 @@ class UnoGame
   end
 
   def start_game
+    @join_timer = nil
     debug "Starting game"
     @players.shuffle!
     show_order
@@ -222,12 +267,28 @@ class UnoGame
     @start_time = Time.now
   end
 
+  def elapsed_time
+    if @start_time
+      Utils.secs_to_string(Time.now-@start_time)
+    else
+      _("no time")
+    end
+  end
+
   def reverse_turn
+    # if there are two players, the Reverse acts like a Skip, unless
+    # there's a @picker running, in which case the Reverse should bounce the
+    # pick on the other player
     if @players.length > 2
       @players.reverse!
       # put the current player back in its place
       @players.unshift @players.pop
       announce _("Playing order was reversed!")
+    elsif @picker > 0
+      announce _("%{cp} bounces the pick to %{np}") % {
+        :cp => @players.first,
+        :np => @players.last
+      }
     else
       skip_turn
     end
@@ -273,26 +334,40 @@ class UnoGame
   end
 
   def next_turn(opts={})
+    @must_play = nil
     @players << @players.shift
     @player_has_picked = false
-    show_turn
+    show_turn unless opts[:silent]
   end
 
   def can_play(card)
-    # When a +something is online, you can only play
-    # a +something of same or higher something, or a Reverse of
-    # the correct color
-    # TODO make optional
+    # if play is forced, check against the only allowed cards
+    return false if @must_play and not @must_play.include?(card)
+
     if @picker > 0
-      if (card.value == 'Reverse' and card.color == @color) or card.picker >= @last_picker
+      # During a picker run (i.e. after a +something was played and before a
+      # player is forced to pick) you can only play pickers (+2, +4) and
+      # Reverse. Reverse can be played if the previous card matches by color or
+      # value (as usual), a +4 can always be played, a +2 can be played on a +2
+      # of any color or on a Reverse of the correct color unless a +4 was
+      # played on it
+      # TODO make optional
+      case card.value
+      when 'Reverse'
+        # Reverse can be played if it matches color or value
+        return (card.color == @color) || (@discard.value == card.value)
+      when '+2'
+        return false if @last_picker > 2
+        return true if @discard.value == card.value
+        return true if @discard.value == 'Reverse' and @color == card.color
+        return false
+      when '+4'
         return true
       else
         return false
       end
     else
       # You can always play a Wild
-      # FIXME W+4 can only be played if you don't have a proper card
-      # TODO make it playable anyway, and allow players to challenge
       return true if Wild === card
       # On a Wild, you must match the color
       if Wild === @discard
@@ -307,36 +382,80 @@ class UnoGame
   def play_card(source, cards)
     debug "Playing card #{cards}"
     p = get_player(source)
-    shorts = cards.scan(/[rbgy]\s*(?:\+?\d|[rs])|w\s*(?:\+4)?/)
+    shorts = cards.gsub(/\s+/,'').match(/^(?:([rbgy]\+?\d)\1?|([rbgy][rs])|(w(?:\+4)?)([rbgy])?)$/).to_a
     debug shorts.inspect
-    if shorts.length > 2 or shorts.length < 1
-      announce _("you can only play one or two cards")
+    if shorts.empty?
+      announce _("what cards were that again?")
       return
     end
-    if shorts.length == 2 and shorts.first != shorts.last
-      announce _("you can only play two cards if they are the same")
+    full = shorts[0]
+    short = shorts[1] || shorts[2] || shorts[3]
+    jolly = shorts[3]
+    jcolor = shorts[4]
+    if jolly
+      toplay = 1
+    else
+      toplay = (full == short) ? 1 : 2
+    end
+    debug [full, short, jolly, jcolor, toplay].inspect
+    # r7r7 -> r7r7, r7, nil, nil, 2
+    # r7 -> r7, r7, nil, nil, 1
+    # w -> w, nil, w, nil, 1
+    # wg -> wg, nil, w, g, 1
+
+    # if @color is nil, the player just played a wild without specifying
+    # a color. (s)he should now use "co <colorname>", but we allow him to
+    # replay the wild _and_ specify the color, without actually replaying
+    # the card (which would otherwise happen if the player has another wild)
+    if @color.nil?
+      if jcolor
+        choose_color(p.user, jcolor)
+      else
+        announce _("you already played your card, ") + _("%{p}, choose a color with: co r|b|g|y") % { :p => p }
+      end
       return
     end
-    if cards = p.has_card?(shorts.first)
+
+    if cards = p.has_card?(short)
       debug cards
       unless can_play(cards.first)
-        announce _("you can't play that card")
+        notify_error p, _("you can't play that card")
         return
       end
-      if cards.length >= shorts.length
+      if cards.length >= toplay
+        # if the played card is a W+4 not played during a stacking +x
+        # TODO if A plays an illegal W+4, B plays a W+4, should the next
+        # player be able to challenge A? For the time being we say no,
+        # but I think he should, and in case A's move was illegal
+        # game would have to go back, A would get the penalty and replay,
+        # while if it was legal the challenger would get 50% more cards,
+        # i.e. 12 cards (or more if the stacked +4 were more). This would
+        # only be possible if the first W+4 was illegal, so it wouldn't
+        # apply for a W+4 played on a +2 anyway.
+        #
+        if @picker == 0 and Wild === cards.first and cards.first.value
+          # save the previous discard in case of challenge
+          @last_discard = @discard.dup
+          # save the color too, in case it was a Wild
+          @last_color = @color.dup
+        else
+          # mark the move as not challengeable
+          @last_discard = nil
+          @last_color = nil
+        end
         set_discard(p.cards.delete_one(cards.shift))
-        if shorts.length > 1
+        if toplay > 1
           set_discard(p.cards.delete_one(cards.shift))
           announce _("%{p} plays %{card} twice!") % {
-            :p => source,
+            :p => p,
             :card => @discard
           }
         else
-          announce _("%{p} plays %{card}") % { :p => source, :card => @discard }
+          announce _("%{p} plays %{card}") % { :p => p, :card => @discard }
         end
         if p.cards.length == 1
           announce _("%{p} has %{uno}!") % {
-            :p => source, :uno => UNO
+            :p => p, :uno => UNO
           }
         elsif p.cards.length == 0
           end_game
@@ -348,12 +467,76 @@ class UnoGame
             do_special
           end
           next_turn
+        elsif jcolor
+          choose_color(p.user, jcolor)
         else
           announce _("%{p}, choose a color with: co r|b|g|y") % { :p => p }
         end
       else
-        announce _("you don't have that card")
+        notify_error p, _("you don't have two cards of that kind")
       end
+    else
+      notify_error p, _("you don't have that card")
+    end
+  end
+
+  def challenge
+    return unless @last_discard
+    # current player
+    cp = @players.first
+    # previous player
+    lp = @players.last
+    announce _("%{cp} challenges %{lp}'s %{card}!") % {
+      :cp => cp, :lp => lp, :card => @discard
+    }
+    # show the cards of the previous player to the current player
+    notify cp, _("%{p} has %{cards}") % {
+      :p => lp, :cards => lp.cards.join(' ')
+    }
+    # check if the previous player had a non-special card of the correct color
+    legal = true
+    lp.cards.each do |c|
+      if c.color == @last_color and not c.special?
+        legal = false
+        break
+      end
+    end
+    if legal
+      @picker += 2
+      announce _("%{lp}'s move was legal, %{cp} must pick %{b}%{n}%{b} cards!") % {
+        :cp => cp, :lp => lp, :b => Bold, :n => @picker
+      }
+      @last_color = nil
+      @last_discard = nil
+      deal(cp, @picker)
+      @picker = 0
+      next_turn
+    else
+      announce _("%{lp}'s move was %{b}not%{b} legal, %{lp} must pick %{b}%{n}%{b} cards and play again!") % {
+        :cp => cp, :lp => lp, :b => Bold, :n => @picker
+      }
+      played = @discard # store the misplayed W+4
+
+      # reset the discard
+      @color = @last_color.dup
+      @discard = @last_discard.dup
+      @special = false
+      @value = @discard.value.dup rescue @discard.value
+      @last_color = nil
+      @last_discard = nil
+
+      # force the player to play the current cards
+      @must_play = lp.cards.dup
+      # but not the same (type of) card he misplayed, though
+      @must_play.delete(played)
+
+      lp.cards << played # reinstate the W+4 in the list of player cards
+      # give him the penalty cards
+      deal(lp, @picker)
+      @picker = 0
+
+      # and restore the turn
+      @players.unshift @players.pop
     end
   end
 
@@ -361,13 +544,17 @@ class UnoGame
     p = get_player(user)
     if @picker > 0
       announce _("%{p} passes turn, and has to pick %{b}%{n}%{b} cards!") % {
-        :p => user, :b => Bold, :n => @picker
+        :p => p, :b => Bold, :n => @picker
       }
       deal(p, @picker)
       @picker = 0
+      # make sure that if this is the "pick and pass" after a W+4,
+      # then the following player cannot do a challenge:
+      @last_discard = nil
+      @last_color = nil
     else
       if @player_has_picked
-        announce _("%{p} passes turn") % { :p => user }
+        announce _("%{p} passes turn") % { :p => p }
       else
         announce _("you need to pick a card first")
         return
@@ -377,6 +564,13 @@ class UnoGame
   end
 
   def choose_color(user, color)
+    # you can only pick a color if the current color is unset
+    if @color
+      announce _("you can't pick a color now, %{p}") % {
+        :p => get_player(user)
+      }
+      return
+    end
     case color
     when 'r'
       @color = 'Red'
@@ -390,7 +584,9 @@ class UnoGame
       announce _('what color is that?')
       return
     end
-    announce _('color is now %{c}') % { :c => @color.downcase }
+    announce _('color is now %{c}') % {
+      :c => UnoGame.irc_color_bg(@color)+" #{@color} "
+    }
     next_turn
   end
 
@@ -398,7 +594,7 @@ class UnoGame
     if @start_time
       announce _("This %{uno} game has been going on for %{time}") % {
         :uno => UNO,
-        :time => Utils.secs_to_string(Time.now - @start_time)
+        :time => elapsed_time
       }
     else
       announce _("The game hasn't started yet")
@@ -412,6 +608,12 @@ class UnoGame
   end
 
   def show_turn(opts={})
+    if @players.empty?
+      announce _("nobody is playing %{uno} yet!") % {
+        :uno => UNO
+      }
+      return false
+    end
     cards = true
     cards = opts[:cards] if opts.key?(:cards)
     player = @players.first
@@ -420,7 +622,7 @@ class UnoGame
   end
 
   def has_turn?(source)
-    @players.first.user == source
+    @start_time && (@players.first.user == source)
   end
 
   def show_picker
@@ -440,6 +642,7 @@ class UnoGame
 
   def show_user_cards(player)
     p = Player === player ? player : get_player(player)
+    return unless p
     notify p, _('Your cards: %{cards}') % {
       :cards => p.cards.join(' ')
     }
@@ -474,16 +677,47 @@ class UnoGame
         end
       end
     end
+    picked.sort!
     notify player, _("You picked %{picked}") % { :picked => picked.join(' ') }
     player.cards += picked
     player.cards.sort!
   end
 
   def add_player(user)
-    return if get_player(user)
+    if p = get_player(user)
+      announce _("you're already in the game, %{p}") % {
+        :p => p
+      }
+      return
+    end
+    @dropouts.each do |dp|
+      if dp.user == user
+        announce _("you dropped from the game, %{p}, you can't get back in") % {
+          :p => dp
+        }
+        return
+      end
+    end
+    if @last_discard
+      announce _("you can't join now, %{p}, a %{card} was just played, wait until next turn") % {
+        :card => @discard,
+        :p => user
+      }
+      return
+    end
+    cards = 7
+    if @start_time
+      cards = (@players.inject(0) do |s, pl|
+        s +=pl.cards.length
+      end*1.0/@players.length).ceil
+    end
     p = Player.new(user)
     @players << p
-    deal(p, 7)
+    announce _("%{p} joins this game of %{uno}") % {
+      :p => p, :uno => UNO
+    }
+    deal(p, cards)
+    return if @start_time
     if @join_timer
       @bot.timer.reschedule(@join_timer, 10)
     elsif @players.length > 1
@@ -494,37 +728,145 @@ class UnoGame
     end
   end
 
-  def end_game
-    announce _("%{uno} game finished! The winner is %{p}") % {
-      :uno => UNO, :p => @players.first
+  def drop_player(nick)
+    # A nick is passed because the original player might have left
+    # the channel or IRC
+    unless p = get_player(nick)
+      announce _("%{p} isn't playing %{uno}") % {
+        :p => p, :uno => UNO
+      }
+      return
+    end
+    announce _("%{p} gives up this game of %{uno}") % {
+      :p => p, :uno => UNO
     }
-    if @picker > 0
-      p = @players[1]
+    case @players.length
+    when 2
+      if @join_timer
+        @bot.timer.remove(@join_timer)
+        announce _("game start countdown stopped")
+        @join_timer = nil
+      end
+      if p == @players.first
+        next_turn :silent => @start_time.nil?
+      end
+      if @start_time
+        end_game
+        return
+      end
+    when 1
+      end_game(true)
+      return
+    end
+    debug @stock.length
+    while p.cards.length > 0
+      @stock.insert(rand(@stock.length), p.cards.shift)
+    end
+    debug @stock.length
+    @dropouts << @players.delete_one(p)
+  end
+
+  def replace_player(old, new)
+    # The new user
+    user = channel.get_user(new)
+    if not user
+      announce _("there is no '%{nick}' here") % {
+        :nick => new
+      }
+      return false
+    end
+    if pl = get_player(user)
+      announce _("%{p} is already playing %{uno} here") % {
+        :p => pl, :uno => UNO
+      }
+      return false
+    end
+    # We scan the player list of the player with the old nick, instead
+    # of using get_player, in case of IRC drops etc
+    @players.each do |p|
+      if p.user.nick == old
+        p.user = user
+        announce _("%{p} takes %{b}%{old}%{b}'s place at %{uno}") % {
+          :p => p, :b => Bold, :old => old, :uno => UNO
+        }
+        return true
+      end
+    end
+    announce _("%{b}%{old}%{b} isn't playing %{uno} here") % {
+      :uno => UNO, :b => Bold, :old => old
+    }
+    return false
+  end
+
+  def end_game(halted = false)
+    runtime = @start_time ? Time.now -  @start_time : 0
+    if @join_timer
+      @bot.timer.remove(@join_timer)
+      announce _("game start countdown stopped")
+      @join_timer = nil
+    end
+    if halted
+      if @start_time
+        announce _("%{uno} game halted after %{time}") % {
+          :time => elapsed_time,
+          :uno => UNO
+        }
+      else
+        announce _("%{uno} game halted before it could start") % {
+          :uno => UNO
+        }
+      end
+    else
+      announce _("%{uno} game finished after %{time}! The winner is %{p}") % {
+        :time => elapsed_time,
+        :uno => UNO, :p => @players.first
+      }
+    end
+    if @picker > 0 and not halted
+      if @discard.value == 'Reverse'
+        p = @players.last
+      else
+        p = @players[1]
+      end
       announce _("%{p} has to pick %{b}%{n}%{b} cards!") % {
         :p => p, :n => @picker, :b => Bold
       }
       deal(p, @picker)
       @picker = 0
     end
-    score = @players.inject(0) do |sum, p|
-      if p.cards.length > 0
+    score = @players.inject(0) do |sum, pl|
+      if pl.cards.length > 0
         announce _("%{p} still had %{cards}") % {
-          :p => p, :cards => p.cards.join(' ')
+          :p => pl, :cards => pl.cards.join(' ')
         }
-        sum += p.cards.inject(0) do |cs, c|
+        sum += pl.cards.inject(0) do |cs, c|
           cs += c.score
         end
       end
       sum
     end
-    announce _("%{p} wins with %{b}%{score}%{b} points!") % {
+
+    closure = { :dropouts => @dropouts, :players => @players, :runtime => runtime }
+    if not halted
+      announce _("%{p} wins with %{b}%{score}%{b} points!") % {
         :p => @players.first, :score => score, :b => Bold
-    }
-    @plugin.end_game(@channel)
+      }
+      closure.merge!(:winner => @players.first, :score => score,
+        :opponents => @players.length - 1)
+    end
+
+    @plugin.do_end_game(@channel, closure)
   end
 
 end
 
+# A won game: store score and number of opponents, so we can calculate
+# an average score per opponent (requested by Squiddhartha)
+define_structure :UnoGameWon, :score, :opponents
+# For each player we store the number of games played, the number of
+# games forfeited, and an UnoGameWon for each won game
+define_structure :UnoPlayerStats, :played, :forfeits, :won
+
 class UnoPlugin < Plugin
   attr :games
   def initialize
@@ -533,34 +875,85 @@ class UnoPlugin < Plugin
   end
 
   def help(plugin, topic="")
-    (_("%{uno} game. !uno to start a game. in-game commands (no prefix): ") % {
-      :uno => UnoGame::UNO
-    }) + [
+    case topic
+    when 'commands'
+      [
       _("'jo' to join in"),
-      _("'pl <card>' to play <card>"),
+      _("'pl <card>' to play <card>: e.g. 'pl g7' to play Green 7, or 'pl rr' to play Red Reverse, or 'pl y2y2' to play both Yellow 2 cards"),
       _("'pe' to pick a card"),
       _("'pa' to pass your turn"),
-      _("'co <color>' to pick a color"),
+      _("'co <color>' to pick a color after playing a Wild: e.g. 'co g' to select Green (or 'pl w+4 g' to select the color when playing the Wild)"),
       _("'ca' to show current cards"),
       _("'cd' to show the current discard"),
+      _("'ch' to challenge a Wild +4"),
       _("'od' to show the playing order"),
       _("'ti' to show play time"),
       _("'tu' to show whose turn it is")
-    ].join(" ; ")
+    ].join("; ")
+    when 'challenge'
+      _("A Wild +4 can only be played legally if you don't have normal (not special) cards of the current color. ") +
+      _("The next player can challenge a W+4 by using the 'ch' command. ") +
+      _("If the W+4 play was illegal, the player who played it must pick the W+4, pick 4 cards from the stock, and play a legal card. ") +
+      _("If the W+4 play was legal, the challenger must pick 6 cards instead of 4.")
+    when 'rules'
+      _("play all your cards, one at a time, by matching either the color or the value of the currently discarded card. ") +
+      _("cards with special effects: Skip (next player skips a turn), Reverse (reverses the playing order), +2 (next player has to take 2 cards). ") +
+      _("Wilds can be played on any card, and you must specify the color for the next card. ") +
+      _("Wild +4 also forces the next player to take 4 cards, but it can only be played if you can't play a color card. ") +
+      _("you can play another +2 or +4 card on a +2 card, and a +4 on a +4, forcing the first player who can't play one to pick the cumulative sum of all cards. ") +
+      _("you can also play a Reverse on a +2 or +4, bouncing the effect back to the previous player (that now comes next). ")
+    when /scor(?:e|ing)/, /points?/
+      [
+      _("The points won with a game of %{uno} are totalled from the cards remaining in the hands of the other players."),
+      _("Each normal (not special) card is worth its face value (from 0 to 9 points)."),
+      _("Each colored special card (+2, Reverse, Skip) is worth 20 points."),
+      _("Each Wild and Wild +4 is worth 50 points."),
+      help(plugin, 'top'),
+      help(plugin, 'topwin'),
+      ].join(" ") % { :uno => UnoGame::UNO }
+    when 'top'
+      _("You can see the scoring table with 'uno top N' where N is the number of top scores to show.")
+    when 'topwin'
+      _("You can see the winners table with 'uno topwin N' where N is the number of top winners to show.")
+    when /cards?/
+      [
+      _("There are 108 cards in a standard %{uno} deck."),
+      _("For each color (Blue, Green, Red, Yellow) there are 19 numbered cards (from 0 to 9), with two of each number except for 0."),
+      _("There are also 6 special cards for each color, two each of +2, Reverse, Skip."),
+      _("Finally, there are 4 Wild and 4 Wild +4 cards.")
+      ].join(" ") % { :uno => UnoGame::UNO }
+    when 'admin'
+      _("The game manager (the user that started the game) can execute the following commands to manage it: ") +
+      [
+      _("'uno drop <user>' to drop a user from the game (any user can drop itself using 'uno drop')"),
+      _("'uno replace <old> [with] <new>' to replace a player with someone else (useful in case of disconnects)"),
+      _("'uno transfer [to] <nick>' to transfer game ownership to someone else"),
+      _("'uno end' to end the game before its natural completion")
+      ].join("; ")
+    else
+      _("%{uno} game. !uno to start a game. see 'help uno rules' for the rules, 'help uno admin' for admin commands, 'help uno score' for scoring rules. In-game commands: %{cmds}.") % {
+        :uno => UnoGame::UNO,
+        :cmds => help(plugin, 'commands')
+      }
+    end
   end
 
   def message(m)
     return unless @games.key?(m.channel)
+    return unless m.plugin # skip messages such as: <someuser> botname,
     g = @games[m.channel]
+    replied = true
     case m.plugin.intern
     when :jo # join game
+      return if m.params
       g.add_player(m.source)
     when :pe # pick card
+      return if m.params
       if g.has_turn?(m.source)
         if g.player_has_picked
           m.reply _("you already picked a card")
         elsif g.picker > 0
-          m.reply _("you can't pick a card")
+          g.pass(m.source)
         else
           g.pick_card(m.source)
         end
@@ -568,6 +961,7 @@ class UnoPlugin < Plugin
         m.reply _("It's not your turn")
       end
     when :pa # pass turn
+      return if m.params or not g.start_time
       if g.has_turn?(m.source)
         g.pass(m.source)
       else
@@ -586,41 +980,228 @@ class UnoPlugin < Plugin
         m.reply _("It's not your turn")
       end
     when :ca # show current cards
+      return if m.params
       g.show_all_cards(m.source)
     when :cd # show current discard
+      return if m.params or not g.start_time
       g.show_discard
-    # TODO
-    # when :ch
-    #   g.challenge
+    when :ch
+      if g.has_turn?(m.source)
+        if g.last_discard
+          g.challenge
+        else
+          m.reply _("previous move cannot be challenged")
+        end
+      else
+        m.reply _("It's not your turn")
+      end
     when :od # show playing order
+      return if m.params
       g.show_order
     when :ti # show play time
+      return if m.params
       g.show_time
     when :tu # show whose turn is it
+      return if m.params
       if g.has_turn?(m.source)
-        m.nickreply _("it's your turn, sleepyhead")
+        m.reply _("it's your turn, sleepyhead"), :nick => true
       else
         g.show_turn(:cards => false)
       end
+    else
+      replied=false
     end
+    m.replied=true if replied
   end
 
   def create_game(m, p)
     if @games.key?(m.channel)
-      m.reply _("There is already an %{uno} game running here, say 'jo' to join in") % { :uno => UnoGame::UNO }
+      m.reply _("There is already an %{uno} game running here, managed by %{who}. say 'jo' to join in") % {
+        :who => @games[m.channel].manager,
+        :uno => UnoGame::UNO
+      }
       return
     end
-    @games[m.channel] = UnoGame.new(self, m.channel)
+    @games[m.channel] = UnoGame.new(self, m.channel, m.source)
+    @bot.auth.irc_to_botuser(m.source).set_temp_permission('uno::manage', true, m.channel)
     m.reply _("Ok, created %{uno} game on %{channel}, say 'jo' to join in") % {
       :uno => UnoGame::UNO,
       :channel => m.channel
     }
   end
 
-  def end_game(channel)
+  def transfer_ownership(m, p)
+    unless @games.key?(m.channel)
+      m.reply _("There is no %{uno} game running here") % { :uno => UnoGame::UNO }
+      return
+    end
+    g = @games[m.channel]
+    old = g.manager
+    new = m.channel.get_user(p[:nick])
+    if new
+      g.manager = new
+      @bot.auth.irc_to_botuser(old).reset_temp_permission('uno::manage', m.channel)
+      @bot.auth.irc_to_botuser(new).set_temp_permission('uno::manage', true, m.channel)
+      m.reply _("%{uno} game ownership transferred from %{old} to %{nick}") % {
+        :uno => UnoGame::UNO, :old => old, :nick => p[:nick]
+      }
+    else
+      m.reply _("who is this %{nick} you want me to transfer game ownership to?") % p
+    end
+  end
+
+  def end_game(m, p)
+    unless @games.key?(m.channel)
+      m.reply _("There is no %{uno} game running here") % { :uno => UnoGame::UNO }
+      return
+    end
+    @games[m.channel].end_game(true)
+  end
+
+  def cleanup
+    @games.each { |k, g| g.end_game(true) }
+    super
+  end
+
+  def chan_reg(channel)
+    @registry.sub_registry(channel.downcase)
+  end
+
+  def chan_stats(channel)
+    stats = chan_reg(channel).sub_registry('stats')
+    class << stats
+      def store(val)
+        val.to_i
+      end
+      def restore(val)
+        val.to_i
+      end
+    end
+    stats.set_default(0)
+    return stats
+  end
+
+  def chan_pstats(channel)
+    pstats = chan_reg(channel).sub_registry('players')
+    pstats.set_default(UnoPlayerStats.new(0,0,[]))
+    return pstats
+  end
+
+  def do_end_game(channel, closure)
+    reg = chan_reg(channel)
+    stats = chan_stats(channel)
+    stats['played'] += 1
+    stats['played_runtime'] += closure[:runtime]
+    if closure[:winner]
+      stats['finished'] += 1
+      stats['finished_runtime'] += closure[:runtime]
+
+      pstats = chan_pstats(channel)
+
+      closure[:players].each do |pl|
+        k = pl.user.downcase
+        pls = pstats[k]
+        pls.played += 1
+        pstats[k] = pls
+      end
+
+      closure[:dropouts].each do |pl|
+        k = pl.user.downcase
+        pls = pstats[k]
+        pls.played += 1
+        pls.forfeits += 1
+        pstats[k] = pls
+      end
+
+      winner = closure[:winner]
+      won = UnoGameWon.new(closure[:score], closure[:opponents])
+      k = winner.user.downcase
+      pls = pstats[k] # already marked played +1 above
+      pls.won << won
+      pstats[k] = pls
+    end
+
+    @bot.auth.irc_to_botuser(@games[channel].manager).reset_temp_permission('uno::manage', channel)
     @games.delete(channel)
   end
 
+  def do_chanstats(m, p)
+    stats = chan_stats(m.channel)
+    np = stats['played']
+    nf = stats['finished']
+    if np > 0
+      str = _("%{nf} %{uno} games completed over %{np} games played. ") % {
+        :np => np, :uno => UnoGame::UNO, :nf => nf
+      }
+      cgt = stats['finished_runtime']
+      tgt = stats['played_runtime']
+      str << _("%{cgt} game time for completed games") % {
+        :cgt => Utils.secs_to_string(cgt)
+      }
+      if np > nf
+        str << _(" on %{tgt} total game time. ") % {
+          :tgt => Utils.secs_to_string(tgt)
+        }
+      else
+        str << ". "
+      end
+      str << _("%{avg} average game time for completed games") % {
+        :avg => Utils.secs_to_string(cgt/nf)
+      }
+      str << _(", %{tavg} for all games") % {
+        :tavg => Utils.secs_to_string(tgt/np)
+      } if np > nf
+      m.reply str
+    else
+      m.reply _("nobody has played %{uno} on %{chan} yet") % {
+        :uno => UnoGame::UNO, :chan => m.channel
+      }
+    end
+  end
+
+  def do_pstats(m, p)
+    dnick = p[:nick] || m.source # display-nick, don't later case
+    nick = dnick.downcase
+    ps = chan_pstats(m.channel)[nick]
+    if ps.played == 0
+      m.reply _("%{nick} never played %{uno} here") % {
+        :uno => UnoGame::UNO, :nick => dnick
+      }
+      return
+    end
+    np = ps.played
+    nf = ps.forfeits
+    nw = ps.won.length
+    score = ps.won.inject(0) { |sum, w| sum += w.score }
+    str = _("%{nick} played %{np} %{uno} games here, ") % {
+      :nick => dnick, :np => np, :uno => UnoGame::UNO
+    }
+    str << _("forfeited %{nf} games, ") % { :nf => nf } if nf > 0
+    str << _("won %{nw} games") % { :nw => nw}
+    if nw > 0
+      str << _(" with %{score} total points") % { :score => score }
+      avg = ps.won.inject(0) { |sum, w| sum += w.score/w.opponents }/nw
+      str << _(" and an average of %{avg} points per opponent") % { :avg => avg }
+    end
+    m.reply str
+  end
+
+  def replace_player(m, p)
+    unless @games.key?(m.channel)
+      m.reply _("There is no %{uno} game running here") % { :uno => UnoGame::UNO }
+      return
+    end
+    @games[m.channel].replace_player(p[:old], p[:new])
+  end
+
+  def drop_player(m, p)
+    unless @games.key?(m.channel)
+      m.reply _("There is no %{uno} game running here") % { :uno => UnoGame::UNO }
+      return
+    end
+    @games[m.channel].drop_player(p[:nick] || m.source.nick)
+  end
+
   def print_stock(m, p)
     unless @games.key?(m.channel)
       m.reply _("There is no %{uno} game running here") % { :uno => UnoGame::UNO }
@@ -632,10 +1213,91 @@ class UnoPlugin < Plugin
       :stock => stock.join(' ')
     }, :split_at => /#{NormalText}\s*/)
   end
+
+  def do_top(m, p)
+    pstats = chan_pstats(m.channel)
+    scores = []
+    wins = []
+    pstats.each do |k, v|
+      wins << [v.won.length, k]
+      scores << [v.won.inject(0) { |s, w| s+=w.score }, k]
+    end
+
+    if wins.empty?
+      m.reply(_("no %{uno} games were completed here") % {
+        :uno => UnoGame::UNO
+      })
+      return
+    end
+
+
+    if n = p[:scorenum]
+      msg = _("%{uno} %{num} highest scores: ") % {
+        :uno => UnoGame::UNO, :num => p[:scorenum]
+      }
+      scores.sort! { |a1, a2| -(a1.first <=> a2.first) }
+      scores = scores[0, n.to_i].compact
+      i = 0
+      if scores.length <= 5
+        list = "\n" + scores.map { |a|
+          i+=1
+          _("%{i}. %{b}%{nick}%{b} with %{b}%{score}%{b} points") % {
+            :i => i, :b => Bold, :nick => a.last, :score => a.first
+          }
+        }.join("\n")
+      else
+        list = scores.map { |a|
+          i+=1
+          _("%{i}. %{nick} ( %{score} )") % {
+            :i => i, :nick => a.last, :score => a.first
+          }
+        }.join(" | ")
+      end
+    elsif n = p[:winnum]
+      msg = _("%{uno} %{num} most wins: ") % {
+        :uno => UnoGame::UNO, :num => p[:winnum]
+      }
+      wins.sort! { |a1, a2| -(a1.first <=> a2.first) }
+      wins = wins[0, n.to_i].compact
+      i = 0
+      if wins.length <= 5
+        list = "\n" + wins.map { |a|
+          i+=1
+          _("%{i}. %{b}%{nick}%{b} with %{b}%{score}%{b} wins") % {
+            :i => i, :b => Bold, :nick => a.last, :score => a.first
+          }
+        }.join("\n")
+      else
+        list = wins.map { |a|
+          i+=1
+          _("%{i}. %{nick} ( %{score} )") % {
+            :i => i, :nick => a.last, :score => a.first
+          }
+        }.join(" | ")
+      end
+    else
+      msg = _("uh, what kind of score list did you want, again?")
+      list = _(" I can only show the top scores (with top) and the most wins (with topwin)")
+    end
+    m.reply msg + list, :max_lines => (msg+list).count("\n")+1
+  end
 end
 
 pg = UnoPlugin.new
 
 pg.map 'uno', :private => false, :action => :create_game
+pg.map 'uno end', :private => false, :action => :end_game, :auth_path => 'manage'
+pg.map 'uno drop', :private => false, :action => :drop_player, :auth_path => 'manage::drop::self!'
+pg.map 'uno giveup', :private => false, :action => :drop_player, :auth_path => 'manage::drop::self!'
+pg.map 'uno drop :nick', :private => false, :action => :drop_player, :auth_path => 'manage::drop::other!'
+pg.map 'uno replace :old [with] :new', :private => false, :action => :replace_player, :auth_path => 'manage'
+pg.map 'uno transfer [game [ownership]] [to] :nick', :private => false, :action => :transfer_ownership, :auth_path => 'manage'
 pg.map 'uno stock', :private => false, :action => :print_stock
+pg.map 'uno chanstats', :private => false, :action => :do_chanstats
+pg.map 'uno stats [:nick]', :private => false, :action => :do_pstats
+pg.map 'uno top :scorenum', :private => false, :action => :do_top, :defaults => { :scorenum => 5 }
+pg.map 'uno topwin :winnum', :private => false, :action => :do_top, :defaults => { :winnum => 5 }
+
 pg.default_auth('stock', false)
+pg.default_auth('manage', false)
+pg.default_auth('manage::drop::self', true)