minecraft 0.0.2 → 0.0.3

data/README.md

@@ -29,23 +29,27 @@ Current Features
   - Give the user an item with a quantity of up to 2560 (by default Minecraft
   will cap at 64).
   - Use the item ID or item name. http://minecraftwiki.net/wiki/Data_values
+- !giveall <item> <quantity>
 - !tp <target_user>
+- !tpall
 - !nom
-- !kit
+- !nomall
+- !kit <group>
   - Diamond
   - Gold armour
   - Armour
   - Ranged
   - Nether
   - Portal
+- !kitall <group>
+- !addtimer <item> <frequency>
+- !deltimer <item>
+- !printtimer
+- !list
 
 TODO
 ----
 
-- Improved error handling.
-- Log time users have spent on the server.
-- !give timers (give user A an item every X seconds).
-
 Contributors
 ------------
 

data/lib/minecraft.rb

@@ -1,5 +1,6 @@
 require "minecraft/tools"
 require "minecraft/data"
+require "minecraft/commands"
 require "minecraft/extensions"
 require "minecraft/server"
 

data/lib/minecraft/commands.rb

@@ -0,0 +1,143 @@
+module Minecraft
+  module Commands
+    include Data
+
+    def give(user, *args)
+      item, quantity = items_arg(1, args)
+      item = resolve_item(item)
+
+      quantify(user, item, quantity)
+    end
+
+    def validate_kit(group = "")
+      return true if KITS.include? group.to_sym
+      @server.puts "say #{group} is not a valid kit."
+      kitlist
+    end
+
+    def kit(user, group)
+      KITS[group.to_sym].each do |item|
+        if item.is_a? Array
+          @server.puts quantify(user, item.first, item.last)
+        else
+          @server.puts "give #{user} #{item} 1"
+        end
+      end
+    end
+
+    def tp(user, target)
+      @server.puts "tp #{user} #{target}"
+    end
+
+    def tpall(user, *args)
+      @users.each { |u| tp(u, user) }
+    end
+
+    def nom(user)
+      @server.puts "give #{user} 322 1"
+    end
+
+    def list(user)
+      l = @users.inject("") do |s, u|
+        if u == user
+          pre = "["
+          suf = "]"
+        end
+        suf = "*" + (suf || "") if is_op? u
+        s + "#{", " unless s.empty?}#{pre}#{u}#{suf}"
+      end
+      @server.puts "say #{l}"
+    end
+
+    def addtimer(user, *args)
+      item, duration = items_arg(30, args)
+      item = resolve_item(item)
+      @timers[user] ||= {}
+      @timers[user][item] = duration
+      @server.puts "say Timer added for #{user}.  Giving #{item} every #{duration} seconds."
+    end
+
+    def deltimer(user, *args)
+      item = args.join(" ")
+      item = resolve_item(item)
+      @timers[user][item] = nil if @timers.has_key? user
+    end
+
+    def printtimer(user)
+      @server.puts "say Timer is at #{@counter}."
+    end
+
+    def help(*args)
+      @server.puts <<-eof
+say !tp target_user
+say !kit kit_name
+say !give item quantity
+say !nom
+say !list
+say !addtimer item frequency
+say !deltimer item
+      eof
+    end
+
+    def kitlist(*args)
+      @server.puts "say Kits: #{KITS.keys.join(", ")}"
+    end
+
+    def quantify(user, item, quantity)
+      if quantity <= 64
+        @server.puts "give #{user} #{item} #{quantity}"
+        return
+      end
+
+      quantity = 2560 if quantity > 2560
+      full_quantity = (quantity / 64.0).floor
+      sub_quantity  = quantity % 64
+      @server.puts "give #{user} #{item} 64\n" * full_quantity
+      @server.puts "give #{user} #{item} #{sub_quantity}" if sub_quantity > 0
+    end
+
+    def items_arg(default, args)
+      if args.length == 1
+        second = default
+        first  = args.first
+      else
+        if args.last.to_i.to_s == args.last # Last argument is an integer.
+          second = args.last.to_i
+          first  = args[0..-2].join(" ")
+        else
+          second = default
+          first = args[0..-1].join(" ")
+        end
+      end
+      return [first, second]
+    end
+
+    def resolve_item(item)
+      item.to_i.to_s == item ? item.to_i : DATA_VALUE_HASH[resolve_key(item.downcase)]
+    end
+
+    def resolve_key(key)
+      bucket = key[0]
+      return key if ITEM_BUCKETS[bucket].include? key
+
+      puts "Finding #{key} approximate in #{ITEM_BUCKETS[bucket]}"
+      shortest_diff = nil
+      shortest_key  = nil
+      ITEM_BUCKETS[bucket].each do |test_key|
+        if test_key.length > key.length
+          diff = test_key.length - key.length if test_key.index(key)
+        else
+          diff = key.length - test_key.length if key.index(test_key)
+        end
+        next if diff.nil?
+
+        if shortest_diff.nil? or diff < shortest_diff
+          shortest_key = test_key
+          shortest_diff = diff
+        end
+      end
+
+      return shortest_key
+    end
+  end
+end

