Module: Lich::Gemstone::Infomon::Parser

Defined in:

lib/gemstone/infomon/parser.rb

Overview

this module handles all of the logic for parsing game lines that infomon depends on

Defined Under Namespace

Modules: Pattern, State

Class Method Summary

• .find_cat(category) ⇒ String^?

  Finds the category based on the provided string.

• .parse(line) ⇒ Object

  Parses a line of game output and updates the internal state accordingly.

Class Method Details

.find_cat(category) ⇒ String^?

Finds the category based on the provided string.

Parameters:

• category (String) —

  The category string to match against.

Returns:

• (String, nil) —

  The matched category or nil if no match is found.

# File 'lib/gemstone/infomon/parser.rb', line 136

def self.find_cat(category)
  case category
  when /Armor/
    'Armor'
  when /Ascension/
    'Ascension'
  when /Combat/
    'CMan'
  when /Feat/
    'Feat'
  when /Shield/
    'Shield'
  when /Weapon/
    'Weapon'
  end
end

.parse(line) ⇒ Object

Parses a line of game output and updates the internal state accordingly.

Parameters:

• line (String) —

  The line of game output to parse.

# File 'lib/gemstone/infomon/parser.rb', line 155

def self.parse(line)
  # O(1) vs O(N)
  return :noop unless line =~ Pattern::All

  begin
    case line
    # blob saves
    when Pattern::CharRaceProf
      # name captured here, but do not rely on it - use XML instead
      @stat_hold = []
      Infomon.mutex_lock
      match = Regexp.last_match
      @stat_hold.push(['stat.race', match[:race].to_s],
                      ['stat.profession', match[:profession].to_s]) unless Effects::Spells.active?(1212)
      :ok
    when Pattern::CharGenderAgeExpLevel
      # level captured here, but do not rely on it - use XML instead
      match = Regexp.last_match
      @stat_hold.push(['stat.gender', match[:gender].to_s],
                      ['stat.age', match[:age].delete(',').to_i]) unless Effects::Spells.active?(1212)
      @stat_hold.push(['stat.experience', match[:experience].delete(',').to_i])
      :ok
    when Pattern::Stat
      match = Regexp.last_match
      @stat_hold.push(['stat.%s' % match[:stat], match[:value].to_i],
                      ['stat.%s_bonus' % match[:stat], match[:bonus].to_i],
                      ['stat.%s.enhanced' % match[:stat], match[:enhanced_value].to_i],
                      ['stat.%s.enhanced_bonus' % match[:stat], match[:enhanced_bonus].to_i])
      :ok
    when Pattern::StatEnd
      match = Regexp.last_match
      @stat_hold.push(['currency.silver', match[:silver].delete(',').to_i])
      Infomon.upsert_batch(@stat_hold)
      Infomon.mutex_unlock
      :ok
    when Pattern::Fame # serves as ExprStart
      @expr_hold = []
      Infomon.mutex_lock
      match = Regexp.last_match
      @expr_hold.push(['experience.fame', match[:fame].delete(',').to_i])
      :ok
    when Pattern::RealExp
      match = Regexp.last_match
      @expr_hold.push(['experience.field_experience_current', match[:fxp_current].delete(',').to_i],
                      ['experience.field_experience_max', match[:fxp_max].delete(',').to_i])
      :ok
    when Pattern::AscExp
      match = Regexp.last_match
      @expr_hold.push(['experience.ascension_experience', match[:ascension_experience].delete(',').to_i])
      :ok
    when Pattern::TotalExp
      match = Regexp.last_match
      @expr_hold.push(['experience.total_experience', match[:total_experience].delete(',').to_i],
                      ['experience.deaths_sting', match[:deaths_sting]])
      :ok
    when Pattern::LTE
      match = Regexp.last_match
      @expr_hold.push(['experience.long_term_experience', match[:long_term_experience].delete(',').to_i],
                      ['experience.deeds', match[:deeds].to_i])
      :ok
    when Pattern::ExprEnd
      Infomon.upsert_batch(@expr_hold)
      Infomon.mutex_unlock
      :ok
    when Pattern::SkillStart
      @skills_hold = []
      Infomon.mutex_lock
      :ok
    when Pattern::Skill
      if Infomon.mutex.owned?
        match = Regexp.last_match
        @skills_hold.push(['skill.%s' % match[:name].downcase, match[:ranks].to_i],
                          ['skill.%s_bonus' % match[:name], match[:bonus].to_i])
        :ok
      else
        :noop
      end
    when Pattern::SpellRanks
      if Infomon.mutex.owned?
        match = Regexp.last_match
        @skills_hold.push(['spell.%s' % match[:name].downcase, match[:rank].to_i])
        :ok
      else
        :noop
      end
    when Pattern::SkillEnd
      if Infomon.mutex.owned?
        Infomon.upsert_batch(@skills_hold)
        Infomon.mutex_unlock
        :ok
      else
        :noop
      end
    when Pattern::GoalsDetected
      State.set(State::Goals)
      :ok
    when Pattern::GoalsEnded
      if State.get.eql?(State::Goals)
        State.set(State::Ready)
        respond
        _respond Lich::Messaging.monsterbold('You just trained your character.  Lich will gather your updated skills.')
        respond
        # temporary inform for users about command
        # fixme: update ExecCommand to consistently perform local API actions from lib files
        respond "[infomon_sync]#{$SEND_CHARACTER}skills"
        Game._puts("#{$cmd_prefix}skills")
        :ok
      else
        :noop
      end
    when Pattern::PSMStart
      match = Regexp.last_match
      @psm_hold = []
      @psm_cat = find_cat(match[:cat])
      Infomon.mutex_lock
      :ok
    when Pattern::PSM
      match = Regexp.last_match
      @psm_hold.push(["#{@psm_cat.downcase}.%s" % match[:command], match[:ranks].to_i])
      :ok
    when Pattern::PSMEnd
      Infomon.upsert_batch(@psm_hold)
      Infomon.mutex_unlock
      :ok
    when Pattern::NoWarcries
      Infomon.upsert_batch([['warcry.bertrandts_bellow', 0],
                            ['warcry.yerties_yowlp', 0],
                            ['warcry.gerrelles_growl', 0],
                            ['warcry.seanettes_shout', 0],
                            ['warcry.carns_cry', 0],
                            ['warcry.horlands_holler', 0]])
      :ok
    # end of blob saves
    when Pattern::Warcries
      match = Regexp.last_match
      Infomon.set('warcry.%s' % match[:name].split(' ')[1], 1)
      :ok
    when Pattern::Levelup
      match = Regexp.last_match
      Infomon.upsert_batch([['stat.%s' % match[:stat], match[:value].to_i],
                            ['stat.%s_bonus' % match[:stat], match[:bonus].to_i]])
      :ok
    when Pattern::SpellsSolo
      match = Regexp.last_match
      Infomon.set('spell.%s' % match[:name].downcase, match[:rank].to_i)
      :ok
    when Pattern::Citizenship
      Infomon.set('citizenship', Regexp.last_match[:town].to_s)
      :ok
    when Pattern::NoCitizenship
      Infomon.set('citizenship', 'None')
      :ok
    when Pattern::Society
      match = Regexp.last_match
      Infomon.set('society.status', match[:society].to_s)
      Infomon.set('society.rank', match[:rank].to_i)
      case match[:standing] # if Master in society the rank match is nil
      when 'Master'
        if /Voln/.match?(match[:society])
          Infomon.set('society.rank', 26)
        elsif /Council of Light|Guardians of Sunfist/.match?(match[:society])
          Infomon.set('society.rank', 20)
        end
      end
      :ok
    when Pattern::NoSociety
      Infomon.set('society.status', 'None')
      Infomon.set('society.rank', 0)
      :ok
    when Pattern::SocietyJoin
      match = Regexp.last_match.to_s
      case match[/Order|Council|Guardians/]
      when 'Order'
        Infomon.set('society.status', 'Order of Voln')
        Infomon.set('society.rank', 1)
      when 'Guardians'
        Infomon.set('society.status', "Guardians of Sunfist")
        Infomon.set('society.rank', 0)
      when 'Lodge'
        Infomon.set('society.status', 'Council of Light')
        Infomon.set('society.rank', 1)
      end
      :ok
    when Pattern::SocietyStep
      Infomon.set('society.rank', Infomon.get('society.rank') + 1)
      :ok
    when Pattern::SocietyResign
      Infomon.set('society.status', 'None')
      Infomon.set('society.rank', 0)
      :ok
    when Pattern::LearnPSM, Pattern::LearnTechnique
      match = Regexp.last_match
      @psm_cat = find_cat(match[:cat])
      seek_name = PSMS.name_normal(match[:psm])
      db_name = PSMS.find_name(seek_name, @psm_cat)
      Infomon.set("#{@psm_cat.downcase}.#{db_name[:short_name]}", match[:rank].to_i)
      :ok
    when Pattern::UnlearnPSM, Pattern::UnlearnTechnique
      match = Regexp.last_match
      @psm_cat = find_cat(match[:cat])
      seek_name = PSMS.name_normal(match[:psm])
      no_decrement = (match.string =~ /have decreased to/)
      db_name = PSMS.find_name(seek_name, @psm_cat)
      Infomon.set("#{@psm_cat.downcase}.#{db_name[:short_name]}", (no_decrement ? match[:rank].to_i : match[:rank].to_i - 1))
      :ok
    when Pattern::LostTechnique
      match = Regexp.last_match
      @psm_cat = find_cat(match[:cat])
      seek_name = PSMS.name_normal(match[:psm])
      db_name = PSMS.find_name(seek_name, @psm_cat)
      Infomon.set("#{@psm_cat.downcase}.#{db_name[:short_name]}", 0)
      :ok
    when Pattern::Resource
      match = Regexp.last_match
      Infomon.set('resources.weekly', match[:weekly].delete(',').to_i)
      Infomon.set('resources.total', match[:total].delete(',').to_i)
      :ok
    when Pattern::Suffused
      match = Regexp.last_match
      Infomon.set('resources.type', match[:type].to_s)
      Infomon.set('resources.suffused', match[:suffused].delete(',').to_i)
      :ok
    when Pattern::VolnFavor
      match = Regexp.last_match
      Infomon.set('resources.voln_favor', match[:favor].delete(',').to_i)
      :ok
    when Pattern::CovertArtsCharges
      match = Regexp.last_match
      Infomon.set('resources.covert_arts_charges', match[:charges].delete(',').to_i)
      :ok
    when Pattern::GigasArtifactFragments
      match = Regexp.last_match
      Infomon.set('currency.gigas_artifact_fragments', match[:gigas_artifact_fragments].delete(',').to_i)
      :ok
    when Pattern::RedsteelMarks
      match = Regexp.last_match
      Infomon.set('currency.redsteel_marks', match[:redsteel_marks].delete(',').to_i)
      :ok
    when Pattern::GemstoneDust
      match = Regexp.last_match
      Infomon.set('currency.gemstone_dust', match[:gemstone_dust].delete(',').to_i)
      :ok
    when Pattern::TicketGeneral
      match = Regexp.last_match
      Infomon.set('currency.tickets', match[:tickets].delete(',').to_i)
      :ok
    when Pattern::TicketBlackscrip
      match = Regexp.last_match
      Infomon.set('currency.blackscrip', match[:blackscrip].delete(',').to_i)
      :ok
    when Pattern::TicketBloodscrip
      match = Regexp.last_match
      Infomon.set('currency.bloodscrip', match[:bloodscrip].delete(',').to_i)
      :ok
    when Pattern::TicketEtherealScrip
      match = Regexp.last_match
      Infomon.set('currency.ethereal_scrip', match[:ethereal_scrip].delete(',').to_i)
      :ok
    when Pattern::TicketSoulShards
      match = Regexp.last_match
      Infomon.set('currency.soul_shards', match[:soul_shards].delete(',').to_i)
      :ok
    when Pattern::TicketRaikhen
      match = Regexp.last_match
      Infomon.set('currency.raikhen', match[:raikhen].delete(',').to_i)
      :ok
    when Pattern::WealthSilver
      match = Regexp.last_match
      case match[:silver]
      when 'no'
        Infomon.set('currency.silver', 0)
      when 'but one'
        Infomon.set('currency.silver', 1)
      else
        Infomon.set('currency.silver', match[:silver].delete(',').to_i)
      end
      :ok
    when Pattern::WealthSilverContainer
      match = Regexp.last_match
      Infomon.set('currency.silver_container', match[:silver].delete(',').to_i)
      :ok
    when Pattern::AccountName
      if Account.name.nil?
        match = Regexp.last_match
        Account.name = match[:name].upcase
        :ok
      else
        :noop
      end
    when Pattern::AccountSubscription
      if Account.subscription
        match = Regexp.last_match
        Account.subscription = match[:subscription].gsub('Standard', 'Normal').gsub('F2P', 'Free').upcase
        :ok
      else
        :noop
      end
    when Pattern::ProfileStart
      State.set(State::Profile)
      :ok
    when Pattern::ProfileName
      match = Regexp.last_match
      if State.get.eql?(State::Profile) && match[:name].split(' ').last != Char.name
        State.set(State::Ready)
        :ok
      else
        :noop
      end
    when Pattern::ProfileHouseCHE
      if State.get.eql?(State::Profile)
        match = Regexp.last_match
        Infomon.set('che', (match[:none] ? 'none' : Lich::Util.normalize_name(match[:house])))
        State.set(State::Ready)
        :ok
      else
        :noop
      end
    when Pattern::ResignCHE
      match = Regexp.last_match
      Infomon.set('che', (match[:none] ? 'none' : Lich::Util.normalize_name(match[:house])))
      :ok

    # TODO: refactor / streamline?
    when Pattern::ThornPoisonStart, Pattern::ThornPoisonProgression, Pattern::ThornPoisonDeprogression
      Infomon.set('status.thorned', true)
      :ok
    when Pattern::ThornPoisonEnd
      Infomon.set('status.thorned', false)
      :ok
    when Pattern::SleepActive
      Infomon.set('status.sleeping', true)
      :ok
    when Pattern::SleepNoActive
      Infomon.set('status.sleeping', false)
      :ok
    when Pattern::BindActive
      Infomon.set('status.bound', true)
      :ok
    when Pattern::BindNoActive
      Infomon.set('status.bound', false)
      :ok
    when Pattern::SilenceActive
      Infomon.set('status.silenced', true)
      :ok
    when Pattern::SilenceNoActive
      Infomon.set('status.silenced', false)
      :ok
    when Pattern::CalmActive
      Infomon.set('status.calmed', true)
      :ok
    when Pattern::CalmNoActive
      Infomon.set('status.calmed', false)
      :ok
    when Pattern::CutthroatActive
      Infomon.set('status.cutthroat', true)
      :ok
    when Pattern::CutthroatNoActive
      Infomon.set('status.cutthroat', false)
      :ok
    when Pattern::SpellUpMsgs
      spell = Spell.list.find do |s|
        line =~ /^#{s.msgup}$/
      end
      spell.putup unless spell.active?
      # add various cooldowns back without affecting parse speed
      Spells.require_cooldown(spell)
      :ok
    when Pattern::SpellDnMsgs
      spell = Spell.list.find do |s|
        line =~ /^#{s.msgdn}$/
      end
      spell.putdown if spell.active?
      :ok
    when Pattern::SpellsongRenewed
      Spellsong.renewed
      :ok
    else
      :noop
    end
  rescue StandardError
    respond "--- Lich: error: Infomon::Parser.parse: #{$!}"
    respond "--- Lich: error: line: #{line}"
    Lich.log "error: Infomon::Parser.parse: #{$!}\n\t#{$!.backtrace.join("\n\t")}"
    Lich.log "error: line: #{line}\n\t"
  end
end