Olib 0.1.0 → 0.1.1

data/lib/Olib/combat/creatures.rb

@@ -1,62 +1,74 @@
+require 'Olib/interface/queryable'
+require 'net/http'
+require 'json'
 # a collection for managing all of the creatures in a room
-module Olib
-  class Creatures
-    def Creatures.first
-      all.first
-    end
 
-    def Creatures.all
-      GameObj.npcs
-        .map    { |creature| Creature.new(creature) }
-        .select { |creature| !creature.dead?              }
-        .select { |creature| !creature.ignorable?         }
-        .select { |creature| !creature.tags.include?('animate') }
-        .select { |creature| !creature.gone? } || []
-    end
+class Creatures < Interface::Queryable
 
-    def Creatures.each(&block)
-      all.each(&block)
-    end
+  METADATA_URL = "https://cdn.rawgit.com/ondreian/gemstone_data_project/c40a5dfb/creatures.json"
+  
+  ARCHETYPES = [
+    :undead, :living, :weak, :grimswarm,
+    :antimagic, :flying, :lowly, :bandit,
+    :aggressive,
+  ]
 
-    def Creatures.[](exp)
-      regexp = exp.class == String ? /#{exp}/ : exp
+  STATES = [
+    :dead, :sleeping, :webbed, :immobile,  
+    :stunned, :prone, :sitting, 
+    :kneeling, :flying
+  ]
 
-      filter { |creature| creature.name =~ regexp || creature.id == exp }
+  def Creatures.fetch_metadata!
+    begin
+      JSON.parse Net::HTTP.get URI METADATA_URL
+    rescue
+      puts $!
+      puts $!.backtrace[0..1]
+      []
     end
-    
-    def Creatures.filter(&block); 
-      all.select(&block)                                
+  end
+
+  METADATA = fetch_metadata!
+  BY_NAME  = METADATA.reduce(Hash.new) do |by_name, record|
+    by_name[record["name"]] = record
+    by_name
+  end
+
+  def Creatures.unsafe
+    (GameObj.npcs || [])
+      .map do |obj| Creature.new obj end
+      .reject do |creature| creature.gone? end
+  end
+
+  def Creatures.fetch
+    unsafe.select do |creature| 
+      creature.aggressive?
+    end.reject do |creature| 
+        creature.tags.include?(:companion) || 
+        creature.tags.include?(:familiar)  || 
+        creature.gone?                     || 
+        creature.name =~ /nest/
     end
+  end
 
-    def Creatures.bandits;    filter { |creature| creature.is?('bandit') }    ;end;
-    def Creatures.ignoreable; filter { |creature| creature.is?('ignoreable') };end;
-    def Creatures.flying;     filter { |creature| creature.is?('flying') }    ;end;
-    def Creatures.living;     filter { |creature| creature.is?('living') }    ;end;
-    def Creatures.antimagic;  filter { |creature| creature.is?('antimagic') } ;end;
-    def Creatures.undead;     filter { |creature| creature.is?('undead') }    ;end;
-
-    def Creatures.grimswarm;  filter { |creature| creature.is?('grimswarm') } ;end;
-    def Creatures.invasion;   filter { |creature| creature.is?('invasion')  } ;end;
-    
-    def Creatures.escortees
-      GameObj.npcs
-        .map {|creature| Creature.new(creature) }
-        .select {|creature| creature.is?('escortee') } 
+  [ARCHETYPES, STATES].flatten.each do |state|
+    Creatures.define_singleton_method(state) do
+      select do |creature|
+        [creature.tags, creature.status].flatten.include?(state)
+      end
     end
+  end
 
