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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59092281655cf2bb6035a9bf6117a4cd1b88539c2eb971041d13910f4d319f55
-  data.tar.gz: 26d0a65a8edfeba5077b6e9efc0887d8bdbcad394fa4b29af015a9281ab00f12
+  metadata.gz: 6b6389e96091c8dc8e79ea4bb25b9c30805c91d47f09addab1a1e2075976a9dc
+  data.tar.gz: 6008e2a6431503d0c72b17c7ec5e27a940ae7a2a4d4af807f6c11670f346794f
 SHA512:
-  metadata.gz: '038216104dd7f79a3d45d181a759b56256ed6bf611dfcece8f8c777886f6a5371c2476381af7ecc447567169265e9299275973f18fd492d32f37ba5573d86a7d'
-  data.tar.gz: 1638f640f0540fc425937dd963a4914e0d44cbb391cc77f2417bb9a9e99b6c4107733818ad4448b1c3858149c803fa9933d164307070040593ecd3d6768de2a0
+  metadata.gz: b19fd1ecffec4ddd4a0e8a587b8db4ccb9089c28ffc1d74c4bab90626a2e43e52efcdec7c2abbb8ae943331d7b5c3deac78e1a2674cfdd47dd6f6410294a0fdf
+  data.tar.gz: bf7d1ddb8a5d621f5a9c98656127a051c93842942c0079d061d415fbefd937450e57866ece27d978652af98881ba620b599575b65735aab76f5daf732d0a0b00

data/Olib.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
   s.authors       = ["Ondreian Shamsiel"]
   s.email         = "ondreian.shamsiel@gmail.com"
   s.homepage      = "https://github.com/ondreian/Olib"
-  s.files         = %w[Olib.gemspec] + Dir["*.md", "lib/**/*.rb"]
+  s.files         = %w[Olib.gemspec] + Dir["*.md", "lib/**/*.rb", "lib/**/*.json"]
   #s.require_paths = %w[lib]
   # s.add_runtime_dependency "shoes"
   s.license     = "MIT"

data/lib/Olib/bounty.rb

@@ -1,15 +1,15 @@
 require "ostruct"
 
 class Bounty
-  NPCS = /guard|sergeant|Felinium|clerk|purser|taskmaster|gemcutter|jeweler|akrash|kris|Ghaerdish|Furryback|healer|dealer|Ragnoz|Maraene|Kelph|Areacne|Jhiseth|Gaedrein/i
+  NPCS = /guard|sergeant|Luthrek|Felinium|clerk|purser|taskmaster|gemcutter|jeweler|akrash|kris|Ghaerdish|Furryback|healer|dealer|Ragnoz|Maraene|Kelph|Areacne|Jhiseth|Gaedrein/i
   HERBALIST_AREAS = /illistim|vaalor|legendary rest|solhaven/i
