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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3847ae46163103e49356d4e6fcc43badaa3b4ddd29a9ea3ad48c509203b5eb7
-  data.tar.gz: 6ff8a42a9ca26c9cf394bd311ff7095052b7a507005b34aa42d73d63f9701a79
+  metadata.gz: f7d8e8dfe837282ceb421c8919c9b14385299f9f718493dc74efef8c9863cb4a
+  data.tar.gz: dffc7436f4fc2da600ed00104ca8ca53e9880226d846c12c67987fe36ca9845d
 SHA512:
-  metadata.gz: eb34b92ed44adeab5c1b15e7ae65f73124d7557af2c613bef5113c7efe76607e362807553076d52f51f05b95787b93adbf65cb3893343962af82485f008098d0
-  data.tar.gz: c89d3853c1d5569f7ed375269a047cf7eee943dde1f5ad8b11eb9c2ffb0e1abd29bdf9df8893491afb1cd4f0b29fb1c3df440d3559fc133f8db4119d390a8856
+  metadata.gz: bde4171be06ed24d979ffbc9a49b68a7159af161006607194485502d4e9f8a43d6c9b10b8417b2e915f8e30475670a4c87965ac0d63609302f804ea4c6e15990
+  data.tar.gz: 97ebab201d826e5e483777535ee91d93a9d80110eea2f329c142d3893a0985409957e95f2d4f74e28bedd1832cdf17636c160e14dd580003013a940fa2c4de83

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

@@ -6,7 +6,7 @@ class Bounty
   @@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/,
@@ -17,16 +17,15 @@ 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]+)/,
 
@@ -35,7 +34,9 @@ class Bounty
     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) (?<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

data/lib/Olib/character/group.rb

@@ -1,257 +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
-
-    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
+class Group
+  @@members ||= []
+  @@leader  ||= nil
+  @@checked ||= false
+  @@status  ||= :closed
 
-    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.
-    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>}
-    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)
@@ -259,30 +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?
-    (GameObj.pcs.to_a.map(&:noun) & Group.members.map(&:noun)).size.eql?(Group.members.size)
-  end   
-end
+    if Group.leader?
+      (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
+
+  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