-    def Creatures.stunned;     all.select(&:stunned?)   ;end;
-    def Creatures.active;      all.select(&:active?)    ;end;
-    def Creatures.dead;        all.select(&:dead?)      ;end;
-    def Creatures.prone;       all.select(&:prone?)     ;end;
-    
-    def Creatures.ambushed?
-      last_line = $_SERVERBUFFER_.reverse.find { |line| line =~ /<pushStream id='room'\/>|An? .*? fearfully exclaims, "It's an ambush!"|#{Olib::Dictionary.bandit_traps.values.join('|')}/ }
-      echo "detected ambush..." if !last_line.nil? && last_line !~ /pushStream id='room'/
+  def self.living
+    reject do |creature|
+      creature.undead?
+    end
+  end
 
-      !last_line.nil? && last_line !~ /pushStream id='room'/
+  def self.bounty
+    select do |creature|
+      creature.name.include?(Bounty.creature)
     end
   end
 end
-
-class Creatures < Olib::Creatures
-end

data/lib/Olib/core/container.rb

@@ -1,18 +1,23 @@
 # for defining containers ala lootsack and using them across scripts
+require "Olib/core/extender"
+require "Olib/core/item"
 
-require 'Olib/core/extender'
-
-class String
-  def to_class
-    Kernel.const_get self
-  rescue NameError 
-    nil
+class Regexp
+  def or(re)
+    Regexp.new self.to_s + "|" + re.to_s
   end
+end
+
+def class_exists?(class_name)
+  klass = Module.const_get(class_name)
+  return klass.is_a?(Class)
+rescue NameError
+  return false
+end
 
-  def is_a_defined_class?
-    true if self.to_class
-  rescue NameError
-    false
+class GameObj
+  def to_container
+    Olib::Container.new self.id
   end
 end
 
@@ -20,20 +25,35 @@ module Olib
   class Container < Gameobj_Extender
     attr_accessor :ref, :nested, :containers, :ontop
 
+    
+    Item.type_methods.each do |method, tag|
+      type =tag.split.map(&:capitalize).join('_')
+      if class_exists?(type)
+        define_method(method.to_sym) do 
+          find_by_tags(tag).map do |item|
+            Kernel.const_get(type).new item
+          end
+        end
+      else
+        define_method(method.to_sym) do find_by_tags(tag) end
+      end
+    end
+
+
     def initialize(id=nil)
       # extract the class name to attempt to lookup the item by your settings
       # ex: class Lootsack
       # ex: class Gemsack
-      name       = if self.class.name.include?("::") then self.class.name.downcase.split('::').last.strip else self.class.name.downcase end 
-      candidates = Olib.Inventory[Vars[name]]
+      name       = if self.class.name.include?("::") then self.class.name.downcase.split("::").last.strip else self.class.name.downcase end 
+      candidates = Inventory[Vars[name]]
       raise Olib::Errors::DoesntExist.new("#{name} could not be initialized are you sure you:\n ;var set #{name}=<something>") if candidates.empty? && id.nil?
-
+      @id    = id
       @ref   = GameObj[id] || candidates.first
       @ontop = Array.new
       
       unless GameObj[@ref.id].contents
         tops = [
-          'table'
+          "table"
         ]
 
         action = tops.include?(@ref.noun) ? "look on ##{@ref.id}" : "look in ##{@ref.id}"
@@ -46,9 +66,8 @@ module Olib
     end
 
     def contents
-      [
-        @ontop,
-        GameObj[@ref.id].contents.map { |item| Item.new(item) }
+      [ @ontop,
+        GameObj[@ref.id].contents.map do |item| Item.new(item, self) end
       ].flatten
     end
 
@@ -66,7 +85,7 @@ module Olib
 
     def find_by_tags(*tags)  
       contents.select { |item|
-        !tags.map {|tag| item.is?(tag) }.include? false
+        !tags.map {|tag| item.is?(tag) }.include?(false)
       }
     end
 
@@ -80,7 +99,7 @@ module Olib
     def 
 
     def __verbs__
-      @verbs = 'open close analyze inspect weigh'.split(' ').map(&:to_sym)
+      @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
@@ -134,68 +153,114 @@ module Olib
       self
     end
 
+    def rummage
+      Rummage.new(self)
+    end
+
     def nested?
       @nested
     end
 
-    def gems
-      find_by_tags('gem')
+    def full?
+      is? "full"
     end
 
-    def magic_items
-      find_by_tags('magic')
-    end
+    def add(*items)
+      _id = @id
+      items.each { |item|
 
-    def jewelry
-      find_by_tags('jewelry')
+        result = Olib.do "_drag ##{item.class == String ? item : item.id} ##{_id}", /#{[Olib::Dictionary.put[:success], Olib::Dictionary.put[:failure].values].flatten.join("|")}/
+        if result =~ /won"t fit in the/
+          tag "full"
+          raise Errors::ContainerFull
+        end
+      }
+      self
     end
 
-    def skins
-      find_by_tags('skin')
+    def method_missing(name, *args)
+      where(noun: name.to_s)
     end
 
-    def boxes
-      find_by_tags('boxes')
+    def to_s
+      "<Container:#{@id} @name=#{@name} @contents=[#{contents}]>"
     end
+  end
+end
 
-    def scrolls
-      find_by_tags('scroll')
-    end
+class Rummage
+  SUCCESS = /and remove/
+  FAIL    = /but can't seem|^But your hands are full|^You can only rummage for|^What/
 
-    def full?
-      is? 'full'
-    end
+  @@message = OpenStruct.new(
+    success: SUCCESS,
+    fail: FAIL,
+    either: SUCCESS.or(FAIL)
+  )
 
-    def add(item)
-      result = Olib.do "_drag ##{item.id} ##{@id}", /#{[Olib::Dictionary.put[:success], Olib::Dictionary.put[:failure].values].flatten.join('|')}/
-      tag 'full' if result =~ /won't fit in the/
-      self
-    end
+  def Rummage.message
+    @@message
   end
 
-  class Lootsack < Container
+  attr_accessor :container
 
+  def initialize(container)
+    @container = container
   end
-    
-  def Olib.Lootsack
-    return @@lootsack if @@lootsack
-    @@lootsack = Lootsack.new
-    @@lootsack
+
+  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
 
+# globalize
+class Container < Olib::Container
 end
 
 module Containers
   @@containers = {}
 
   def Containers.define(name)
-    @@containers[name] = Object.const_set(name.capitalize, Class.new(Olib::Container)).new
+    container = Class.new(Olib::Container)
+    @@containers[name] = Object.const_set(name.capitalize, container).new
     @@containers[name]
   end
 
   def Containers.method_missing(name)
     return @@containers[name] if @@containers[name]
     return Containers.define(name)
- end
+  end
 
+  def Containers.[](name)
+    begin
+      Containers.define(name)
+    rescue Exception => e
+      nil
+    end
+  end
+
+  def Containers.right_hand
+    Olib::Container.new(GameObj.right_hand.id)
+  end
+
+  def Containers.left_hand
+    Olib::Container.new(GameObj.left_hand.id)
+  end
 end

data/lib/Olib/core/extender.rb

@@ -1,4 +1,5 @@
-# used to wrap and extend a GameObj item
+# TODO:
+# this should be refactored to use a mixin pattern
 module Olib
   class Gameobj_Extender
     attr_accessor :type

data/lib/Olib/core/item.rb

@@ -1,38 +1,100 @@
-require 'Olib/core/extender'
+require "ostruct"
+require "Olib/core/extender"
+require "Olib/core/use"
+
+class GameObj
+  def to_item
+    Olib::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
+    }
+  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)
+    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[:desc]       = [obj.before_name, obj.name, obj.after_name].compact.join(" ")
       @props[:noun]       = obj.noun
       define :tags, []
