Olib 0.1.0 → 0.1.1

data/lib/Olib/character/char.rb

@@ -1,6 +1,13 @@
 class Char
+  EMPATH     = "Empath"
+  Duration   = Struct.new(:seconds, :minutes, :hours)
+  INJURIES   = Wounds.singleton_methods
+    .map(&:to_s)
+    .select do |m| m.downcase == m && m !~ /_/ end.map(&:to_sym)
+
   @@silvers  = 0
   @@routines = {}
+  @@aiming   = nil
 
   def Char.hide
     while not hiding?
@@ -14,6 +21,48 @@ class Char
     Char
   end
 
+  def Char.arm
+    fput "gird"
+    self
+  end
+
+  def Char.unarm
+    fput "store both"
+    self
+  end
+
+  def Char.swap
+    fput "swap"
+    self
+  end
+
+  def Char.stand
+    unless standing?
+      fput "stand"
+      waitrt?
+    end
+    self
+  end
+
+  def Char.spell(num)
+    hour, minutes, seconds = Spell[num].remaining.split(":").map(&:to_f)
+    total_seconds = seconds + (minutes * 60.00) + (hour * 60.00 * 60.00)
+
+    Duration.new(
+      total_seconds,
+      total_seconds/60,
+      total_seconds/60/60,
+    )
+  end
+
+  def Char.aim(location)
+    unless @@aiming == location
+      fput "aim #{location}"
+      @@aiming = location
+    end
+    self
+  end
+
   def Char.fwi_teleporter
     Vars.teleporter || Vars.mapdb_fwi_trinket
   end
@@ -27,6 +76,10 @@ class Char
     Char
   end
 
+  def Char.in_town?
+    Room.current.location =~ /the Adventurer's Guild|kharam|teras|landing|sol|icemule trace|mist|vaalor|illistim|rest|cysaegir|logoth/i
+  end
+
   def Char.left
     GameObj.left_hand.name == "Empty" ? nil : Olib::Item.new(GameObj.left_hand)
   end
@@ -75,7 +128,7 @@ class Char
   end
 
   def Char.deplete_wealth(silvers)
-    @@silvers = @@silvers - silvers
+    #@@silvers = @@silvers - silvers
   end
 
   def Char.smart_wealth
@@ -109,5 +162,22 @@ class Char
     @@silvers
   end
 
+  def Char.total_wound_severity
+    INJURIES
+      .reduce(0) do |sum, method| sum + Wounds.send(method) end
+  end
+
+  def Char.wounded?
+    total_wound_severity.gt(0)
+  end
+
+  def Char.empty_hands
+    hands = [Char.left, Char.right].compact
 
+    hands.each do |hand| Containers.Lootsack.add hand end
+
+    yield
+
+    hands.each(&:take)
+  end
 end

data/lib/Olib/character/disk.rb

@@ -0,0 +1,19 @@
+class Disk
+  attr_accessor :owner, :full
+
+  def initialize(owner)
+    @owner = owner
+    @full  = false
+    GameObj.loot.find do |item|
+      item.name.downcase =~/#{owner.downcase}/
+    end
+  end
+
+  def add(item)
+
+  end
+
+  def full?
+    @full
+  end
+end

data/lib/Olib/character/group.rb

@@ -1,69 +1,206 @@
-module Olib
-  class Group
-    @@characters             = {}
-    @@checked                = false
-    @@characters[Char.name]  = true  # YOU CAN NEVER ESCAPE YOURSELF (so your own disk won't fuck up)
-    @@leader                 = Char.name
-
-    # ran at the initialization of a script
-    def Group.check
-      @@characters             = {}
-      
-      
-      fput "group"
-      while line=get
-        break            if line =~ /You are not currently in a group/
-        Group.define($1) if line =~ /([a-zA-Z]+) (is following you|is also a member of your group|is the leader of your group)/
-        @@leader = $1    if line =~ /([a-zA-Z]+) is the leader of your group/
-        break            if line =~ /^Your group status is/
-      end
-      @@checked = true
-      @@characters
+require "ostruct"
+
+
+class String
+  def is_i?
+    !!(self =~ /\A[-+]?[0-9]+\z/)
+  end
+end
+
+
+class MatchData
+  def to_struct
+    OpenStruct.new to_hash
+  end
+
+  def to_hash
+    Hash[self.names.zip(self.captures.map(&:strip).map do |capture|  
+      if capture.is_i? then capture.to_i else capture end
+    end)]
+  end
+end
+
+class Hash
+  def to_struct
+    OpenStruct.new self
+  end
+end
+
+module Group
+  class Members
+    include Enumerable
+    attr_accessor :leader, :members, :birth
+    def initialize
+      @birth   = Time.now
+      @members = []
     end
 
