Olib 2.0.0.pre.rc.2 → 2.0.0.pre.rc.7

data/lib/Olib/combat/creatures.rb

@@ -1,11 +1,8 @@
-require 'net/http'
 require 'json'
 # a collection for managing all of the creatures in a room
 
 class Creatures
   include Enumerable
-
-  METADATA_URL = "https://cdn.rawgit.com/ondreian/gemstone_data_project/c40a5dfb/creatures.json"
   
   ARCHETYPES = %i[ 
     undead living weak
@@ -15,7 +12,6 @@ class Creatures
 
   STATES = %i[
     prone sitting kneeling
-    dead 
     sleeping webbed immobile
     stunned 
     flying
@@ -23,22 +19,6 @@ class Creatures
 
   KINDS = ARCHETYPES + STATES
 
-  def self.fetch_metadata()
-    begin
-      JSON.parse Net::HTTP.get URI METADATA_URL
-    rescue
-      puts $!
-      puts $!.backtrace[0..1]
-      []
-    end
-  end
-
-  METADATA = fetch_metadata()
-  BY_NAME  = METADATA.reduce(Hash.new) do |by_name, record|
-    by_name[record["name"]] = record
-    by_name
-  end
-
   ALL = -> creature { true }
 
   attr_reader :predicate
@@ -48,9 +28,9 @@ class Creatures
   end
 
   def each()    
-    GameObj.npcs.to_a.map do |obj| Creature.new(obj) end
+    GameObj.targets.to_a.map do |obj| Creature.new(obj) end
       .select(&@predicate)
-      .each do |creature| yield(creature) if GameObj[creature.id] and creature.aggressive? end
+      .each do |creature| yield(creature) if GameObj[creature.id] end
   end
 
   def respond_to_missing?(method, include_private = false)
@@ -75,6 +55,12 @@ class Creatures
     Creatures.new do |creature| creature.name.include?(Bounty.creature) end
   end
 
+  def dead
+    GameObj.npcs.to_a
+      .select do |c| c.status.include?("dead") end
+      .map do |obj| Creature.new(obj) end
+  end
+
   def self.method_missing(method, *args, &block)
     if respond_to?(method)
       Creatures.new.send(method, *args, &block)

data/lib/Olib/combat/metadata.rb

@@ -0,0 +1,17 @@
+class Creatures
+  module Metadata
+    @repo = JSON.parse File.read File.join(__dir__, "creatures.json")
+
+    def self.put(name:, level:, tags: [])
+      @repo[name.downcase] = {name: name, level: level, tags: tags}
+    end
+
+    def self.get(name)
+      @repo.fetch(name.downcase) do {name: name, level: Char.level, tags: []} end
+    end
+
+    def self.repo()
+      @repo.values.map {|creature| OpenStruct.new(creature)}
+    end
+  end
+end

data/lib/Olib/core/action.rb

@@ -1,4 +1,10 @@
 module Action
+  LOCK = Mutex.new
+
+  def self.lock()
+    LOCK.synchronize { yield }
+  end
+
   def self.try_or_fail(seconds: 5, command: nil)
     fput(command)
     expiry = Time.now + seconds

data/lib/Olib/core/container.rb

@@ -23,7 +23,11 @@ class Container < Exist
   end
 
   def contents
-    GameObj.containers.fetch(id, []).map do |item| Item.new(item, self) end
+    GameObj.containers.fetch(id, []).map do |item| Item.of(item, self) end
+  end
+
+  def closed?
+    not GameObj.containers[id]
   end
 
   def each(&block)

data/lib/Olib/core/containers.rb

@@ -1,31 +1,45 @@
 require "Olib/pattern_matching/pattern_matching"
 
 module Containers
-  @@containers = {}
-
-  def self.find_game_obj!(name)
-    var     = Vars[name.to_s] or fail Exception, "Var[#{name}] is not set\n\t;vars set #{name}=<whatever>"
-    pattern = %r[#{var}]
-    GameObj.inv.find(&Where[name: pattern]) or fail Exception, "#{name.capitalize}(#{var}) could not be found in GameObj.inv"
+  @@containers ||= {}
+
+  def self.find_game_obj!(pattern)
+    candidates = GameObj.inv.select do |item|
+      if pattern.class.is_a?(String)
+        item.name.include?(pattern)
+      else
+        item.name.match(pattern)
+      end
+    end
+    case candidates.size
+    when 1
+      return Container.new(candidates.first)
+    when 0
+      fail Exception, <<~ERROR
+        Source(GameObj.inv)
+
+         reason: no matches for Pattern(#{pattern}) found in GameObj.inv
+      ERROR
+    else
+      fail Exception, <<~ERROR
+        Source(GameObj.inv)
+
+         reason: aspecific Container[#{pattern.to_s}] found
+        matches: #{candidates.map(&:name)}
+      ERROR
+    end
   end
 
   def self.define(name)
-    @@containers[name] = Container.new(
-      Containers.find_game_obj!(name))
+    var = Vars[name.to_s] or fail Exception, "Var[#{name}] is not set\n\t;vars set #{name}=<whatever>"
+    pattern = %r[#{var}]
+    @@containers[name] = Containers.find_game_obj!(pattern)
     @@containers[name]
   end
 
-  def self.method_missing(name, *args)
-    return @@containers[name] if @@containers[name]
-    return self.define(name)
-  end
-
   def self.[](name)
-    begin
-      self.define(name)
-    rescue Exception => err
-      Err(why: err.message, error: err)
-    end
+    return define(name) if name.is_a?(Symbol)
+    find_game_obj!(name)
   end
 
   def self.right_hand
@@ -39,4 +53,9 @@ module Containers
   def self.registry
     @@containers
   end
+
+  def self.method_missing(name, *args)
+    return @@containers[name] if @@containers[name]
+    return self.define(name)
+  end
 end

data/lib/Olib/core/exist.rb

@@ -79,17 +79,9 @@ class Exist
     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})]
+  def deconstruct_keys(keys)
+    keys.each_with_object({}) do |key, acc|
+      acc[key] = self.send(key)
+    end
   end
 end

data/lib/Olib/core/item.rb

@@ -2,6 +2,7 @@ require "ostruct"
 require "Olib/core/exist"
 require "Olib/core/use"
 require "Olib/core/transaction"
+require "Olib/core/scroll"
 
 class GameObj
   def to_item
@@ -12,6 +13,12 @@ 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.of(item, container = nil)
+    return Scroll.new(item, container) if item.type.include?("scroll")
+    return Item.new(item, container)
+  end
+
+
   def self.fetch(id)
     new Exist.fetch(id)
   end

data/lib/Olib/core/scroll.rb

@@ -0,0 +1,37 @@
+class Scroll < Exist
+  SPELL = %r[\((?<num>\d+)\)\s(?<name>(\w|\s)+)$]
+
+  def initialize(obj, container = nil)
+    super(obj.id)
+    @knowledge = nil
+    @container = container
+  end
+
+  def spells()
+    @_spells ||= _read()
+  end
+
+  def knowledge?
+    spells
+    @knowledge.eql?(true)
+  end
+
+  def _read()
+    Script.current.want_downstream_xml = true
+    dothistimeout("read ##{id}", 5, /It takes you a moment to focus on the/)
+    spells = []
+    @knowledge = false
+    while line = get
+      @knowledge = true if line.include?(%[in vibrant ink])
+      break if line =~ %r[<prompt]
+      _parse_spell(spells, line.strip)
+    end
+    Script.current.want_downstream_xml = false
+    return spells
+  end
+
+  def _parse_spell(spells, line)
+    return unless line =~ SPELL
+    spells << OpenStruct.new(line.match(SPELL).to_h)
+  end
+end

data/lib/Olib/core/transaction.rb

@@ -5,15 +5,19 @@ class Transaction < Exist
     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])
+      %r[Sorry, #{Char.name}, I'm not buying anything this valuable today\.],
+      %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[(hands you|for) (?<value>[,\d]+)],
       %r[No #{Char.name}, I won't buy that],
+      %r[I'm sorry, #{Char.name}, but I have no use for that\.],
+      %r[He hands it back to you],
+      %r[Nope #{Char.name}, I ain't buying that\.],
       %r[basically worthless here, #{Char.name}])
     )
   
@@ -33,9 +37,14 @@ class Transaction < Exist
   def appraise()
     return self unless @value.nil?
     take
-    (match, _lines) = Appraise.capture(self.to_h, 
+    (_, match, lines) = Appraise.capture(self.to_h, 
       "appraise \#{{id}}")
-    @value = match[:value].to_i
+    if lines.any? {|line| line.include?(%[Sorry, #{Char.name}, I'm not buying anything this valuable today.])}
+      @value = Float::INFINITY
+    else
+      Log.out(match[:value])
+      @value = match[:value].delete(",").to_i
+    end
     self
   end
 
@@ -46,8 +55,15 @@ class Transaction < Exist
         transaction: self,
         reason:      "Value[#{@value}] is over Threshold[#{@threshold}]"] 
     end
-    (match, _lines) = Sell.capture(self.to_h, 
+  
+    (_, match, _lines) = Sell.capture(self.to_h, 
       "sell \#{{id}}")
+
+    if match[:value].is_a?(String) && match[:value] =~ /[\d,]+/
+      match[:value] = match[:value].delete(",").to_i
+    end
+
+    match[:value] = 0 unless match[:value].is_a?(Integer)
     Ok[**match]
   end
 end

data/lib/Olib/ext/matchdata.rb

@@ -8,7 +8,7 @@ class MatchData
 
   def to_h
     Hash[self.names.map(&:to_sym).zip(self.captures.map(&:strip).map do |capture|  
-      if capture.is_i? then capture.to_i else capture end
+      if capture.is_i? then capture.delete(",").to_i else capture end
     end)]
   end
 end

data/lib/Olib/ext/string.rb

@@ -1,6 +1,6 @@
 class String
   def is_i?
-    !!(self =~ /\A[-+]?[0-9]+\z/)
+    !!(self.delete(",") =~ /\A[-+]?[0-9]+\z/)
   end
 
   def methodize

data/lib/Olib/go2.rb

@@ -29,24 +29,32 @@ class Go2
     Go2.define_singleton_method(tag.methodize) do Go2.room(tag) end
   end
 
-  def Go2.room(roomid)
-    unless Room.current.id == roomid || Room.current.tags.include?(roomid)
+  def Go2.run(target)
+    Script.run "go2", ("%s _disable_confirm_" % target)
+  end
+
+  def Go2.room(target)
+    starting_room = Room.current.id
+    unless Room.current.id == target || Room.current.tags.include?(target)
       Char.unhide if hidden
-      start_script "go2", [roomid, "_disable_confirm_"]
-      wait_while { running? "go2" };
+      Go2.run(target)
+      if block_given?
+        yield
+        starting_room
+      end
     end
     Go2
   end
 
   def Go2.origin
-    Go2.room @@origin[:roomid]
+    Go2.room @@origin[:target]
     Char.hide if @@origin[:hidden]
     Go2
   end
 
   def Go2.rebase
     @@origin            = {}
-    @@origin[:roomid]   = Room.current.id
+    @@origin[:target]   = Room.current.id
     @@origin[:hidden]   = hiding?
     @@origin[:location] = Room.current.location
     Go2

data/lib/Olib/log.rb

@@ -0,0 +1,42 @@
+module Preset
+  def self.as(kind, body)
+    %[<preset id="#{kind}">#{body}</preset>\r\n]
+  end
+end
+##
+## contextual logging
+##
+module Log  
+  require "cgi"
+  def self.out(msg, label: :debug)
+    return _write _view(msg, label) unless msg.is_a?(Exception)
+    ## pretty-print exception
+    _write _view(msg.message, label)
+    msg.backtrace.to_a.slice(0..5).each do |frame| _write _view(frame, label) end
+  end
+
+  def self._write(line)
+    if Script.current.vars.include?("--headless") or not defined?(:_respond)
+      $stdout.write(line + "\n")
+    elsif line.include?("<") and line.include?(">")
+      respond(line)
+    else
+      _respond Preset.as(:debug, CGI.escapeHTML(line))
+    end
+  end
+
+  def self._view(msg, label)
+    label = [Script.current.name, label].flatten.compact.join(".")
+    safe = msg.inspect
+    #safe = safe.gsub("<", "&lt;").gsub(">", "&gt;") if safe.include?("<") and safe.include?(">")
+    "[#{label}] #{safe}"
+  end
+
+  def self.pp(msg, label = :debug)
+    respond _view(msg, label)
+  end
+
+  def self.dump(*args)
+    pp(*args)
+  end
+end

data/lib/Olib/loot.rb

@@ -10,8 +10,9 @@ class Loot
   end
 
   def each()    
-    GameObj.loot.to_a.map do |obj| Item.new(obj) end
+    GameObj.loot.to_a
       .reject(&Where[noun: "disk"])
+      .map do |obj| Item.new(obj) end
       .select(&@predicate)
       .each do |item| yield(item) end
   end

data/lib/Olib/opts.rb

@@ -0,0 +1,42 @@
+##
+## minimal options parser
+##
+module Opts
+  FLAG_PREFIX    = "--"
+  
+  def self.parse_command(h, c)
+    h[c.to_sym] = true
+  end
+
+  def self.parse_flag(h, f)
+    (name, val) = f[2..-1].split("=")
+    if val.nil?
+      h[name.to_sym] = true
+    else
+      val = val.split(",")
+
+      h[name.to_sym] = val.size == 1 ? val.first : val
+    end
+  end
+
+  def self.parse(args = Script.current.vars[1..-1])        
+    OpenStruct.new(**args.to_a.reduce(Hash.new) do |opts, v|
+      if v.start_with?(FLAG_PREFIX)
+        Opts.parse_flag(opts, v)
+      else
+        Opts.parse_command(opts, v)
+      end
+      opts
+    end)
+  end
+
+  def self.as_list(key)
+    val = to_h.fetch(key.to_sym, [])
+    val = [val] if val.is_a?(String)
+    return val
+  end
+
+  def self.method_missing(method, *args)
+    parse.send(method, *args)
+  end
+end