-      obj.type.split(',').map { |t| tag(t) }
+      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
+      if is?("jar") && @props[:after_name] =~ /containing (.*+?)/
+        tag Dictionary.gems[:singularize].call @props[:after_name].gsub("containing", "").strip
       end
 
-      if is?('gem')
+      if is?("gem")
         tag Dictionary.gems[:singularize].call @props[:name]
       end
 
-      if is?('jar') && @props[:after_name].nil?
-        tag('empty')
+      if is?("jar") && @props[:after_name].nil?
+        tag("empty")
       end
 
       if Vars.teleporter && Vars.teleporter == @props[:name]
-        tag('teleporter')
+        tag("teleporter")
       end
 
       super(obj)
@@ -64,6 +126,10 @@ module Olib
       @props[:tags]
     end
 
+    def use(&block)
+      Use.new(self, &block)
+    end
+
     def worn?
       GameObj.inv.collect { |item| item.id }.include? @id
     end
@@ -76,7 +142,7 @@ module Olib
 
     def buy
       Char.deplete_wealth cost
-      fput action 'buy'
+      fput action "buy"
       self
     end
 
@@ -92,8 +158,12 @@ module Olib
       GameObj[@id].nil?
     end
 
+    def ==(other)
+      @id == other.id
+    end
+
     def pullable?
