Olib 0.1.2 → 2.0.0.pre.rc.1

data/lib/Olib/core/errors.rb

@@ -1,91 +1,89 @@
-module Olib
-  module Errors
-    @@padding = 20
 
-    def Errors.padding(n)
-      @@padding = n
-    end
+module Errors
+  @@padding = 20
 
-    def Errors.indent(str)
-      str.split("\n").map { |line| [''] * @@padding * " " + line }.join("\n")
-    end
+  def Errors.padding(n)
+    @@padding = n
+  end
 
-    # used internally to handle early thread execution and error bubbling
-    class Mundane < Exception
-    end
+  def Errors.indent(str)
+    str.split("\n").map { |line| [''] * @@padding * " " + line }.join("\n")
+  end
 
-    # used internally to insure threads died and error bubbling
-    class TimedOut < Exception
-    end
+  # used internally to handle early thread execution and error bubbling
+  class Mundane < Exception
+  end
 
-    # used internally to handle early thread execution and error bubbling
-    class Prempt < Exception
-    end
+  # used internally to insure threads died and error bubbling
+  class TimedOut < Exception
+  end
 
-    # used to exit a thread early due to an error that Olib cannot resolve internally
-    class Fatal < Exception
-      def initialize(message=nil)
-        unless message
-          message = String.new
-          message.concat "\n\nAn Olib::Errors::Fatal was raised but not rescued in an Olib method"
-          message.concat "\nyou should rescue this error if it isn't fatal and you don't want your script to break"
-        end
-        super Errors.indent message
-      end
-    end 
+  # used internally to handle early thread execution and error bubbling
+  class Prempt < Exception
+  end
 
-    # If you have a full container and a script/action depends on it, this is thrown
-    # rescue it for logic
-    class ContainerFull < Exception
-      def initialize(message=nil)
-        unless message
-          message = String.new
-          message.concat "\n\nYou tried to add stuff to a container that was full"
-          message.concat "\nyou should rescue this error if it isn't fatal and you don't want your script to break"
-        end
-        super Errors.indent message
-      end
-    end 
-    
-    class InsufficientFunds < Exception
-      def initialize(message=nil)
-        unless message
-          message = String.new
-          message.concat "\n\nYou tried to do something that costs more money that your character had on them"
-          message.concat "\nyou should rescue this error if it isn't fatal and you don't want your script to break"
-        end
-        super Errors.indent message
+  # used to exit a thread early due to an error that Olib cannot resolve internally
+  class Fatal < Exception
+    def initialize(message=nil)
+      unless message
+        message = String.new
+        message.concat "\n\nAn Errors::Fatal was raised but not rescued in an Olib method"
+        message.concat "\nyou should rescue this error if it isn't fatal and you don't want your script to break"
       end
-    end 
+      super Errors.indent message
+    end
+  end 
 
-    class HandsFull < Exception
-      def initialize
+  # If you have a full container and a script/action depends on it, this is thrown
+  # rescue it for logic
+  class ContainerFull < Exception
+    def initialize(message=nil)
+      unless message
         message = String.new
-        message.concat "\n\nYour hands were full!"
-        message.concat "\nyou should rescue this error if you don't want your script to break"
-        super Errors.indent message
+        message.concat "\n\nYou tried to add stuff to a container that was full"
+        message.concat "\nyou should rescue this error if it isn't fatal and you don't want your script to break"
       end
+      super Errors.indent message
     end
-
-    class TooHeavy < Exception
-      def initialize
+  end 
+  
+  class InsufficientFunds < Exception
+    def initialize(message=nil)
+      unless message
         message = String.new
-        message.concat "\n\nYou were too heavy to do something!"
-        message.concat "\nyou should rescue this error if you don't want your script to break"
-        super Errors.indent message
+        message.concat "\n\nYou tried to do something that costs more money that your character had on them"
+        message.concat "\nyou should rescue this error if it isn't fatal and you don't want your script to break"
       end
+      super Errors.indent message
     end
+  end 
 
-    class DoesntExist < Exception
-      def initialize(message=nil)
-        unless message
-          message = String.new
-          message.concat "\n\nYou tried to interact with something that no longer exists"
-          message.concat "\nyou should rescue this error if it isn't fatal and you don't want your script to break"
-        end
-        super Errors.indent message
-      end
+  class HandsFull < Exception
+    def initialize
+      message = String.new
+      message.concat "\n\nYour hands were full!"
+      message.concat "\nyou should rescue this error if you don't want your script to break"
+      super Errors.indent message
     end
