Olib 0.0.3 → 0.0.4

data/lib/Olib/shops.rb

@@ -0,0 +1,175 @@
+module Olib
+  module Shop
+
+    @@containers = []
+
+    def Shop.items
+      Shop.containers.map { |container| container.contents }.flatten
+    end
+
+    def Shop.containers
+      #fput "look"
+      @@containers = [
+        GameObj.loot, 
+        GameObj.room_desc
+      ]
+      .flatten
+      .compact
+      .map        { |container| Shop::Container.new(container)  }
+
+      @@containers
+
+    end
+
+    def Shop.cache
+      @@containers
+    end
+
+    class Container < Olib::Gameobj_Extender
+      attr_accessor :show, :nested, :containers, :id, :cache, :props
+
+      def to_s
+        info = {}
+        info[:name]     = @name
+        info[:noun]     = @noun
+        info[:props]    = @props
+        info[:cache]    = @cache
+        info.to_s
+      end
+      
+      def initialize(obj)
+        @cache = Hash.new
+        @props = Hash.new
+        super(obj)
+      end
+
+      def action(verb)
+        "#{verb} ##{@id}"
+      end
+
+      def look
+        self
+      end
+
+      # detect nested containers
+      def at
+        
+        Olib.wrap_stream(action 'look at') { |line|
+          
+          raise Olib::Errors::Mundane if line =~ /You see nothing unusual/
+
+          if line =~ /Looking at the (.*?), you see (?<nested>.*)/
+            @nested     = true
+
+            @containers = line.match(/Looking at the (.*?), you see (?<nested>.*)/)[:nested].scan(/<a exist="(?<id>.*?)" noun="(?<noun>.*?)">(?<name>.*?)<\/a>/).map {|matches| 
+              Container.new GameObj.new *matches
+            }
+            raise Olib::Errors::Prempt
+          end
+          
+        }
+
+        self
+      end
+
+      def nested?
+        @nested || false
+      end
+
+      def in
+        return self unless @id
+        Olib.wrap_stream(action 'look in') { |line|
+          raise Olib::Errors::Mundane if line=~ /^There is nothing in there|^That is closed|filled with a variety of garbage|Total items:/
+          raise Olib::Errors::Prempt  if line =~ /^In the (.*?) you see/
+        }
+        self
+      end
+
+      def on
+        return self unless @id
+        Olib.wrap_stream(action 'look on') { |line|
+          raise Olib::Errors::Mundane if line =~ /^There is nothing on there/
+          raise Olib::Errors::Prempt  if line =~ /^On the (.*?) you see/
+        }
+        self
+      end
+
+      def contents
+        look.in.on unless GameObj[@id].contents
+        GameObj[@id].contents.map {|i| Item.new(i).define('container', @id) }
+      end
+
+      def containers
+        @containers
+      end 
+    end
+    
+    class Playershop
+      @@noncontainers = [ "wall", "ceiling", "permit", "floor", "helmet", "snowshoes",
+                      "candelabrum", "flowerpot", "Hearthstone", "bear", "candelabra",
+                      "sculpture", "anvil", "tapestry", "portrait", "Wehnimer", "spiderweb",
+                      "rug", "fountain", "longsword", "ship", "panel", "painting", "armor",
+                      "flowers", "head", "plate", "vase", "pillows", "mask", "skeleton", "fan",
+                      "flag", "statue", "mat", "plaque", "mandolin", "plant", "sign" ]
+      
+      def Playershop.containers
+        Shop.containers.reject { |container|
+          @@noncontainers.include? container.noun
+        }
+      end
+
+      def Playershop.balance
+        balance = 0
+        Olib.wrap_stream('shop withdraw') { |line|
+          next if line =~ /^Usage: SHOP WITHDRAW <amount>/
+          raise Olib::Errors::Prempt if line =~ /^You must be in your shop to do that.$/
+
+          if line =~ /Your shop's bank account is currently ([\d]+)/
+            balance = $1.to_i
+            raise Olib::Errors::Prempt
+          end
+
+        }
+        return balance
+      end
+
+      def Playershop.where(conditions)        
+        Playershop.items.select { |item|
+          conditions.keys.map { |key|
+            item.respond_to?(key) ? item.send(key) == conditions[key] : false
+            
+          }.include? false
+          
+        }
+        
+      end
+
+      def Playershop.find_by_tags(*tags)
+        
+        Playershop.items.select { |item|
+          !tags.map {|tag| item.is?(tag) }.include? false
+        }
+      end
+
+      def Playershop.sign
+        Shop.containers.select { |container|
+          container.noun == 'sign'
+        }[0]
+      end
+
+      def Playershop.items
+        Playershop.containers.map { |container|
+          container.contents
+        }.flatten
+      end
+    end
+  end
+
+  def Olib.Playershop
+    Olib::Shop::Playershop
+  end
+
+  def Olib.Shop
+    Olib::Shop
+  end
+end