-    def Group.leader
-      @@leader
+    def clear!
+      @members = []
+      @birth   = Time.now
+      @leader  = nil
     end
 
-    def Group.leader?
-      Group.check unless @@checked
-      @@leader == Char.name
+    def size
+      @members.size
     end
 
-    def Group.whisper(msg)
-      fput "whisper group #{msg}" unless Group.members.empty?
+    def empty?
+      @members.empty?
     end
-    
-    def Group.add(char)
-      fput "group #{char}"
-      Group.define(char)
+
+    def add(pc, leader = false)      
+      member = Member.new pc, leader
+      if leader
+        @leader = member
+      end
+      @members << member
       self
     end
 
-    def Group.remove(char)
-      fput "remove #{char}"
-      @@characters.delete(char)
+    def each(&block)
+      @members.each { |char| yield char }
       self
     end
 
-    def Group.nonmembers
-      Group.check unless @@checked
-      others      = GameObj.pcs.map! {|char| char.noun } || []
-      # find all the disks/hidden players too
-      disk_owners = GameObj.loot.find_all { |obj| (obj.noun == 'disk') }.map{|disk| /([A-Z](?:[a-z]+))/.match(disk.name)[0].strip } || []
-      [others, disk_owners].flatten.reject(&:nil?).uniq - @@characters.keys
+    def include?(pc)
+      select { |char| char.name == pc }
     end
 
-    def Group.members
-      Group.check unless @@checked
-      @@characters.keys
+    def nonmembers
+      (GameObj.pcs || []).reject do |pc|
+        @members.include?(pc)
+      end
     end
 
-    def Group.define(name)
-      GameObj.pcs.detect do |pc| @@characters[name] = pc.dup if pc.noun == name end
+    def to_s
+      "<Members: [#{@members.join(" ")}]>"
     end
   end
-end
 