-      is? 'pullable'
+      is? "pullable"
     end
 
     def affordable?
@@ -103,11 +173,11 @@ module Olib
     end
 
     def buyable?
-      is? 'buyable'
+      is? "buyable"
     end
 
     def cost
-      @props['cost']
+      @props["cost"]
     end
 
     def acquire_from_shop
@@ -127,8 +197,8 @@ module Olib
     end
 
     def in
-      return self if has? 'contents'
-      Olib.wrap(action 'look in') { |line|
+      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
@@ -136,14 +206,14 @@ module Olib
         # 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"
+          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'
+          tag "empty"
           raise Olib::Errors::Mundane
         end
       }
@@ -157,7 +227,7 @@ module Olib
         raise Olib::Errors::Mundane              if line =~ Dictionary.put[:success]
         
         if line =~ Dictionary.put[:failure][:full]
-          tag 'full'
+          tag "full"
           raise Olib::Errors::ContainerFull
         end
       }
@@ -165,12 +235,12 @@ module Olib
     end
 
     def stash
-      _drag GameObj[props['container']]
+      _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
+      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/
@@ -190,27 +260,27 @@ module Olib
 
       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./
+        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
-      price = 0
       take
-      Olib.wrap( action "sell" ){ |line|
-        raise Olib::Errors::Fatal.new "#{to_s} is not sellable here" if GameObj.right_hand.id == @id
-
-        if line =~ /([\d]+) silver/
-          price = $1.to_i 
-          raise Olib::Errors::Mundane
-        end
-      }
-      price
+      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'
+      fput action "turn"
       self
     end
 
@@ -219,9 +289,9 @@ module Olib
     end
 
     def add(*items)
-      items.each { |item|
+      items.each do |item|
         item._drag(self)
-      }
+      end
       self
     end
 
@@ -243,7 +313,7 @@ module Olib
           raise Olib::Errors::Mundane
         end
 
-        if line =~ /I'm afraid that you can't pull that./
+        if line =~ /I"m afraid that you can"t pull that./
           if onfailure
             onfailure.call(self)
           else 