data/lib/Olib/transport.rb

@@ -2,27 +2,47 @@ module Olib
 
   class Transport
 
-    attr_accessor :origin, :silvers, :teleporter
+    @@silvers    = 0
+    @@teleporter = {}
+    @@routines   = {}
 
-    def initialize
-      rebase
-      @teleporter        = {}
-      self.__constructor__
-      return self
+    def Transport.__extend__
+      singleton = (class << self; self end)
+      [
+        'bank', 'gemshop', 'pawnshop', 'advguild', 'forge', 'inn', 'npchealer',
+        'chronomage', 'town', 'furrier', 'herbalist', 'locksmith', 'alchemist',
+        'fletcher', 'sunfist', 'movers', 'consignment', 'advguard','advguard2',
+        'clericshop', 'warriorguild'
+      ].each do |target|
+        singleton.send :define_method, "go2_#{target}".to_sym do
+
+          unhide if hidden?
+          unless Room.current.tags.include?(target)
+            start_script 'go2', [target, '_disable_confirm_']
+            wait_while { running? "go2" };
+          end
+          return self
+        end
+      end
     end
 
-    def rebase
-      @origin            = {}
-      @origin[:roomid]   = Room.current.id
-      @origin[:hidden]   = hiding?
-      @origin[:location] = Room.current.location
+    Transport.__extend__
+
+    def Transport.rebase
+      @@origin            = {}
+      @@origin[:roomid]   = Room.current.id
+      @@origin[:hidden]   = hiding?
+      @@origin[:location] = Room.current.location
       self
     end
 
+    Transport.rebase
+
+
     # Thanks Tillmen
-    def cost(to)
+    def Transport.cost(to)
       cost = 0
