Olib 0.1.2 → 2.0.0.pre.rc.1

data/lib/Olib/combat/creatures.rb

@@ -1,25 +1,29 @@
-require 'Olib/interface/queryable'
 require 'net/http'
 require 'json'
 # a collection for managing all of the creatures in a room
 
-class Creatures < Interface::Queryable
+class Creatures
+  include Enumerable
 
   METADATA_URL = "https://cdn.rawgit.com/ondreian/gemstone_data_project/c40a5dfb/creatures.json"
   
-  ARCHETYPES = [
-    :undead, :living, :weak, :grimswarm,
-    :antimagic, :flying, :lowly, :bandit,
-    :aggressive,
+  ARCHETYPES = %i[ 
+    undead living weak
+    grimswarm antimagic flying 
+    lowly bandit aggressive
   ]
 
-  STATES = [
-    :dead, :sleeping, :webbed, :immobile,  
-    :stunned, :prone, :sitting, 
-    :kneeling, :flying
+  STATES = %i[
+    prone sitting kneeling
+    dead 
+    sleeping webbed immobile
+    stunned 
+    flying
   ]
 
-  def Creatures.fetch_metadata!
+  KINDS = ARCHETYPES + STATES
+
+  def self.fetch_metadata()
     begin
       JSON.parse Net::HTTP.get URI METADATA_URL
     rescue
@@ -29,46 +33,58 @@ class Creatures < Interface::Queryable
     end
   end
 
-  METADATA = fetch_metadata!
+  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
+  ALL = -> creature { true }
+
+  attr_reader :predicate
+
+  def initialize(&predicate)
+    @predicate = predicate
   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
+  def each()    
+    GameObj.npcs.to_a.map do |obj| Creature.new(obj) end
+      .select(&@predicate)
+      .each do |creature| yield(creature) if GameObj[creature.id] and creature.aggressive? end
+  end
+
+  def respond_to_missing?(method, include_private = false)
+    to_a.respond_to?(method) or super
   end
 
-  [ARCHETYPES, STATES].flatten.each do |state|
-    Creatures.define_singleton_method(state) do
-      select do |creature|
-        [creature.tags, creature.status].flatten.include?(state)
-      end
+  def method_missing(method, *args)
+    if to_a.respond_to?(method)
+      to_a.send(method, *args)
+    else
+      super(method, *args)
     end
   end
 
-  def self.living
-    reject do |creature|
-      creature.undead?
+  KINDS.each do |kind|
+    define_method(kind) do
+      Creatures.new do |creature| [creature.tags, creature.status].flatten.include?(kind) end
     end
   end
 
-  def self.bounty
-    select do |creature|
-      creature.name.include?(Bounty.creature)
+  def bounty
+    Creatures.new do |creature| creature.name.include?(Bounty.creature) end
+  end
+
+  def self.method_missing(method, *args, &block)
+    if respond_to?(method)
+      Creatures.new.send(method, *args, &block)
+    else
+      super(method, *args, &block)
     end
   end
+
+  def self.respond_to?(method)
+    return super(method) unless Creatures.new.respond_to?(method)
+    return true
+  end
 end

data/lib/Olib/core/action.rb

@@ -0,0 +1,8 @@
+module Action
+  def self.try_or_fail(seconds: 5, command: nil)
+    fput(command)
+    expiry = Time.now + seconds
+    wait_until do yield or Time.now > expiry end
+    Err[command: command, seconds: seconds, reason: :not_found] if Time.now > expiry
+  end
+end

data/lib/Olib/core/container.rb

@@ -1,266 +1,62 @@
 # for defining containers ala lootsack and using them across scripts
-require "Olib/core/extender"
+require "Olib/core/exist"
 require "Olib/core/item"
-
-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
+require "Olib/core/action"
 
 class GameObj
   def to_container
-    Olib::Container.new self.id
-  end
-end
-
-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 = 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"
-        ]
-
-        action = tops.include?(@ref.noun) ? "look on ##{@ref.id}" : "look in ##{@ref.id}"
-         
-        fput action
-      end
-      
-      super @ref
-            
-    end
-
-    def contents
-      [ @ontop,
-        GameObj[@ref.id].contents.map do |item| Item.new(item, self) end
-      ].flatten
-    end
-
-    def where(conditions)
-      contents.select { |item|
-        !conditions.keys.map { |key|
-          if conditions[key].class == Array
-            item.props[key].class == Array && !conditions[key].map { |ele| item.props[key].include? ele }.include?(false)
-          else
-            item.props[key] == conditions[key]
-          end
-        }.include?(false)
-      }
-    end
-
-    def find_by_tags(*tags)  
-      contents.select { |item|
-        !tags.map {|tag| item.is?(tag) }.include?(false)
-      }
-    end
-
-
-    def [](query)
-      return contents.select do |item| 
-        item if (item.type =~ query || item.noun =~ query || item.name =~ query)
-      end
-    end
-
-    def 
-
-    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 Olib::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 Olib::Errors::Mundane
-        end
-        
-      }
-      self
-    end
-
-    def look
-      self
-    end
-
-    def on
-      return self unless @id
-      Olib.wrap_stream("look on ##{@id}") { |line|
-        raise Olib::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 Olib::Errors::Mundane
-        end
-        next
-      }
-      self
-    end
-
-    def in
-      fput "look in ##{@id}"
-      self
-    end
-
-    def rummage
-      Rummage.new(self)
-    end
-
-    def nested?
-      @nested
-    end
-
-    def full?
-      is? "full"
-    end
-
-    def add(*items)
-      _id = @id
-      items.each { |item|
-
-        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 method_missing(name, *args)
-      where(noun: name.to_s)
-    end
-
-    def to_s
-      "<Container:#{@id} @name=#{@name} @contents=[#{contents}]>"
-    end
+    Container.new(self)
   end
 end
 
-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: SUCCESS.or(FAIL)
-  )
+class Container < Exist
+  TOPS = %w(table)
+  include Enumerable
 