-class Group < Olib::Group
+  class Member
+    attr :id, :leader
+    def initialize(pc, leader = false)
+      @id     = pc.id
+      @leader = leader
+    end
+
+    private def ref
+      GameObj[@id]
+    end
+
+    def leader?
+      @leader
+    end
+
+    def name
+      ref.name.split.pop
+    end
+
+    def status
+      (ref.status.split(" ") || []).map(&:to_sym)
+    end
+
+    def is(state)
+      status =~ state
+    end
+
+    def ==(other)
+      @id == other.id
+    end
+
+    def to_s
+      "<#{name}: @leader=#{leader?} @status=#{status}>"
+    end
+  end
+
+  MEMBERS    = Members.new
+  OPEN       = :open
+  CLOSED     = :closed
+  CHECK_HOOK = self.name.to_s
+  NO_GROUP   = /You are not currently in a group/
+  MEMBER     = /<a exist="(?<id>.*?)" noun="(?<name>.*?)">(.*?)<\/a> is (?<type>(the leader|also a member) of your group|following you)\./
+  STATE      = /^Your group status is currently (?<state>open|closed)\./
+  END_GROUP  = /list of other options\./
+
+  PARSER = Proc.new do |line|
+    
+    if line.strip.empty? || line =~ NO_GROUP
+      nil
+    elsif line =~ STATE
+      nil
+    elsif line =~ END_GROUP
+      Group.checked!
+      DownstreamHook.remove(CHECK_HOOK)
+      nil
+    elsif line =~ MEMBER
+      begin
+        pc = line.match(MEMBER).to_struct
+        Group::MEMBERS.add GameObj[pc.name], (line =~ /leader/ ? true : false)
+        if line =~ /following/
+          Group::MEMBERS.leader = OpenStruct.new(name: Char.name, leader: true)
+        end
+        nil 
+      rescue Exception => e
+        respond e
+        respond e.backtrace
+      end
+    else
+      line
+    end
+  end
+
+  @@checked  = false
+
+  def Group.checked?
+    @@checked
+  end
+
+  def Group.checked!
+    @@checked = true
+    self
+  end
+
+  def Group.empty?
+    MEMBERS.empty?
+  end
+
+  def Group.exists?
+    !empty?
+  end
+
+  def Group.members
+    maybe_check
+    MEMBERS
+  end
+
+  def Group.to_s
+    MEMBERS.to_s
+  end
+
+  # ran at the initialization of a script
+  def Group.check
+    @@checked = false
+    MEMBERS.clear!
+    DownstreamHook.add(CHECK_HOOK, PARSER)
+    Game._puts "<c>group\r\n"
+    wait_until { Group.checked? }
+    MEMBERS
+  end
+
+  def Group.maybe_check
+    Group.check unless checked?
+  end
+
+  def Group.nonmembers
+    members.nonmembers
+  end
+
+  def Group.leader
+    members.leader
+  end
+
+  def Group.leader?
+    leader && leader.name == Char.name
+  end
 end

data/lib/Olib/character/inventory.rb

@@ -1,80 +1,21 @@
-module Olib
-  module Inventory
-    Vars.Olib[:Inventory] ||= Hash.new
-
-    @@checked = false
-
-    
-    def Inventory.containers
-      Inventory.check
-      GameObj.containers
-    end
-
-    def Inventory.to_s
-      Inventory.items.map(&:to_s)
-    end
-
-    def Inventory.checked?
-      @@checked
-    end
-
-    def Inventory.[](query)
-      GameObj.inv.select { |item|
-        item.name == query || item.id == query
-      }
-    end
-
-    def Inventory.fwi_teleporter
-      # check for worn teleporter
-      candidates= GameObj.inv.select { |item|
-        item.name == Char.fwi_teleporter
-      }
-
-      unless candidates.empty?
-        return Item.new(candidates.first)
-      end
-
-      # check in containers
-      Inventory.items.select { |item|
-        item.is? "teleporter"
-      }.first
-    end
-    
-    def Inventory.items
-      Inventory.containers.map { |id, contents| contents.map {|item|
-          Item.new(item).define("container", id)
-        } 
-      }.flatten
-    end
-
-    def Inventory.check
-      return self if Inventory.checked?
-      GameObj.inv.select{ |item|
-        !item.name.include?('tattoo')
-      }.each {|item|
-        if item.contents.nil?
-          Olib.wrap("look in ##{item.id}") { |line|
-            respond line =~ /Shadow engulf/
+module Inventory
+  def Inventory.containers
+    GameObj.containers
+  end
 
-            raise Olib::Errors::Mundane if line =~ /There is nothing in there.|Total|^In the (.*).$|prompt|^Shadows engulf/
+  def Inventory.to_s
+    Inventory.items.map(&:to_s)
+  end
 
-            if line =~ /That is closed./
-              Olib.wrap("open ##{item.id}") { |line|
-                if line =~ /You open/
-                  multifput "look in ##{item.id}", "close ##{item.id}"
-                end
-              } 
-            end
-          }
-        end
-      }
-      @@checked = true
-      return self
-    end
-  
+  def Inventory.[](query)
+    GameObj.inv.select { |item|
+      item.name == query || item.id == query
+    }
   end
 
-  def Olib.Inventory
-    Olib::Inventory
+  def Inventory.items
+    containers.map do |id, contents|
+      contents.map(&:to_item)
+    end.flatten
   end
 end