Olib 0.1.2 → 2.0.0.pre.rc.1

data/lib/Olib/core/kinds.rb

@@ -0,0 +1,6 @@
+require "Olib/core/exist"
+require "Olib/core/item"
+
+module Kinds
+
+end

data/lib/Olib/core/rummage.rb

@@ -0,0 +1,42 @@
+
+class Rummage
+  SUCCESS = /and remove/
+  FAIL    = /but can't seem|^But your hands are full|^You can only rummage for|^What/
+
+  @@message = OpenStruct.new(
+    success: SUCCESS,
+    fail:    FAIL,
+    either:  Regexp.union(SUCCESS, FAIL)
+  )
+
+  def self.message
+    @@message
+  end
+
+  attr_accessor :container
+
+  def initialize(container)
+    @container = container
+  end
+
+  def perform(mod, query)
+    res = Olib.do "rummage ##{@container.id} #{mod} #{query}", Rummage.message.either
+    [!res.match(FAIL), res]
+  end
+
+  def spell(number)
+    perform "spell", number
+  end
+
+  def runestone(rune)
+    perform "runestone", rune
+  end
+
+  def ingredient(str)
+    perform "ingredient", str
+  end
+
+  def holy(tier)
+    perform "holy", tier
+  end
+end

data/lib/Olib/core/transaction.rb