@@ -307,7 +377,7 @@ module Olib
       end
 
       Olib.wrap(action "wear") { |line|        
-        if line =~ /You can't wear that.|You can only wear/
+        if line =~ /You can"t wear that.|You can only wear/
           if onfailure
             onfailure.call(self)
           else 
@@ -329,18 +399,18 @@ module Olib
           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/
+            @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 " "
+            @props["analyze"] = String.new unless @props["analyze"]
+            @props["analyze"].concat line.strip
+            @props["analyze"].concat " "
           end
         end
       
@@ -348,15 +418,15 @@ module Olib
         # 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?
+      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'
+      return self if has? "cost"
 
-      Olib.wrap(action 'get') { |line|
+      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]
@@ -366,7 +436,7 @@ module Olib
         end  
 
         if line =~ Olib::Dictionary.get[:failure][:buy]
-          define 'cost', line.match(Olib::Dictionary.get[:failure][:buy])[:cost].to_i
+          define "cost", line.match(Olib::Dictionary.get[:failure][:buy])[:cost].to_i
           raise Olib::Errors::Mundane
         end
 
@@ -374,13 +444,13 @@ module Olib
           raise Olib::Errors::Mundane
         end
 
-        if line=~ /You'll have to buy it if you want it/
-          tag 'buyable'
+        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'
+          tag "pullable"
           raise Olib::Errors::Mundane
         end
 
@@ -396,15 +466,15 @@ module Olib
 
     def _inspect
 
-      return self if has? 'inspect'
+      return self if has? "inspect"
 
       in_inspect = false
 
-      Olib.wrap_stream(action 'inspect') { |line|
+      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
+        # skip first inspect line because it"s useless for info
         if line =~ /You carefully inspect|You carefully count|goat/
           in_inspect = true
         end
@@ -413,47 +483,47 @@ module Olib
         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
+            @props["space"]           = $1
+            @props["number_of_items"] = $2
           end
             
 
           
           if line =~ /^You determine that you could wear the (.*?) ([a-zA-Z ]+)/
-            @props['location']= $2
+            @props["location"]= $2
           end
           
           if line =~ /allows you to conclude that it is ([a-zA-Z ]+)/
 
             if line =~ Dictionary.size
-              @props['shield_type'] = $1
+              @props["shield_type"] = $1
             else
-              Dictionary.armors.each do |type, re| @props['armor_type'] = type if line =~ re end
+              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"
+            @props["weapon_type"]= "uac"
           end
 
           if line =~ /requires skill in ([a-zA-Z ]+) to use effectively/
         
-            @props['weapon_type']= $1
+            @props["weapon_type"]= $1
             if line =~ /It appears to be a modified ([a-zA-Z -]+)/
-              @props['weapon_base']= $1
+              @props["weapon_base"]= $1
             else
-              @props['weapon_base']= @noun
+              @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
+            @props["material"]= $1
             raise Olib::Errors::Mundane
           end
           
           if line =~ /can hold liquids/
-            @props['liquid_container']=true
+            @props["liquid_container"]=true
           end
 
         end
@@ -464,34 +534,34 @@ module Olib
     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/
+      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|
+      return self if has? "description"
+      Olib.wrap(action "tap") { |line|
         next unless line=~ /You tap (.*?) (on|in)/
-        define 'description', $1 
+        define "description", $1 
         raise Olib::Errors::Mundane         
       }
       self
     end
 
     def price
-      return self if(has? 'price' or has? 'info')
-      Olib.wrap(action 'get') { |line|
+      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]
+          define "price", line.match(/(?<price>\d+) silvers/)[:price]
           raise Olib::Errors::Mundane
         end
 
-        if line =~ /You can't pick that up/
+        if line =~ /You can"t pick that up/
           define "info", true
           raise Olib::Errors::Mundane
         end
@@ -503,38 +573,36 @@ module Olib
     end
 
     def read
-      return self if has? 'read'
+      return self if has? "read"
       scroll    = false
       multiline = false
-      Olib.wrap_stream(action 'read') {  |line|
+      Olib.wrap_stream(action "read") {  |line|
 
         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./
+        raise Olib::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
+        @props["read"] = @props["read"].concat line if multiline
 
         # capture spell
-        if scroll && line =~ /\(([0-9]+)\) ([a-zA-Z'\s]+)/
-            n    = $1
-            name = $2
-            spell = {'n' => $1, 'name' => $2}
+        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
+            @props["spells"].push spell
 
         # begin scroll
         elsif line =~ /It takes you a moment to focus on the/
           scroll = true
-          @props['spells'] = Array.new 
+          @props["spells"] = Array.new 
 
         # open multiline
         elsif line =~ /^In the (.*?) language, it reads/
           multiline          = true
-          @props['read']     = "#{line}\n"
-          @props['language'] = $1
+          @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 (.*?)./
+        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