data/lib/minecraft/data.rb

@@ -70,7 +70,7 @@ module Minecraft
       "lava"                    => "10",
       "dead shrubs"             => "32",
       "double stone slab"       => "43",
-      "furnace "                => "61",
+      "furnace"                 => "61",
       "fence"                   => "85",
       "stationary lava "        => "11",
       "piston"                  => "33",
@@ -246,5 +246,12 @@ module Minecraft
       "saddle"                  => "329",
       "cocoa beans"             => "351"
     }
+
+    ITEM_BUCKETS = {}
+    DATA_VALUE_HASH.each_key do |key|
+      bucket = key[0]
+      ITEM_BUCKETS[bucket] ||= []
+      ITEM_BUCKETS[bucket] << key
+    end
   end
 end

data/lib/minecraft/extensions.rb

@@ -1,31 +1,108 @@
+require "json/pure"
+
 module Minecraft
   class Extensions
-    include Data
+    include Commands
 
-    def initialize
-      @ops = File.readlines("ops.txt").map { |s| s.chop }
+    def initialize(server)
+      @ops = File.readlines("ops.txt").map { |s| s.chomp }
+      @userlog = get_user_log
       @users = []
+      @timers = {}
+      @counter = 0
+      @logon_time = {}
+      @server = server
+
+      # Command set.
+      @commands = {}
+      add_command(:give, :ops => true,  :all => true, :all_message => "is putting out.")
+      add_command(:tp,   :ops => false, :all => true, :all_message => "is teleporting all users to their location.")
+      add_command(:kit,  :ops => true,  :all => true, :all_message => "is providing kits to all.")
+      add_command(:help, :ops => false, :all => false)
+      add_command(:nom,  :ops => true,  :all => true, :all_message => "is providing noms to all.")
+      add_command(:list, :ops => false, :all => false)
+      add_command(:addtimer,   :ops => true,  :all => false)
+      add_command(:deltimer,   :ops => true,  :all => false)
+      add_command(:printtimer, :ops => true,  :all => false)
+      add_command(:kitlist,    :ops => false, :all => false)
+    end
+
+    def get_user_log
+      if File.exists? "user.log"
+        JSON.parse(File.read("user.log"))
+      else
+        {}
+      end
+    end
+
+    def write_log
+      File.open("user.log", "w") { |f| f.print @userlog.to_json }
+    end
+
+    def call_command(user, command, *args)
+      is_all = command.to_s.end_with? "all"
+      root   = command.to_s.chomp("all").to_sym
+      return invalid_command(command) unless @commands.include? root
+
+      # Any `all` suffixed command requires ops.
+      if @commands[root][:ops] or (is_all and @commands[root][:all])
+        return if !validate_ops(user, command)
+      end
+
+      if respond_to? "validate_" + root.to_s
+        return unless send("validate_" + root.to_s, *args)
+      end
+
+      if is_all
+        @server.puts "say #{user} #{@commands[root][:all_message]}"
+        if respond_to? command
+          send(command, user, *args)
+        else
+          @users.each { |u| send(root, u, *args) }
+        end
+      else
+        send(root, user, *args)
+      end
+    end
+
+    def add_command(command, opts)
+      @commands[command] = opts
     end
 
     def process(line)
       puts line
       return info_command(line) if line.index "INFO"
+    rescue Exception => e
+      puts "An error has occurred."
+      puts e
+      puts e.backtrace
+    end
+
+    def periodic
+      @counter += 1
+      @users.each do |user|
+        next unless @timers.has_key? user
+        @timers[user].each do |item, duration|
+          next if duration.nil?
+          @server.puts "give #{user} #{item} 64" if @counter % duration == 0
+        end
+      end
     end
 
     def info_command(line)
       line.gsub! /^.*?\[INFO\]\s+/, ''
-      meta_check(line)
+      return if meta_check(line)
       match_data = line.match /^\<(.*?)\>\s+!(.*?)$/
       return if match_data.nil?
 
       user = match_data[1]
       args = match_data[2].split(" ")
-      return send(args.slice!(0), user, *args)
+      call_command(user, args.slice!(0).to_sym, *args)
     end
 
     def meta_check(line)
-      return if check_ops(line)
-      return if check_join_part(line)
+      return true if check_ops(line)
+      return true if check_join_part(line)
     end
 
     def check_ops(line)
@@ -43,111 +120,44 @@ module Minecraft
       user = line.split(" ").first
       if line.index "lost connection"
         @users.reject! { |u| u == user }
+        log_time(user)
         return true
       elsif line.index "logged in"
         @users << user
+        @logon_time[user] = Time.now
         return true
       end
     end
 
     def method_missing(sym, *args)