-  def Rummage.message
-    @@message
+  def initialize(obj)
+    super(obj)
+    fput "look in ##{obj.id}" unless GameObj.containers.fetch(id, false)  
   end
 
-  attr_accessor :container
-
-  def initialize(container)
-    @container = container
+  def check_contents
+    fput TOPS.include?(noun) ? "look on ##{id}" : "look in ##{id}"  
   end
 
-  def perform(mod, query)
-    res = Olib.do "rummage ##{@container.id} #{mod} #{query}", Rummage.message.either
-    [!res.match(FAIL), res]
+  def contents
+    GameObj.containers.fetch(id, []).map do |item| Item.new(item, self) end
   end
 
-  def spell(number)
-    perform "spell", number
+  def each(&block)
+    contents.each(&block)
   end
 
-  def runestone(rune)
-    perform "runestone", rune
+  def where(**query)
+    contents.select(&Where[**query])
   end
 
-  def ingredient(str)
-    perform "ingredient", str
+  def type(type = nil)
+    return super() if type.nil?
+    find_by_tags(type)
   end
 
-  def holy(tier)
-    perform "holy", tier
+  def find_by_tags(*tags)
+    tags = tags.map(&:to_sym)
+    contents.select do |item| (item.tags & tags).size.eql?(tags.size) end
   end
-end
 
-# globalize
-class Container < Olib::Container
-end
-
-module Containers
-  @@containers = {}
-
-  def Containers.define(name)
-    container = Class.new(Olib::Container)
-    @@containers[name] = Object.const_set(name.capitalize, container).new
-    @@containers[name]
+  def rummage
+    Rummage.new(self)
   end
 
-  def Containers.method_missing(name)
-    return @@containers[name] if @@containers[name]
-    return Containers.define(name)
+  def to_json(*args)
+    {id: id, name: name, noun: noun, contents: contents}.to_json(*args)
   end
 
-  def Containers.[](name)
-    begin
-      Containers.define(name)
-    rescue Exception => e
-      nil
+  def add(*items)
+    items.flatten.each do |item|
+      Action.try_or_fail(command: "_drag ##{item.id} ##{id}") do
+        contents.map(&:id).include?(item.id.to_s)
+      end
     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/containers.rb

@@ -0,0 +1,42 @@
+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"
+  end
+
+  def self.define(name)
+    @@containers[name] = Container.new(
+      Containers.find_game_obj!(name))
+    @@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
+  end
+
+  def self.right_hand
+    Container.new(Char.right)
+  end
+
+  def self.left_hand
+    Container.new(Char.left)
+  end
+
+  def self.registry
+    @@containers
+  end
+end