Olib 2.0.0.pre.rc.1 → 2.0.0.pre.rc.6

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,13 @@
+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
+  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

@@ -2,7 +2,8 @@
 require "Olib/core/action"
 
 class Exist
-  GETTER = %r[\w$]
+  GETTER  = %r[\w$]
+  PATTERN = %r(<a exist=(?:'|")(?<id>.*?)(?:'|") noun=(?:'|")(?<noun>.*?)(?:'|")>(?<name>.*?)</a>)
 
   def self.fetch(id)
     [ GameObj.inv, GameObj.containers.values, 
@@ -12,8 +13,12 @@ class Exist
                                              .find do |item| item.id.to_s.eql?(id.to_s) end
   end
 
+  def self.scan(str)
+    str.scan(PATTERN).map do |matches| Item.new(GameObj.new(*matches)) end
+  end
+
   def self.normalize_type_data(type)
-    (type or "").gsub(",", " ").split(" ")
+    (type or "").gsub(",", " ").split(" ").compact
   end
 
   attr_reader :id, :gameobj
@@ -35,6 +40,8 @@ class Exist
   end
 
   def method_missing(method, *args)
+    return nil if fetch.nil?
+
     if respond_to_missing?(method)
       fetch.send(method, *args)
     else
@@ -51,7 +58,7 @@ class Exist
   end
 
   def tags
-    Exist.normalize_type_data(type).map(&:to_sym)
+    Exist.normalize_type_data("#{type},#{sellable}").map(&:to_sym)
   end
 
   def effects
@@ -72,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
@@ -53,6 +60,10 @@ class Item < Exist
     Transaction.new(take, **args)
   end
 
+  def appraise(**args)
+    transaction(**args).appraise()
+  end
+
   def sell(**args)
     transaction(**args).sell()
   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,6 +5,7 @@ class Transaction < Exist
     start: %[to appraise (?:a |an |)<a exist="{{id}}"],
     close: Regexp.union(
       %r[I already appraised that],
+      %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])
     )
@@ -14,6 +15,9 @@ class Transaction < Exist
     close: Regexp.union(
       %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,13 @@ 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, Pixelia, I'm not buying anything this valuable today.])}
+      @value = Float::INFINITY
+    else
+      @value = match[:value].to_i
+    end
     self
   end
 
@@ -46,8 +54,12 @@ 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}}")
+
+    
+    match[:value] = 0 unless match[:value].is_a?(Integer)
     Ok[**match]
   end
 end

data/lib/Olib/ext/matchdata.rb

@@ -3,7 +3,7 @@ require "Olib/ext/string"
 
 class MatchData
   def to_struct
-    OpenStruct.new to_hash
+    OpenStruct.new to_h
   end
 
   def to_h

data/lib/Olib/go2.rb

@@ -32,8 +32,7 @@ class Go2
   def Go2.room(roomid)
     unless Room.current.id == roomid || Room.current.tags.include?(roomid)
       Char.unhide if hidden
-      start_script "go2", [roomid, "_disable_confirm_"]
-      wait_while { running? "go2" };
+      Script.run("go2", "#{roomid} _disable_confirm_")
     end
     Go2
   end

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