-      if DATA_VALUE_HASH.has_key? sym.downcase
+      if DATA_VALUE_HASH.has_key? sym.downcase and is_op? args.first
         give(args.first, sym, args.last)
       else
         puts "Invalid command given."
       end
     end
 
-    def giveall(user, *args)
-      return privilege_error(user, "giveall") unless is_op? user
-      ret = "say #{user} is putting out!\n"
-      @users.each do |u|
-        ret += mc_give(u, *args)
-      end
-
-      return ret
-    end
-
-    def give(user, *args)
-      return privilege_error(user, "give") unless is_op? user
-      return mc_give(user, *args)
-    end
-
-    def mc_give(user, *args)
-      if args.length == 1
-        quantity = 1
-        item = args.first
-      else
-        quantity = args.last.to_i || 1
-        item = args[0..-2].join(" ")
-      end
-      item = (item.to_i.to_s == item) ? item.to_i : DATA_VALUE_HASH[item.downcase]
-
-      return quantify(user, item, quantity)
-    end
-
-    def kit(user, group)
-      return privilege_error(user, "kit") unless is_op? user
-      return "say #{group} is not a valid kit." unless KITS.has_key? group.to_sym
-      ret = ""
-
-      KITS[group.to_sym].each do |item|
-        if item.is_a? Array
-          ret += quantify(user, item.first, item.last)
-        else
-          ret += "give #{user} #{item} 1\n"
-        end
-      end
-      return ret.chop
-    end
-
-    def tp(user, target)
-      "tp #{user} #{target}"
-    end
-
-    def tpall(user)
-      return privilege_error(user, "tpall", "Wow, #{user} actually tried to pull that...") unless is_op? user
-      ret = "say #{user} is teleporting all users to their location.\n"
-      @users.each do |u|
-        ret += tp(u, user)
-      end
-      return ret
-    end
-
-    def nom(user)
-      return privilege_error(user, "nom", "No noms for you!") unless is_op? user
-      "give #{user} 322 1"
-    end
-
-    def help(*args)
-      <<-eof
-say !tp target_user
-say !tpall
-say !kit kit_name
-say !give item quantity
-say !giveall item quantity
-say !nom
-say /help
-      eof
-    end
-
-    def quantify(user, item, quantity)
-      return "give #{user} #{item} #{quantity}" if quantity <= 64
-
-      quantity = 2560 if quantity > 2560
-      full_quantity = (quantity / 64.0).floor
-      sub_quantity  = quantity % 64
-      ret = "give #{user} #{item} 64\n" * full_quantity
-      ret += "give #{user} #{item} #{sub_quantity}"
-      return ret
+    def log_time(user)
+      logoff = Time.now
+      logon  = @logon_time[user]
+      time_spent = logoff - logon
+      @userlog[user] ||= 0
+      @userlog[user] += time_spent
+      @server.puts "say #{user} spent #{time_spent} seconds the server, totalling to #{@userlog[user]}."
+      write_log
     end
 
     def is_op?(user)
       @ops.include? user
     end
 
-    def privilege_error(user, command, suffix = "S/he must be humiliated!")
-      "say #{user} is not an op, cannot use !#{command}.  #{suffix}"
+    def validate_ops(user, command)
+      return true if is_op? user
+      @server.puts "say #{user} is not an op, cannot use !#{command}."
+    end
+
+    def invalid_command(command)
+      @server.puts "say #{command} is invalid."
     end
   end
 end

data/lib/minecraft/server.rb

@@ -5,18 +5,14 @@ module Minecraft
     attr_accessor :sin
 
     def initialize(command)
-      @extensions = Extensions.new
       @sin, @sout, @serr = Open3.popen3(command)
+      @extensions = Extensions.new(@sin)
       threads = []
-      threads << Thread.new { loop { process(@sout.gets) } }
-      threads << Thread.new { loop { process(@serr.gets) } }
+      threads << Thread.new { loop { @extensions.process(@sout.gets) } }
+      threads << Thread.new { loop { @extensions.process(@serr.gets) } }
+      threads << Thread.new { loop { @extensions.periodic; sleep 1 } }
       threads << Thread.new { loop { @sin.puts gets } }
       threads.each(&:join)
     end
-
-    def process(line)
-      result = @extensions.process(line)
-      @sin.puts(result) unless result.nil?
-    end
   end
 end

data/lib/minecraft/version.rb

@@ -1,3 +1,3 @@
 module Minecraft
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

metadata

@@ -2,7 +2,7 @@
 name: minecraft
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Andrew Horsman
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-13 00:00:00 -04:00
+date: 2011-08-14 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,6 +40,7 @@ files:
 - Rakefile
 - bin/minecraft
 - lib/minecraft.rb
+- lib/minecraft/commands.rb
 - lib/minecraft/data.rb
 - lib/minecraft/extensions.rb
 - lib/minecraft/server.rb