-      Map.findpath(Room.current.id, @to).each { |id|
+      Map.findpath(Room.current.id, to).each { |id|
         Room[id].tags.each { |tag|          
           if tag =~ /^silver-cost:#{id-1}:(.*)$/
             cost_string = $1
@@ -39,58 +59,62 @@ module Olib
 
     # use the teleporter variable to locate your teleporter and teleport
     # naive of where you are
-    def fwi_teleport
-      unless @teleporter[:item]
-        setting           = 'teleporter'
-        if UserVars.send(setting).nil? or UserVars.send(setting).empty?
-          echo "error: #{setting.to_s} is not set. (;vars set #{setting.to_s}=<teleporter>)" 
-        else
-          #echo "locating teleporter..."
-          GameObj.containers.map do |container, contents| 
-            contents.each do |item|
-              if item.full_name =~ /#{UserVars.send(setting)}/
-                respond @item
-                @teleporter[:container] = container
-                @teleporter[:item]      = item
-              end
-            end
-          end
-        end
+    def Transport.fwi_teleport
+      unless Vars.teleporter
+        echo "Error: No teleport defined ;var set teleporter=<teleporter>"
+        exit
+      end
+      
+      unless Inventory.teleporter
+        echo "Error: Your teleporter could not be found #{Vars.teleporter}"
+        exit
+      end
+
+      last = Room.current.id
+      teleporter = Inventory.teleporter
+      if teleporter.worn?
+        teleporter.turn
+      else
+        teleporter.take.turn.stash
+      end
+
+      if Room.current.id == last
+        echo "Error: You tried to teleport to FWI in a room that does not allow that"
       end
-      multifput "get ##{@teleporter[:item].id}", "turn ##{@teleporter[:item].id}", "_drag ##{@teleporter[:item].id} ##{@teleporter[:container]}" if @teleporter[:item]
+
       self
     end
 
-    def wealth
+    def Transport.wealth
       fput "info"
       while(line=get)
         next                if line =~ /^\s*Name\:|^\s*Gender\:|^\s*Normal \(Bonus\)|^\s*Strength \(STR\)\:|^\s*Constitution \(CON\)\:|^\s*Dexterity \(DEX\)\:|^\s*Agility \(AGI\)\:|^\s*Discipline \(DIS\)\:|^\s*Aura \(AUR\)\:|^\s*Logic \(LOG\)\:|^\s*Intuition \(INT\)\:|^\s*Wisdom \(WIS\)\:|^\s*Influence \(INF\)\:/
         if line =~ /^\s*Mana\:\s+\-?[0-9]+\s+Silver\:\s+([0-9]+)/
-          @silvers= $1.to_i
+          @@silvers= $1.to_i
           break
         end
         sleep 0.1
       end
-      @silvers
+      @@silvers
     end
 
-    def deplete(silvers)
-      @silvers = @silvers - silvers
+    def Transport.deplete(silvers)
+      @@silvers = @@silvers - silvers
     end
 
-    def smart_wealth
-      return @silvers if @silvers 
-      @wealth
+    def Transport.smart_wealth
+      return @@silvers if @@silvers 
+      @@wealth
     end
 
-    def unhide
-      fput 'unhide' if Spell[9003].active? or hidden?
+    def Transport.unhide
+      fput 'unhide' if Spell[916].active? or hidden?
       self
     end
 
-    def withdraw(amount)
+    def Transport.withdraw(amount)
       go2_bank
-      result = Olib.do "withdraw #{amount} silvers", /I'm sorry|then hands you/
+      result = Olib.do "withdraw #{amount} silvers", /I'm sorry|hands you/
       if result =~ /I'm sorry/ 
         go2_origin
         echo "Unable to withdraw the amount requested for this script to run from your bank account"
@@ -99,14 +123,14 @@ module Olib
       return self
     end
 
-    def deposit_all
+    def Transport.deposit_all
       self.go2_bank
       fput "unhide" if invisible? || hidden?
       fput "deposit all"
       return self
     end
 
-    def deposit(amt)
+    def Transport.deposit(amt)
       self.go2_bank
       fput "unhide" if invisible? || hidden?
       fput "deposit #{amt}"
@@ -115,13 +139,13 @@ module Olib
 
     # naive share
     # does not check if you're actually in a group or not
-    def share
+    def Transport.share
       wealth
       fput "share #{@silvers}"
       self
     end
 
-    def go2(roomid)
+    def Transport.go2(roomid)
       unhide if hidden
       unless Room.current.id == roomid
         start_script 'go2', [roomid, '_disable_confirm_']
@@ -130,49 +154,26 @@ module Olib
       return self
     end
 
-    def hide
-      while not hiding?
-        waitrt?
-        fput 'hide'
-      end
-    end
-
-    def __constructor__
-      singleton = (class << self; self end)
-      [
-        'bank', 'gemshop', 'pawnshop', 'advguild', 'forge', 'inn', 'npchealer',
-        'chronomage', 'town', 'furrier', 'herbalist', 'locksmith', 'alchemist',
-        'fletcher', 'sunfist', 'movers', 'consignment', 'advguard','advguard2',
-        'clericshop', 'warriorguild'
-      ].each do |target|
-        singleton.send :define_method, "go2_#{target}".to_sym do
-
-          unhide if hidden?
-          unless Room.current.tags.include?(target)
-            start_script 'go2', [target, '_disable_confirm_']
-            wait_while { running? "go2" };
-          end
-          return self
-        end
-      end
-    end
-
     # TODO
     # create a dictionary of house lockers and the logic to enter a locker
     # insure locker is closed before scripting away from it
-    def go2_locker
+    def Transport.go2_locker
       echo "the go2_locker method currently does not function properly..."
       self
     end
 
-    def go2_origin
-      if Room.current.id != @origin[:roomid]
+    def Transport.go2_origin
+      if Room.current.id != @@origin[:roomid]
         start_script 'go2', [@origin[:roomid]]
         wait_while { running? "go2" };
       end
-      hide if @origin[:hidden]
+      hide if @@origin[:hidden]
       return self
     end    
 
   end
+
+  def Olib.Transport
+    Olib::Transport
+  end
 end

data/lib/Olib/utils.rb

@@ -0,0 +1,223 @@
+require "Olib"
+
+module Olib
+  @@debug  = false
+  @@xml    = false
+
+  class ScriptVars
+    attr_accessor :opts
+    def initialize
+      opts          = {}
+      opts[:flags]  = {}
+      return opts if Script.current.vars.empty?
+      list          = Script.current.vars.map(&:downcase).last(Script.current.vars.length-1)
+      unless list.first.start_with?('--')
+        opts[:cmd]   = list.shift
+      end
+      # iterate over list for flag values
+      
+      list.each.with_index {|ele, i|
+        if ele.start_with?('--')
+          opts[:flags][ symbolize(ele) ] = ''
+        else
+          # cast to Number if is number
+          ele = ele.to_i if ele =~ /^([\d\.]+$)/
+          # look back to previous flag and set it to it's value
+          opts[:flags][ symbolize(list[i-1]) ] = ele
+        end
+      }
+      
+      @opts = opts
+      self
+    end
+
+    def cmd
+      @opts[:cmd]
+    end
+
+    def empty?(flag)
+      opts[:flags][flag].class == TrueClass || opts[:flags][flag].class == NilClass
+    end
+
+    def cmd?(action)
+      cmd == action
+    end
+
+    def symbolize(flag)
+      flag.gsub('--', '').gsub('-', '_').to_sym
+    end
+
+    def help?
+      cmd =~ /help/
+    end
+
+    def flags
+      opts[:flags].keys
+    end
+
+    def to_s
+      @opts.to_s
+    end
+
+    def flag
+      self
+    end
+
+    def flag?(f)
+      opts[:flags][ symbolize(f) ]
+    end
+
+    def method_missing(arg1, arg2=nil)
+      @opts[:flags][arg1]
+    end
+  
+  end
+
+  def Olib.vars
+    ScriptVars.new
+  end
+  
+
+  def Olib.toggle_debug
+    @@debug = @@debug ? false : true 
+  end
+
+  def Olib.debug(msg)
+    return unless @@debug
+    echo "Olib.debug> #{msg}"
+  end
+
+  def Olib.timeout(sec)   #:yield: +sec+
+    return yield(sec) if sec == nil or sec.zero?
+  
+    begin
+      current_thread = Thread.current
+      x = Thread.start{ 
+        begin
+          yield(sec)
+        rescue => e 
+          current_thread.raise e
+        end
+      }
+      y = Thread.start {
+        begin
+          sleep sec
+        rescue => e
+          x.raise e
+        else
+          x.kill
+          current_thread.raise Olib::Errors::TimedOut
+        end
+      }
+      x.value
+    ensure
+      if y
+        y.kill
+        y.join # make sure y is dead.
+      end
+    end
+    
+  end
+
+  def Olib.script
+    Script.current
+  end
+
+  def Olib.turn_on_xml
+    if not @@xml
+      @@xml = true
+      Script.current.want_downstream_xml = @@xml
+    end
+    self
+  end
+
+  def Olib.turn_off_xml
+    if @@xml
+      @@xml = false
+      Script.current.want_downstream_xml = @@xml
+    end
+    self
+  end
+
+  def Olib.xml?
+    @@xml
+  end
+
+  def Olib.wrap(action)
+    
+    begin
+      Olib.timeout(3) {
+        put action
+        while (line=get)
+          next if Dictionary.ignorable?(line)
+          # attempt at removing PC action that turned out to be more harmful than good
+          # next if not GameObj.pcs.nil? and line =~ /#{GameObj.pcs.join('|')}/
+          yield line
+        end
+      }
+
+    rescue Olib::Errors::TimedOut
+      Olib.debug "timeout... "
+      # Silent
+    rescue Olib::Errors::Mundane => e
+
+    rescue Olib::Errors::Prempt => e
+      
+    end
+    
+  end
+
+  def Olib.wrap_greedy(action)
+    
+    begin
+      Olib.timeout(3) {
+        put action
+        while (line=get)
+          #next if not GameObj.pcs.nil? and line =~ /#{GameObj.pcs.join('|')}/
+          yield line
+        end
+      }
+
+    rescue Olib::Errors::TimedOut
+      Olib.debug "timeout... "
+      # Silent
+    rescue Olib::Errors::Mundane => e
+
+    rescue Olib::Errors::Prempt => e
+      
+    end
+    
+  end
+
+  def Olib.exit
+    raise Olib::Errors::Mundane
+  end
+
+  def Olib.wrap_stream(action, seconds=3)
+    begin
+      Olib.turn_on_xml
+
+      Olib.timeout(seconds) {
+        put action
+        while (line=get)
+          next if     Olib::Dictionary.ignorable?(line)
+          # next if not GameObj.pcs.nil? and line =~ /#{GameObj.pcs.join('|')}/
+          yield line
+        end
+      }
+  
+    rescue Olib::Errors::TimedOut
+      Olib.debug "timeout... "
+      # Silent
+
+    rescue Olib::Errors::Mundane => e
+      Olib.debug "mundane..."
+
+    rescue Olib::Errors::Prempt => e
+      Olib.debug "waiting prempted..."
+
+    ensure
+      Olib.turn_off_xml
+    end
+  end
+end