+  end
 
+  class TooHeavy < Exception
+    def initialize
+      message = String.new
+      message.concat "\n\nYou were too heavy to do something!"
+      message.concat "\nyou should rescue this error if you don't want your script to break"
+      super Errors.indent message
+    end
+  end
+
+  class DoesntExist < Exception
+    def initialize(message=nil)
+      unless message
+        message = String.new
+        message.concat "\n\nYou tried to interact with something that no longer exists"
+        message.concat "\nyou should rescue this error if it isn't fatal and you don't want your script to break"
+      end
+      super Errors.indent message
+    end
   end
 end

data/lib/Olib/core/exist.rb

@@ -0,0 +1,88 @@
+
+require "Olib/core/action"
+
+class Exist
+  GETTER = %r[\w$]
+
+  def self.fetch(id)
+    [ GameObj.inv, GameObj.containers.values, 
+      GameObj.loot, GameObj.room_desc,
+      GameObj.pcs, GameObj.npcs, 
+      GameObj.right_hand, GameObj.left_hand ].flatten
+                                             .find do |item| item.id.to_s.eql?(id.to_s) end
+  end
+
+  def self.normalize_type_data(type)
+    (type or "").gsub(",", " ").split(" ")
+  end
+
+  attr_reader :id, :gameobj
+  def initialize(obj)
+    if obj.respond_to?(:id)
+      @id = obj.id
+    else
+      @id = obj
+    end
+    fail Exception, "Id<#{@id}> was not of String|Fixnum" if @id.nil?
+  end
+
+  def fetch()
+    @gameobj ||= Exist.fetch(id)
+  end
+
+  def respond_to_missing?(method, *args)
+    fetch.respond_to?(method) and method.to_s.match(GETTER) 
+  end
+
+  def method_missing(method, *args)
+    if respond_to_missing?(method)
+      fetch.send(method, *args)
+    else
+      super
+    end
+  end
+
+  def exists?
+    not GameObj[id].nil?
+  end
+
+  def gone?
+    not exists?
+  end
+
+  def tags
+    Exist.normalize_type_data(type).map(&:to_sym)
+  end
+
+  def effects
+    (status or "").split(",").map(&:to_sym)
+  end
+
+  def to_h()
+    {id: id, name: name, noun: noun}
+  end
+
+  def ==(other)
+    id.to_s.eql?(other.id.to_s)
+  end
+
+  alias_method :eql?, :==
+
+  def to_s()
+    inspect()
+  end
+
+  def inspect(depth= 0)
+    indent = ""
+    indent = "\n" + (["\t"] * depth).join if depth > 0 
+    body = [:id, :name, :tags].reduce("") do |acc, prop|
+      val = send(prop)
+      acc = "#{acc} #{prop}=#{val.inspect}" unless val.nil? or val.empty?
+      acc
+    end.strip
+
+    body = "#{body} contents=[#{contents.map {|i| i.inspect(depth + 1)}.join}]" unless contents.to_a.empty?
+      
+    %[#{indent}#{self.class.name}(#{body})]
+  end
+end

data/lib/Olib/core/item.rb

@@ -1,618 +1,63 @@
 require "ostruct"
-require "Olib/core/extender"
+require "Olib/core/exist"
 require "Olib/core/use"
+require "Olib/core/transaction"
 
 class GameObj
   def to_item
-    Olib::Item.new self
+    Item.new self
   end
 end
 
-module Olib
-  # this is the structure for a base Object
-  # wraps an instance of GameObj and adds the ability for tags, queries
-  class Item < Olib::Gameobj_Extender
-    TYPES = [
-    "reagent",
-    ["spirit beast talismans", true],
-    "alchemy product",
-    ["alchemy equipment", true],
-    "note",
-    ["cursed", true],
-    ["ammo", true],
-    "box",
-    "gem",
-    "herb",
-    ["food", true],
-    ["uncommon", true],
-    "valuable",
-    "plinite",
-    ["ebongate", true],
-    ["quest", true],
-    ["jewelry", true],
-    ["junk", true],
-    "lockpick",
-    "magic",
-    "scroll",
-    "skin",
-    "wand",
-    "toy",
-    ["armor", true],
-    "weapon",
-    ["clothing", true],
-    "instrument",
-    "jar",
-    "lm trap",
-    "lm tool",
-    "scarab",
-    #"consignment",
-    #"gemshop",
-    #"pawnshop",
-    #"furrier"
-  ]
-
-  def self.type_methods
-    TYPES.map { |type|
-      if type.class == Array then
-        [ Olib.methodize(type.first).to_sym, type.first ]
-      elsif ["x"].include?(type.chars.last)
-        [ Olib.methodize(type + "es").to_sym, type ]
-      else
-        [ Olib.methodize(type + "s").to_sym, type ]
-      end
-    }
+# this is the structure for a base Object
+# wraps an instance of GameObj and adds the ability for tags, queries
+class Item < Exist
+  def self.fetch(id)
+    new Exist.fetch(id)
   end
 
-    attr_accessor :props, :container
-    # When created, it should be passed an instance of GameObj
-    #
-    # Example: 
-    #          Olib::Item.new(GameObj.right_hand)
-    def initialize(obj, container = nil)
-      @container          = container
-      @props              = Hash.new
-      @props[:name]       = obj.name
-      @props[:after_name] = obj.after_name
-      @props[:before_name]= obj.before_name
-      @props[:desc]       = [obj.before_name, obj.name, obj.after_name].compact.join(" ")
-      @props[:noun]       = obj.noun
-      define :tags, []
-      obj.type.split(",").map { |t| tag(t) }
-
-      #tag @props[:name]
-
-      if is?("jar") && @props[:after_name] =~ /containing (.*+?)/
-        tag Dictionary.gems[:singularize].call @props[:after_name].gsub("containing", "").strip
-      end
-
-      if is?("gem")
-        tag Dictionary.gems[:singularize].call @props[:name]
-      end
-
-      if is?("jar") && @props[:after_name].nil?
-        tag("empty")
-      end
-
-      if Vars.teleporter && Vars.teleporter == @props[:name]
-        tag("teleporter")
-      end
-
-      super(obj)
-    end
-
-    def to_s
-      @props.to_s
-    end
-
-    # determine if Item is something
-    #
-    # example:
-    #          item.is?("jar")
-    #
-    def is?(tag)
-      @props[:tags].include?(tag)
-    end
-
-    def tag(*tags)
-      @props[:tags].concat(tags)
-      self
-    end
-
-    def untag(*remove)
-      @props[:tags] = @props[:tags].select { |tag| !remove.include?(tag) }
-    end
-
-    def tags
-      @props[:tags]
-    end
-
-    def use(&block)
-      Use.new(self, &block)
-    end
-
-    def worn?
-      GameObj.inv.collect { |item| item.id }.include? @id
-    end
-
-    def crawl
-      take
-      tap._inspect.read.look
-      self
-    end
-
-    def buy
-      Char.deplete_wealth cost
-      fput action "buy"
-      self
-    end
-
-    def has?(key)
-      !@props[key].nil?
-    end
-
-    def missing?(key)
-      !has?(key)
-    end
-
-    def exists?
-      GameObj[@id].nil?
-    end
-
-    def ==(other)
-      @id == other.id
-    end
-
-    def pullable?
-      is? "pullable"
-    end
-
-    def affordable?
-      take
-      return true if pullable?
-      cost <= Char.smart_wealth
-    end
-
-    def buyable?
-      is? "buyable"
-    end
-
-    def cost
-      @props["cost"]
-    end
-
-    def acquire_from_shop
-      take
-      if pullable?
-        return pull
-      else
-        Olib.wrap(action "buy"){ |line|
-          raise Olib::Errors::InsufficientFunds if line =~ /The merchant frowns/
-          if line =~ /You hand over/
-            Char.deplete_wealth cost
-            raise Olib::Errors::Mundane
-          end
-        }
-      end
-      self
-    end
-
-    def in
-      return self if has? "contents"
-      Olib.wrap(action "look in") { |line|
-        if line=~/^There is nothing in there.|You gaze through (.*?) and see.../
-          raise Olib::Errors::Mundane
-        end
-        
-        # handle jar data
-        if line =~ /Inside (.*?) you see (?<number>[\d]+) portion(|s) of (?<type>.*?).  It is (more than |less than|)(?<percent>[a-z ]+)./ 
-          data = line.match(/Inside (.*?) you see (?<number>[\d]+) portion(|s) of (?<type>.*?).  It is (more than |less than|)(?<percentage>[a-z ]+)./)
-          tag data[:percentage] == "full" ? "full" : "partial"
-          define :number, data[:number].to_i
-          raise Olib::Errors::Mundane
-        end
-
-        #handle empty jars
-        if line =~ /The (.*?) is empty./
-          tag "empty"
-          raise Olib::Errors::Mundane
-        end
-      }
-      self
-    end
-
-    def _drag(target)
-      Olib.wrap("_drag ##{@id} ##{target.id}") { |line|
-        # order of operations is important here for jars
-        raise Olib::Errors::DoesntExist          if line =~ Dictionary.put[:failure][:ne]
-        raise Olib::Errors::Mundane              if line =~ Dictionary.put[:success]
-        
-        if line =~ Dictionary.put[:failure][:full]
-          tag "full"
-          raise Olib::Errors::ContainerFull
-        end
-      }
-      self
-    end
-
-    def stash
-      _drag GameObj[props["container"]]
-    end
-
-    def shake
-      # make sure we have a count so we need to match fewer lines
-      self.in if is? "jar" and missing? :number
-      
-      Olib.wrap(action "shake"){ |line|
-        raise Olib::Errors::Fatal    if line =~ /you realize that it is empty/
-        if line =~ /fall into your/
-          @props[:number] = @props[:number]-1
-          raise Olib::Errors::Fatal.new "Jar is now empty\n you should rescue this to handle it gracefully" if @props[:number] == 0
-          raise Olib::Errors::Mundane
-        end
-      }
-      self
-    end
-
-    def shop_sell(amt)
-      if GameObj.right_hand.id != @id
-        raise Olib::Errors::Fatal
-      end
-
-      Olib.wrap("shop sell #{amt}") {|line|
-        raise Olib::Errors::Mundane if line =~ /^You place your/
-        raise Olib::Errors::Fatal   if line =~ /There"s no more room for anything else right now./
-      }
-
-    end
-
-    SOLD        = /([\d]+) silver/
-    WRONG_SHOP  = /That's not quite my field/
-    WORTHLESS   = /worthless/
-
-    def sell
-      take
-      case result = dothistimeout("sell ##{@id}", 3, (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 turn
-      fput action "turn"
-      self
-    end
-
-    def action(verb)
-      "#{verb} ##{@id}"
-    end
-
-    def add(*items)
-      items.each do |item|
-        item._drag(self)
-      end
-      self
-    end
-
-    def define(key, val)
-      @props[key] = val
-      self
-    end
-
-    def pull(onfailure=nil)
-      refresh_instance = false
-      original_right   = GameObj.right_hand
-      original_left    = GameObj.left_hand
-      Olib.wrap(action "pull") { |line|
-        
-        if line =~ /^You pull/
-          if line =~ /There (are|is) ([\d]+) left/
-            refresh_instance = true
-          end
-          raise Olib::Errors::Mundane
-        end
-
-        if line =~ /I"m afraid that you can"t pull that./
-          if onfailure
-            onfailure.call(self)
-          else 
-            raise Olib::Errors::DoesntExist 
-          end
-        end
-      }
-      # for stacked items in shops
-      if refresh_instance
-        return Item.new(GameObj.left_hand) if original_left.nil? && !GameObj.left_hand.nil?
-        return Item.new(GameObj.right_hand)
-      end
-      self
-    end
-
-    def give(target, onfailure=nil)
-      Olib.wrap_stream("give ##{@id} to #{target}", 30) { |line|
-        raise Olib::Errors::Mundane if line=~ /This looks perfect/
-
-        if line =~ /glances at you and moves out of your reach./
-          raise Olib::Errors::Fatal.new "You appear to have an invalid NPC definition"
-        end
-
-      }
-
-      self
-    end
-
-    def remove(onfailure=nil)
-      
-      unless GameObj.inv.map(&:id).include? @id
-        if onfailure
-          onfailure.call(self)
-        else 
-          raise Olib::Errors::DoesntExist 
-        end
-      end
-      
-      Olib.wrap(action "remove") { |line|        
-        if line =~ /You cannot remove|You better get a sharp knife/
-          if onfailure
-            onfailure.call(self)
-          else 
-            raise Olib::Errors::DoesntExist 
-          end
-        end
-          
-        raise Olib::Errors::Mundane if GameObj.right_hand.id == @id || GameObj.left_hand.id == @id
-      }
-    
-      self
-    end
-
-    def wear(onfailure=nil)
-      if GameObj.right_hand.id != @id || GameObj.left_hand.id != @id
-        if onfailure
-          onfailure.call(self)
-        else 
-          raise Olib::Errors::DoesntExist 
-        end      
-      end
-
-      Olib.wrap(action "wear") { |line|        
-        if line =~ /You can"t wear that.|You can only wear/
-          if onfailure
-            onfailure.call(self)
-          else 
-            raise Olib::Errors::DoesntExist 
-          end
-        end
-        raise Olib::Errors::Mundane if GameObj.inv.map(&:id).include? @id
-      }
-    
-      self
-
-    end
-
-    def analyze
-      fput "analyze ##{@id}"
-      should_detect = false
-      begin
-        Timeout::timeout(1) do
-          while(line = get)
-            next                        if Olib::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=~ Olib::Dictionary.get[:failure][:ne]
-        raise Errors::HandsFull      if line=~ Olib::Dictionary.get[:failure][:hands_full]
-        raise Errors::TooHeavy       if line=~ Olib::Dictionary.get[:failure][:weight]
-        
-        if line=~ Olib::Dictionary.get[:success] 
-          raise Olib::Errors::Mundane
-        end  
-
-        if line =~ Olib::Dictionary.get[:failure][:buy]
-          define "cost", line.match(Olib::Dictionary.get[:failure][:buy])[:cost].to_i
-          raise Olib::Errors::Mundane
-        end
-
-        if line =~ /let me help you with that/
-          raise Olib::Errors::Mundane
-        end
-
-        if line=~ /You"ll have to buy it if you want it/
-          tag "buyable"
-          raise Olib::Errors::Mundane
-        end
-
-        if line=~ /You can PULL/
-          tag "pullable"
-          raise Olib::Errors::Mundane
-        end
-
-      }
-      self
-    end
-
-    def drop
-      Script.log("#{Time.now} > dropped #{to_s}")
-      fput action "drop"
-      self
-    end
-
-    def _inspect
-
-      return self if has? "inspect"
-
-      in_inspect = false
-
-      Olib.wrap_stream(action "inspect") { |line|
-
-        raise Olib::Errors::Mundane  if line =~ /^<prompt/ and in_inspect
-
-        # skip first inspect line because it"s useless for info
-        if line =~ /You carefully inspect|You carefully count|goat/
-          in_inspect = true
-        end
-
-
-        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 Olib::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 Olib::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 Olib::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 Olib::Errors::Mundane
-        end
-
-        if line =~ /You can"t pick that up/
-          define "info", true
-          raise Olib::Errors::Mundane
-        end
-
-        Script.log "unmatched price: #{line}"
-        
-      }
-      self
-    end
+  attr_reader :container
+  # When created, it should be passed an instance of GameObj
+  #
+  # Example: 
+  #          Item.new(GameObj.right_hand)
+  def initialize(obj, container = nil)
+    super(obj.id)
+    @container = container
+  end
 
-    def read
-      return self if has? "read"
-      scroll    = false
-      multiline = false
-      Olib.wrap_stream(action "read") {  |line|
+  def worn?
+    GameObj.inv.map(&:id).include?(id)
+  end
 
-        raise Olib::Errors::Mundane  if line =~ /^<prompt/ and (multiline or scroll)
-        raise Olib::Errors::Mundane if line =~ /There is nothing there to read|You can"t do that./
+  def use(&block)
+    Use.new(self, &block)
+  end
 
-        # if we are in a multiline state
-        @props["read"] = @props["read"].concat line if multiline
+  def held?
+    [Char.left, Char.right].map(&:id).include?(id.to_s)
+  end
 
-        # 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
+  def take()
+    return self if held?
+    fail Exception, "Error #{inspect}\nyour hands are full" if Char.left && Char.right
+    Action.try_or_fail(command: "get ##{id}") do held? end
+    return self
+  end
 
-        # begin scroll
-        elsif line =~ /It takes you a moment to focus on the/
-          scroll = true
-          @props["spells"] = Array.new 
+  def to_json(*args)    
+    to_h.to_json(*args)
+  end
 
-        # open multiline
-        elsif line =~ /^In the (.*?) language, it reads/
-          multiline          = true
-          @props["read"]     = "#{line}\n"
-          @props["language"] = $1
+  def transaction(**args)
+    Transaction.new(take, **args)
+  end
 
-        # 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 Olib::Errors::Mundane
-       
-        end
-        
-      }
-      return self
-    end
+  def sell(**args)
+    transaction(**args).sell()
+  end
 
+  def stash
+    @container.add(self) unless @container.nil?
   end
-  
 end