-  @@listeners = {}
+
   # this should be refactored to use CONST
   REGEX = OpenStruct.new(
-    creature_problem: /It appears they have a creature problem they\'d like you to solve/,
+    creature_problem: /"Hmm, I've got a task here from (?<town>.*?)\.  It appears they have a creature problem they\'d like you to solve/,
     report_to_guard:  /^You succeeded in your task and should report back to/,
     get_skin_bounty:  /The local furrier/,
-    heirloom_found:   /^You have located the heirloom and should bring it back to/,
+    heirloom_found:   /^You have located (?:a|an|some) (?<heirloom>.*?) and should bring it back to one of the (?<town>.*?) gate guards\./,
     cooldown:         /^You are not currently assigned a task.  You will be eligible for new task assignment in about (?<minutes>.*?) minute(s)./,
     
     dangerous: /You have been tasked to hunt down and kill a particularly dangerous (?<creature>.*) that has established a territory (?:in|on) (?:the )?(?<area>.*?)(?: near| between| under|\.)/,
@@ -17,25 +17,26 @@ class Bounty
     heirloom:  /^You have been tasked to recover (a|an|some) (?<heirloom>.*?) that an unfortunate citizen lost after being attacked by (a|an|some) (?<creature>.*?) (?:in|on|around|near|by) (?<area>.*?)(| near (?<realm>.*?))\./,
 
 
-    get_rescue:      /It appears that a local resident urgently needs our help in some matter/,
-    get_bandits:     /It appears they have a bandit problem they'd like you to solve./,
-    get_heirloom:    /It appears they need your help in tracking down some kind of lost heirloom/,
+    get_rescue:      /"Hmm, I've got a task here from (?<town>.*?)\.  It appears that a local resident urgently needs our help in some matter/,
+    get_bandits:     /"Hmm, I've got a task here from (?<town>.*?)\.  It appears they have a bandit problem they'd like you to solve./,
+    get_heirloom:    /"Hmm, I've got a task here from (?<town>.*?)\.  It appears they need your help in tracking down some kind of lost heirloom/,
     get_herb_bounty: /local herbalist|local healer|local alchemist/,
-    get_gem_bounty:  /The local gem dealer, (?<npc>[a-zA-Z ]+), has an order to fill and wants our help/,
+    get_gem_bounty:  /"Hmm, I've got a task here from (?<town>.*?)\.  The local gem dealer, (?<npc>[a-zA-Z ]+), has an order to fill and wants our help/,
 
     herb:   /requires (?:a |an |)(?<herb>.*?) found (?:in|on|around|near) (?<area>.*?)(| (near|between) (?<realm>.*?)).  These samples must be in pristine condition.  You have been tasked to retrieve (?<number>[\d]+)/,
     escort: /Go to the (.*?) and WAIT for (?:him|her|them) to meet you there.  You must guarantee (?:his|her|their) safety to (?<destination>.*?) as soon as/,
-    gem:    /has received orders from multiple customers requesting (?:a|an|some) (?<gem>[a-zA-Z '-]+).  You have been tasked to retrieve (?<number>[0-9]+)/,
-
+    gem:    /The gem dealer in (?<town>.*?), (?<npc>.*?), has received orders from multiple customers requesting (?:a|an|some) (?<gem>[a-zA-Z '-]+).  You have been tasked to retrieve (?<number>[0-9]+)/,
     cull:    /^You have been tasked to suppress (?<creature>(?!bandit).*) activity (?:in|on|around) (?<area>.*?)(| (near|between) (?<realm>.*?)).  You need to kill (?<number>[0-9]+)/,
-    bandits: /^You have been tasked to suppress bandit activity (?:in|on|around) (?<area>.*?) (?:near|between|under) (?<realm>.*?).  You need to kill (?<number>[0-9]+)/,
+    bandits: /^You have been tasked to suppress bandit activity (?:in|on|around|near) (?<area>.*?) (?:near|between|under) (?<realm>.*?).  You need to kill (?<number>[0-9]+)/,
 
     rescue:  /A local divinist has had visions of the child fleeing from (?:a|an) (?<creature>.*) (?:in|on) (?:the )?(?<area>.*?)(?: near| between| under|\.)/,
     failed:  /You have failed in your task/,
     none:    /You are not currently assigned a task/,
     skin:    /^You have been tasked to retrieve (?<number>\d+) (?<skin>.*?) of at least (?<quality>.*?) quality for (?<buyer>.*?) in (?<realm>.*?)\.\s+You can SKIN them off the corpse of (a|an|some) (?<creature>.*?) or/,
     
-    help_bandits: /You have been tasked to help (?<partner>.*?) suppress bandit activity (?:in|on|around) (?<area>.*?) (?:near|between|under) (?<realm>.*?).  You need to kill (?<number>[0-9]+)/
+    help_bandits: /You have been tasked to help (?<partner>.*?) suppress bandit activity (?:in|on|around|near) (?<area>.*?) (?:near|between|under) (?<realm>.*?).  You need to kill (?<number>[0-9]+)/,
+    help_creatures: /You have been tasked to help (?<partner>.*?) kill a dangerous creature by suppressing (?<creature>.*) activity (?:in|on|around|near) (?<area>.*?) (?:near|between|under) (?<realm>.*?) during the hunt.  You need to kill (?<number>[0-9]+)/,
+    help_cull: /You have been tasked to help (?<partner>.*?) suppress (?<creature>.*) activity (?:in|on|around|near) (?<area>.*?) (?:near|between|under) (?<realm>.*?).  You need to kill (?<number>[0-9]+)/,
   )
   
   # convenience list to get all types of bounties
@@ -115,23 +116,15 @@ class Bounty
     Bounty.parse(checkbounty)
   end
 
-  def Bounty.ask_for_bounty
-    if invisible?
-      fput "unhide"
-    end
-
-    if hidden?
-      fput "unhide"
-    end
-
-    if Bounty.npc
-      fput "ask ##{Bounty.npc.id} for bounty"
-      Bounty
+  def Bounty.ask_for_bounty(expedite: false)
+    fput "unhide" if invisible?
+    fput "unhide" if hidden?
+    raise Exception, "could not find Bounty.npc here" unless Bounty.npc
+    if expedite
+      fput "ask ##{Bounty.npc.id} for expedite" 
     else
-      raise Exception.new "could not find Bounty.npc here"
+      fput "ask ##{Bounty.npc.id} for bounty"
     end
-    # give the XML parser time to update
-    sleep 0.2
   end
 
   def Bounty.herbalist
@@ -149,15 +142,6 @@ class Bounty
     Bounty
   end
 
-  def Bounty.on(namespace, &block)
-    @@listeners[namespace] = block
-    Bounty
-  end
-
-  def Bounty.listeners
-    @@listeners
-  end
-
   def Bounty.cooldown?
     not XMLData.active_spells["Next Bounty"].nil?
   end
@@ -170,38 +154,6 @@ class Bounty
     Bounty
   end
 
-  def Bounty.throw_missing_listener
-    msg = "\n"
-    msg.concat "\nBounty.dispatch called for `:#{Bounty.type}` without a defined listener\n\n"
-    msg.concat "define a listener with:\n"
-    msg.concat " \n" 
-    msg.concat "   Bounty.on(:#{Bounty.type}) {\n" 
-    msg.concat "      # do something\n"
-    msg.concat "   }\n"
-    msg.concat " \n"
-    msg.concat "or rescue this error (Errors::Fatal) gracefully\n"
-    msg.concat " \n"
-    raise Errors::Fatal.new msg
-  end
-
-  def Bounty.dispatch(listener=nil)
-    if listener
-      if @@listeners[listener]
-        @@listeners[listener].call
-        return Bounty
-      else 
-        Bounty.throw_missing_listener
-      end
-    end
-
-    if @@listeners[Bounty.type]
-      @@listeners[Bounty.type].call
-      return Bounty
-    else
-      Bounty.throw_missing_listener
-    end
-  end
-
   def Bounty.find_guard
     Go2.advguard
     if Bounty.npc.nil? then Go2.advguard2 end

data/lib/Olib/character/group.rb

@@ -1,258 +1,99 @@
 require "ostruct"
+require "benchmark"
 require "Olib/character/disk"
 
-module Group
-  class Members
-    include Enumerable
-    attr_accessor :leader, :members, :birth
-    def initialize
-      @birth   = Time.now
-      @members = []
-    end
-
-    def clear!
-      @members = []
-      @birth   = Time.now
-      @leader  = nil
-    end
-
-    def size
-      @members.size
-    end
-
-    def empty?
-      @members.empty?
-    end
-
-    def add(pc, leader = false)      
-      member = Member.new pc, leader
-      if leader
-        @leader = member
-      end
-      @members << member
-      self
-    end
-
-    def each(&block)
-      @members.each do |char| yield char end
-      self
-    end
+class Group
+  @@members ||= []
+  @@leader  ||= nil
+  @@checked ||= false
+  @@status  ||= :closed
 
-    def include?(pc)
-      return true if pc.is_a?(String) and Char.name.eql?(pc)
-      return true if pc.respond_to?(:noun) and Char.name.eql?(pc.noun)
-      return true if pc.respond_to?(:name) and Char.name.eql?(pc.name)
-      !find do |char|
-        if pc.is_a?(String)
-          char.noun.eql?(pc)
-        else
-          char.noun.eql?(pc.noun) || char.noun.eql?(pc.name)
-        end
-      end.nil?
-    end
-
-    def nonmembers
-      ((GameObj.pcs || []) + Disk.all()).reject do |pc|
-        include?(pc)
-      end 
-    end
-
-    def to_s
-      "<Members: [#{@members.join(" ")}]>"
-    end
-  end
-
-  class Member
-    attr_reader :id, :leader, :name, :noun
-    def initialize(pc, leader = false)
-      @id     = pc.id
-      @leader = leader
-      @name   = pc.name
-      @noun   = pc.noun
-    end
-
-    def ref
-      GameObj[@id]
-    end
-
-    def leader?
-      @leader
-    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
+  def self.clear()
+    @@members = []
+    @@checked = false
   end
 
-  @@checked  = false
-
-  def Group.checked?
+  def self.checked?
     @@checked
   end
 
-  def Group.checked!
-    @@checked = true
-    self
+  def self.push(*members)
+    members.each do |member|
+      @@members.push(member) unless include?(member)
+    end
   end
 
-  def Group.empty?
-    MEMBERS.empty?
+  def self.delete(*members)
+    gone = members.map(&:id)
+    @@members.reject! do |m| gone.include?(m.id) end
   end
 
-  def Group.exists?
-    !empty?
+  def self.members
+    maybe_check
+    @@members.dup
   end
 
-  def Group.members
-    maybe_check
-    MEMBERS
+  def self._members
+    @@members
   end
 
-  def Group.disks
+  def self.disks
     return [Disk.find_by_name(Char.name)].compact unless Group.leader?
-    members.map(&:name).map do |name|  Disk.find_by_name(name) end.compact
+    members.map(&:noun).map do |noun|  Disk.find_by_name(noun) end.compact
   end
   
-  def Group.to_s
-    MEMBERS.to_s
+  def self.to_s
+    @@members.to_s
   end
 
-  # ran at the initialization of a script
-  def Group.check
-    Group.unobserve()
-    @@checked = false
-    MEMBERS.clear!
-    DownstreamHook.add(CHECK_HOOK, PARSER)
-    Game._puts "<c>group\r\n"
-    wait_until { Group.checked? }
-    Group.observe()
-    MEMBERS
+  def self.checked=(flag)
+    @@checked = flag
   end
 
-  def Group.maybe_check
-    Group.check unless checked?
+  def self.status=(state)
+    @@status = state
   end
 
-  def Group.nonmembers
-    members.nonmembers
+  def self.status()
+    @@status
   end
 
-  def Group.leader
-    members.leader
+  def self.open?
+    maybe_check
+    @@status.eql?(:open)
   end
 
-  def Group.leader?
-    leader && leader.name == Char.name
+  def self.closed?
+    not open?
   end
 
+  # ran at the initialization of a script
+  def self.check
+    Group.clear()
+    ttl = Time.now + 3
+    Game._puts "<c>group\r\n"
+    wait_until { Group.checked? or Time.now > ttl }
+    @@members.dup
+  end
 
-  module Term
-    # <a exist="-10467645" noun="Oreh">Oreh</a> leaves your group
-    # <a exist="-10467645" noun="Oreh">Oreh</a> joins your group.
-    # You add <a exist="-10467645" noun="Oreh">Oreh</a> to your group.
-    # You remove <a exist="-10467645" noun="Oreh">Oreh</a> from the group.
-    # You disband your group.
-    JOIN    = %r{^<a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> joins your group.$}
-    LEAVE   = %r{^<a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> leaves your group.$}
-    ADD     = %r{^You add <a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> to your group.$}
-    REMOVE  = %r{^You remove <a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> from the group.$}
-    NOOP    = %r{^But <a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> is already a member of your group!$}
-    EXIST   = %r{<a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a>}
-    DISBAND = %r{^You disband your group}
-    ANY     = Regexp.union(JOIN, LEAVE, ADD, REMOVE, NOOP)
+  def self.maybe_check
+    Group.check unless checked?
   end
 
-  GROUP_OBSERVER = -> line {
-    begin
-      return line if DownstreamHook.list.include?(CHECK_HOOK)
-      Group.consume(line.strip)
-    rescue => exception
-      respond exception
-      respond exception.backtrace
-    end
-    line
-  }
+  def self.nonmembers
+    GameObj.pcs.to_a.reject {|pc| ids.include?(pc.id) }
+  end
 
-  def self.observe()
-    wait_while do DownstreamHook.list.include?(CHECK_HOOK) end
-    DownstreamHook.add("__group_observer", GROUP_OBSERVER)
+  def self.leader=(char)
+    @@leader = char
   end
 
-  def self.unobserve()
-    DownstreamHook.remove("__group_observer")
+  def self.leader
+    @@leader
   end
 
-  Group.observe()
-
-  def self.consume(line)
-    return unless line.match(Group::Term::ANY)
-    person = GameObj[Term::EXIST.match(line)[:id]]
-    case line
-    when Term::JOIN
-      Group.members.add(person) unless Group.members.include?(person)
-    when Term::ADD
-      Group.members.add(person) unless Group.members.include?(person)
-    when Term::NOOP
-      Group.members.add(person) unless Group.members.include?(person)
-    when Term::LEAVE
-      Group.members.members.delete(Group.members.find do |member|
-        member.id.eql?(person.id)
-      end)
-    when Term::REMOVE
-      Group.members.members.delete(Group.members.find do |member|
-        member.id.eql?(person.id)
-      end)
-    else
-      # silence is golden
-    end
-    Group.persist()
+  def self.leader?
+    @@leader.eql?(:self)
   end
 
   def self.add(*members)
@@ -260,34 +101,201 @@ module Group
       if member.is_a?(Array)
         Group.add(*member)
       else
+        member = GameObj.pcs.find {|pc| pc.noun.eql?(member)} if member.is_a?(String)
+
+        return if member.nil?
+
         result = dothistimeout("group ##{member.id}", 3, Regexp.union(
           %r{You add #{member.noun} to your group},
           %r{#{member.noun}'s group status is closed},
           %r{But #{member.noun} is already a member of your group}))
         
         case result
-        when %r{You add}
-          Group.members.add(member)
-          [:ok, member]
-        when %r{already a member}
-          [:noop, member]
+        when %r{You add}, %r{already a member}
+          Group.push(member)
+          {ok: member}
         when %r{closed}
-          [:err, member]
+          Group.delete(member)
+          {err: member}
         else
         end
       end
     end
   end
 
-  def self.persist()
-    return
+  def self.ids
+    @@members.map(&:id)
+  end
+
+  def self.include?(*members)
+    members.all? { |m| ids.include?(m.id) }
   end
 
   def self.broken?
     if Group.leader?
-      (GameObj.pcs.map(&:noun) & Group.members.map(&:noun)).size < Group.members.size
+      (GameObj.pcs.map(&:noun) & @@members.map(&:noun)).size < @@members.size
     else
       GameObj.pcs.find do |pc| pc.noun.eql?(Group.leader.noun) end.nil?
     end
   end
-end
+
+  def self.method_missing(method, *args, &block)
+    @@members.send(method, *args, &block)
+  end
+end
+
+class Group
+  module Observer
+    module Term
+      ##
+      ## passive messages
+      ##
+      # <a exist="-10467645" noun="Oreh">Oreh</a> joins your group.
+      JOIN    = %r{^<a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> joins your group.$}
+      # <a exist="-10467645" noun="Oreh">Oreh</a> leaves your group
+      LEAVE   = %r{^<a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> leaves your group.$}
+      # You add <a exist="-10467645" noun="Oreh">Oreh</a> to your group.
+      ADD     = %r{^You add <a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> to your group.$}
+      # You remove <a exist="-10467645" noun="Oreh">Oreh</a> from the group.
+      REMOVE  = %r{^You remove <a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> from the group.$}
+      NOOP    = %r{^But <a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> is already a member of your group!$}
+      # <a exist="-10488845" noun="Etanamir">Etanamir</a> designates you as the new leader of the group.
+      HAS_LEADER = %r{<a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> designates you as the new leader of the group\.$}
+      SWAP_LEADER = %r{<a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> designates <a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> as the new leader of the group.}
+      
+      # You designate <a exist="-10778599" noun="Ondreian">Ondreian</a> as the new leader of the group.
+      GAVE_LEADER_AWAY = %r{You designate <a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> as the new leader of the group\.$} 
+      # You disband your group.
+      DISBAND = %r{^You disband your group}
+      # <a exist="-10488845" noun="Etanamir">Etanamir</a> adds you to <a exist="-10488845" noun="Etanamir">his</a> group.
+      ADDED_TO_NEW_GROUP = %r{<a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> adds you to <a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> group.}
+      # You join <a exist="-10488845" noun="Etanamir">Etanamir</a>.
+      JOINED_NEW_GROUP = %r{You join <a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a>\.$}
+      # <a exist="-10488845" noun="Etanamir">Etanamir</a> adds <a exist="-10974229" noun="Szan">Szan</a> to <a exist="-10488845" noun="Etanamir">his</a> group.
+      LEADER_ADDED_MEMBER = %r{<a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> adds <a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> to <a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> group\.$}
+      # <a exist="-10488845" noun="Etanamir">Etanamir</a> removes <a exist="-10974229" noun="Szan">Szan</a> from the group.
+      LEADER_REMOVED_MEMBER = %r{<a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> removes <a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a> from the group\.$}
+      ##
+      ## active messages
+      ##
+      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)\./
+      STATUS   = /^Your group status is currently (?<status>open|closed)\./ 
+
+      GROUP_EMPTIED    = %[<indicator id='IconJOINED' visible='n'/>]
+      GROUP_EXISTS     = %[<indicator id='IconJOINED' visible='y'/>]
+      GIVEN_LEADERSHIP = %[designates you as the new leader of the group.]
+
+      ANY = Regexp.union(
+        JOIN, 
+        LEAVE, 
+        ADD, 
+        REMOVE, 
+        DISBAND,
+        NOOP,
+        STATUS,
+        NO_GROUP,
+        MEMBER,
+        
+        HAS_LEADER,
+        SWAP_LEADER,
+
+        LEADER_ADDED_MEMBER,
+        LEADER_REMOVED_MEMBER,
+
+        ADDED_TO_NEW_GROUP,
+        JOINED_NEW_GROUP,
+        GAVE_LEADER_AWAY,
+        )
+
+      EXIST   = %r{<a exist="(?<id>[\d-]+)" noun="(?<noun>[A-Za-z]+)">(?<name>\w+?)</a>}
+    end
+
+    CALLBACK = -> line {
+      begin
+        # fast first-pass
+        if line.include?("group") or line.include?("following you") or line.include?("IconJOINED")
+          # more detailed pass
+          if match_data = Observer.wants?(line)
+            Observer.consume(line.strip, match_data)
+          end
+        end
+      rescue => exception
+        respond(exception)
+        respond(exception.backtrace)
+      ensure
+        return line  
+      end
+    }
+
+    def self.exist(xml)
+      xml.scan(Group::Observer::Term::EXIST).map { |id, noun, name| GameObj[id] }
+    end
+
+    def self.wants?(line)
+      line.strip.match(Term::ANY) or 
+      line.include?(Term::GROUP_EMPTIED)
+    end
+
+    def self.consume(line, match_data)
+      if line.include?(Term::GIVEN_LEADERSHIP)
+        return Group.leader = :self
+      end
+
+      ## Group indicator changed!
+      if line.include?(Term::GROUP_EMPTIED)
+        Group.leader = :self
+        return Group._members.clear
+      end
+
+      people = exist(line)
+
+      if line.include?("is following you")
+        Group.leader = :self
+      elsif line.include?("is the leader of your group")
+        Group.leader = people.first
+      end
+      
+      case line
+      when Term::NO_GROUP, Term::DISBAND
+        Group.leader = :self
+        return Group._members.clear
+      when Term::STATUS
+        Group.status  = match_data[:status].to_sym
+        return Group.checked = true
+      when Term::GAVE_LEADER_AWAY
+        Group.push(people.first)
+        return Group.leader = people.first
+      when Term::ADDED_TO_NEW_GROUP, Term::JOINED_NEW_GROUP
+        Group.push(people.first)
+        return Group.leader = people.first
+      when Term::SWAP_LEADER
+        (old_leader, new_leader) = people
+        Group.push(*people) if Group.include?(old_leader) or Group.include?(new_leader)
+        return Group.leader = new_leader
+      when Term::LEADER_ADDED_MEMBER
+        (leader, added) = people
+        Group.push(added) if Group.include?(leader)
+      when Term::LEADER_REMOVED_MEMBER
+        (leader, removed) = people
+        return Group.delete(removed) if Group.include?(leader)
+      when Term::JOIN, Term::ADD, Term::NOOP, Term::MEMBER
+        return Group.push(*people)
+      when Term::LEAVE, Term::REMOVE
+        return Group.delete(*people)
+      end
+    end
+
+  
+    def self.attach()
+      remove() if DownstreamHook.list.include?(self.name)
+      DownstreamHook.add(self.name, CALLBACK)
+    end
+
+    def self.remove()
+      DownstreamHook.remove(self.name)
+    end
+  end
+
+  Observer.attach()
+end