@@ -0,0 +1,53 @@
+require "Olib/pattern_matching/rill"
+
+class Transaction < Exist
+  Appraise = Rill.new(
+    start: %[to appraise (?:a |an |)<a exist="{{id}}"],
+    close: Regexp.union(
+      %r[I already appraised that],
+      %r[(I'll give you|How's|I'll offer you|worth at least) (?<value>\d+)],
+      %r[(?<value>\d+) silvers])
+    )
+  
+  Sell = Rill.new(
+    start: %[You offer|You ask (?<merchant>.*?) if (he|she) would like to buy (?:a |an |)<a exist="{{id}}"],
+    close: Regexp.union(
+      %r[(hands you|for) (?<value>\d+)],
+      %r[No #{Char.name}, I won't buy that],
+      %r[basically worthless here, #{Char.name}])
+    )
+  
+  attr_reader :value,
+              :threshold
+
+  def initialize(item, **args)
+    super(item)
+    @threshold = args.fetch(:threshold, false)
+  end
+
+  def take()
+    Item.new(self).take
+    self
+  end
+
+  def appraise()
+    return self unless @value.nil?
+    take
+    (match, _lines) = Appraise.capture(self.to_h, 
+      "appraise \#{{id}}")
+    @value = match[:value].to_i
+    self
+  end
+
+  def sell()
+    take
+    if @threshold && appraise && @value > @threshold
+      return Err[
+        transaction: self,
+        reason:      "Value[#{@value}] is over Threshold[#{@threshold}]"] 
+    end
+    (match, _lines) = Sell.capture(self.to_h, 
+      "sell \#{{id}}")
+    Ok[**match]
+  end
+end

data/lib/Olib/core/use.rb

@@ -1,16 +1,14 @@
 class Use
-  
   attr_accessor :item
   
   def initialize(item, &block)
+    fail Exception, "Use(#{item}) did not have a container" if item.container.nil?
     @item = item
     both(&block) if block
   end
 
   def run(&block)
-    Try.new do
-      yield @item
-    end
+    yield @item
     @item.container.add(@item)
   end
 
@@ -35,5 +33,4 @@ class Use
     run &block
     fill_hands
   end
-
 end

data/lib/Olib/core/utils.rb

@@ -1,88 +1,9 @@
 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}"
+  @@xml = false
+  # invoke update notifier immediately
+  # Olib.update_notifier
+  def Olib.do(action, re)
+    dothistimeout action, 5, re
   end
 
   def Olib.timeout(sec)   #:yield: +sec+
@@ -104,7 +25,7 @@ module Olib
           x.raise e
         else
           x.kill
-          current_thread.raise Olib::Errors::TimedOut
+          current_thread.raise Errors::TimedOut
         end
       }
       x.value
@@ -117,10 +38,6 @@ module Olib
     
   end
 
-  def Olib.script
-    Script.current
-  end
-
   def Olib.turn_on_xml
     if not @@xml
       @@xml = true
@@ -142,9 +59,8 @@ module Olib
   end
 
   def Olib.wrap(action = nil)
-    
     begin
-      Olib.timeout(3) {
+      Olib.timeout(3) do
         put action if action
         while (line=get)
           next if Dictionary.ignorable?(line)
@@ -152,43 +68,33 @@ module Olib
           # next if not GameObj.pcs.nil? and line =~ /#{GameObj.pcs.join('|')}/
           yield line
         end
-      }
-
-    rescue Olib::Errors::TimedOut
-      Olib.debug "timeout... "
+      end
+    rescue Errors::TimedOut
       # Silent
-    rescue Olib::Errors::Mundane => e
-
-    rescue Olib::Errors::Prempt => e
-      
+    rescue Errors::Mundane => e
+    rescue Errors::Prempt => e
     end
-    
   end
 
   def Olib.wrap_greedy(action)
-    
     begin
-      Olib.timeout(3) {
+      Olib.timeout(3) do
         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... "
+      end
+    rescue Errors::TimedOut
       # Silent
-    rescue Olib::Errors::Mundane => e
-
-    rescue Olib::Errors::Prempt => e
-      
+    rescue Errors::Mundane => e
+      # omit
+    rescue Errors::Prempt => e
+      # omit
     end
-    
   end
 
   def Olib.exit
-    raise Olib::Errors::Mundane
+    raise Errors::Mundane
   end
 
   def Olib.wrap_stream(action = nil)
@@ -198,22 +104,18 @@ module Olib
       Olib.timeout(3) {
         if action then fput action end
         while (line=get)
-          next if     Olib::Dictionary.ignorable?(line)
+          next if     Dictionary.ignorable?(line)
           # next if not GameObj.pcs.nil? and line =~ /#{GameObj.pcs.join('|')}/
           yield line
         end
       }
   
-    rescue Olib::Errors::TimedOut
-      Olib.debug "timeout... "
+    rescue Errors::TimedOut
       # Silent
-
-    rescue Olib::Errors::Mundane => e
-      Olib.debug "mundane..."
-
-    rescue Olib::Errors::Prempt => e
-      Olib.debug "waiting prempted..."
-
+    rescue Errors::Mundane => e
+      # omit
+    rescue Errors::Prempt => e
+      # omit
     ensure
       Olib.turn_off_xml
     end

data/lib/Olib/core/verbs.rb

@@ -0,0 +1,304 @@
+module Verbs
+  def __verbs__
+    @verbs = "open close analyze inspect weigh".split(" ").map(&:to_sym)
+    singleton = (class << self; self end)
+    @verbs.each do |verb|
+      singleton.send :define_method, verb do
+        fput "#{verb.to_s} ##{@id}"
+        self
+      end
+    end
+  end
+
+  def at
+    Olib.wrap_stream("look at ##{@id}") { |line|
+      if line =~ /You see nothing unusual|prompt time|You gaze through (.*?) and see...|written/
+        raise Errors::Mundane
+      end
+
+      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 Errors::Mundane
+      end
+      
+    }
+    self
+  end
+
+  def look
+    self
+  end
+
+  def on
+    return self unless @id
+    Olib.wrap_stream("look on ##{@id}") { |line|
+      raise Errors::Mundane if line =~ /There is nothing on there|prompt time/
+      if line =~ /On the (.*?) you see/
+        @ontop << line.match(Dictionary.contents)[:items]
+          .scan(Dictionary.tag)
+          .map {|matches| Item.new GameObj.new *matches }
+        raise Errors::Mundane
+      end
+      next
+    }
+    self
+  end
+
+  def in
+    fput "look in ##{@id}"
+    self
+  end
+
+  def _inspect
+
+    return self if has? "inspect"
+
+    in_inspect = false
+
+    Olib.wrap_stream(action "inspect") { |line|
+
+      raise Errors::Mundane  if line =~ /^<prompt/ and in_inspect
+
+      # skip first inspect line because it"s useless for info
+      in_inspect = true if line =~ /You carefully inspect|You carefully count|goat/
+
+      if in_inspect
+        
+        if line =~ /^You estimate that (?:.*?) can store (?:a|an|some) ([a-zA-Z -]+) amount with enough space for ([a-zA-Z ]+)/
+          @props["space"]           = $1
+          @props["number_of_items"] = $2
+        end
+          
+
+        
+        if line =~ /^You determine that you could wear the (.*?) ([a-zA-Z ]+)/
+          @props["location"]= $2
+        end
+        
+        if line =~ /allows you to conclude that it is ([a-zA-Z ]+)/
+
+          if line =~ Dictionary.size
+            @props["shield_type"] = $1
+          else
+            Dictionary.armors.each do |type, re| @props["armor_type"] = type if line =~ re end
+          end
+          
+        end
+
+        if line =~ /suitable for use in unarmed combat/
+          @props["weapon_type"]= "uac"
+        end
+
+        if line =~ /requires skill in ([a-zA-Z ]+) to use effectively/
+      
+          @props["weapon_type"]= $1
+          if line =~ /It appears to be a modified ([a-zA-Z -]+)/
+            @props["weapon_base"]= $1
+          else
+            @props["weapon_base"]= @noun
+          end
+        end            
+        
+        if line =~ /^It looks like this item has been mainly crafted out of ([a-zA-Z -]+)./
+          @props["material"]= $1
+          raise Errors::Mundane
+        end
+        
+        if line =~ /can hold liquids/
+          @props["liquid_container"]=true
+        end
+
+      end
+      
+    }
+    
+    return self
+  end
+
+  def look
+    return self if has? "show"
+    Olib.wrap(action "look") { |line|
+      raise Errors::Mundane if line=~/^You see nothing unusual.|^You can"t quite get a good look at/
+      define "show", line  unless line=~/prompt time|You take a closer look/
+    }
+    self
+  end
+
+  def tap
+    return self if has? "description"
+    Olib.wrap(action "tap") { |line|
+      next unless line=~ /You tap (.*?) (on|in)/
+      define "description", $1 
+      raise Errors::Mundane         
+    }
+    self
+  end
+
+  def price
+    return self if(has? "price" or has? "info")
+    Olib.wrap(action "get") { |line|
+
+      if line =~ /(\d+) silvers/
+        define "price", line.match(/(?<price>\d+) silvers/)[:price]
+        raise Errors::Mundane
+      end
+
+      if line =~ /You can"t pick that up/
+        define "info", true
+        raise Errors::Mundane
+      end
+
+      Script.log "unmatched price: #{line}"
+      
+    }
+    self
+  end
+
+  def read
+    return self if has? "read"
+    scroll    = false
+    multiline = false
+    Olib.wrap_stream(action "read") {  |line|
+
+      raise Errors::Mundane  if line =~ /^<prompt/ and (multiline or scroll)
+      raise Errors::Mundane if line =~ /There is nothing there to read|You can"t do that./
+
+      # if we are in a multiline state
+      @props["read"] = @props["read"].concat line if multiline
+
+      # capture spell
+      if scroll && line =~ /\(([0-9]+)\) ([a-zA-Z"\s]+)/
+          spell = OpenStruct.new(name: $2, num: $1.to_i)
+          #Client.notify "Spell detected ... (#{$1}) #{$2}"
+          @props["spells"].push spell
+
+      # begin scroll
+      elsif line =~ /It takes you a moment to focus on the/
+        scroll = true
+        @props["spells"] = Array.new 
+
+      # open multiline
+      elsif line =~ /^In the (.*?) language, it reads/
+        multiline          = true
+        @props["read"]     = "#{line}\n"
+        @props["language"] = $1
+
+      # alert to unknown
+      elsif line =~ /but the language is not one you know.  It looks like it"s written in (.*?)./
+        Script.log "Please find a friend that can read for #{$1} in #{XMLData.room_title}"
+        echo "Please find a friend that can read for #{$1} in #{XMLData.room_title}"
+        raise Errors::Mundane
+      
+      end
+      
+    }
+    return self
+  end
+
+  def analyze
+    fput "analyze ##{id}"
+    should_detect = false
+    begin
+      Timeout::timeout(1) do
+        while(line = get)
+          next                        if Dictionary.ignorable?(line)
+          next                        if line =~ /sense that the item is free from merchant alteration restrictions|and sense that the item is largely free from merchant alteration restrictions|these can all be altered by a skilled merchant|please keep the messaging in mind when designing an alterations|there is no recorded information on that item|The creator has also provided the following information/
+          @props["max_light"] = true  if line =~ /light as it can get/
+          @props["max_deep"]  = true  if line =~ /pockets could not possibly get any deeper/
+          @props["max_deep"]  = false if line =~ /pockets deepened/
+          @props["max_light"] = false if line =~ /talented merchant lighten/
+          if line =~ /Casting Elemental Detection/
+            should_detect = true 
+            next 
+          end
+          break                       if line =~ /pockets deepened|^You get no sense of whether|light as it can get|pockets could not possibly get any deeper|talented merchant lighten/
+          @props["analyze"] = String.new unless @props["analyze"]
+          @props["analyze"].concat line.strip
+          @props["analyze"].concat " "
+        end
+      end
+    
+    rescue Timeout::Error
+      # Silent
+    end
+    detect if should_detect
+    temp_analysis = @props["analyze"].split(".").map(&:strip).map(&:downcase).reject {|ln| ln.empty? }
+    @props["analyze"] = temp_analysis unless temp_analysis.empty?
+    return self
+  end
+
+  def take
+    return self if has? "cost"
+
+    Olib.wrap(action "get") { |line|
+      raise Errors::DoesntExist    if line=~ Dictionary.get[:failure][:ne]
+      raise Errors::HandsFull      if line=~ Dictionary.get[:failure][:hands_full]
+      raise Errors::TooHeavy       if line=~ Dictionary.get[:failure][:weight]
+      
+      if line=~ Dictionary.get[:success] 
+        raise Errors::Mundane
+      end  
+
+      if line =~ Dictionary.get[:failure][:buy]
+        define "cost", line.match(Dictionary.get[:failure][:buy])[:cost].to_i
+        raise Errors::Mundane
+      end
+
+      if line =~ /let me help you with that/
+        raise Errors::Mundane
+      end
+
+      if line=~ /You"ll have to buy it if you want it/
+        tag "buyable"
+        raise Errors::Mundane
+      end
+
+      if line=~ /You can PULL/
+        tag "pullable"
+        raise Errors::Mundane
+      end
+
+    }
+    self
+  end
+
+  def drop
+    Script.log("#{Time.now} > dropped #{to_s}")
+    fput action "drop"
+    self
+  end
+
+  SOLD        = /([\d]+) silver/
+  WRONG_SHOP  = /That's not quite my field/
+  WORTHLESS   = /worthless/
+
+  def sell
+    take
+    case result = dothistimeout("sell ##{id}", 3, Regexp.union(SOLD, WRONG_SHOP, WORTHLESS))
+    when SOLD        then [:sold, OpenStruct.new(name: self.name, price: $1.to_i)]
+    when WRONG_SHOP  then [:wrong_shop, self]
+    when WORTHLESS   then [:worthless, self]
+    else                  [:unhandled_case, result]
+    end
+  end
+
+  def _drag(target)
+    Olib.wrap("_drag ##{id} ##{target.id}") { |line|
+      # order of operations is important here for jars
+      raise Errors::DoesntExist          if line =~ Dictionary.put[:failure][:ne]
+      raise Errors::Mundane              if line =~ Dictionary.put[:success]
+      
+      if line =~ Dictionary.put[:failure][:full]
+        tag "full"
+        raise Errors::ContainerFull
+      end
+    }
+    self
+  end
+
+end