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

Defined in:

documented/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) ⇒ Object
• .parse(line) ⇒ Object

Class Method Details

.find_cat(category) ⇒ Object

# File 'documented/gemstone/infomon/parser.rb', line 172

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

# File 'documented/gemstone/infomon/parser.rb', line 189

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::ShadowEssence
      match = Regexp.last_match
      Infomon.set('resources.shadow_essence', match[:essence].to_i.clamp(0, 5))
      :ok
    when Pattern::ShadowEssenceGain
      Infomon.set('resources.shadow_essence', (Lich::Resources.shadow_essence.to_i + 1).clamp(0, 5))
      :ok
    when Pattern::ShadowEssenceCap
      Infomon.set('resources.shadow_essence', 5)
      :ok
    when Pattern::SacrificeMana
      match = Regexp.last_match
      # Calculate effective mana control ranks
      effective_mana_ranks = [Skills.elemental_mana_control, Skills.spirit_mana_control].max + [Skills.elemental_mana_control, Skills.spirit_mana_control].min / 2

      # Base mana for first essence
      base_mana = Char.level + 20

      # Mana per essence after
      mana_per_essence = (base_mana * (0.5 + effective_mana_ranks.clamp(0, 60) / 120))

      # Estimate of essences used
      essences_used = (((match[:amount].to_i - mana_per_essence) / (base_mana * 0.5))).round.clamp(1, 5)
      Infomon.set('resources.shadow_essence', (Lich::Resources.shadow_essence.to_i - essences_used).clamp(0, 5))
      :ok
    when Pattern::SacrificeChannel, Pattern::SacrificeInfest, Pattern::SacrificeFate, Pattern::SacrificeShift
      Infomon.set('resources.shadow_essence', (Lich::Resources.shadow_essence.to_i - 1).clamp(0, 5))
      :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::TicketGold
      match = Regexp.last_match
      Infomon.set('currency.gold', match[:gold].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').gsub('Platinum', 'Premium').upcase
        Infomon.set('account.type', 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(' ').include?(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
    when Pattern::ResignConfirmCHE
      Infomon.set('che', 'none')
      :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
    # === ENHANCIVE PARSING ===
    when Pattern::EnhanciveStart
      @enhancive_hold = []
      State.set(State::EnhanciveStats)
      Infomon.mutex_lock
      # Reset all values to 0 first since output only shows non-zero
      Lich::Gemstone::Enhancive.reset_all
      :ok
    when Pattern::EnhanciveStat
      if State.get == State::EnhanciveStats
        match = Regexp.last_match
        stat_key = Lich::Gemstone::Enhancive::STAT_ABBREV[match[:abbr]]
        @enhancive_hold.push(["enhancive.stat.#{stat_key}", match[:value].to_i])
        :ok
      else
        :noop
      end
    when Pattern::EnhanciveSkillsSection
      State.set(State::EnhanciveSkills) if State.get == State::EnhanciveStats
      :ok
    when Pattern::EnhanciveSkillRanks
      if State.get == State::EnhanciveSkills
        match = Regexp.last_match
        skill_key = Lich::Gemstone::Enhancive::SKILL_NAME_MAP[match[:name].strip]
        @enhancive_hold.push(["enhancive.skill.#{skill_key}.ranks", match[:value].to_i]) if skill_key
        :ok
      else
        :noop
      end
    when Pattern::EnhanciveSkillBonus
      if State.get == State::EnhanciveSkills
        match = Regexp.last_match
        skill_key = Lich::Gemstone::Enhancive::SKILL_NAME_MAP[match[:name].strip]
        @enhancive_hold.push(["enhancive.skill.#{skill_key}.bonus", match[:value].to_i]) if skill_key
        :ok
      else
        :noop
      end
    when Pattern::EnhanciveResourcesSection
      State.set(State::EnhanciveResources) if State.get == State::EnhanciveSkills
      :ok
    when Pattern::EnhanciveResource
      if State.get == State::EnhanciveResources
        match = Regexp.last_match
        resource_key = Lich::Gemstone::Enhancive::RESOURCE_NAME_MAP[match[:name].strip]
        @enhancive_hold.push(["enhancive.resource.#{resource_key}", match[:value].to_i]) if resource_key
        :ok
      else
        :noop
      end
    when Pattern::EnhanciveSpellsSection
      State.set(State::EnhanciveSpells) if State.get == State::EnhanciveResources
      :ok
    when Pattern::EnhanciveSpells
      if State.get == State::EnhanciveSpells
        match = Regexp.last_match
        spell_nums = match[:spells].split(',').map { |s| s.strip.to_i }
        @enhancive_hold.push(["enhancive.spells", spell_nums.join(',')])
        :ok
      else
        :noop
      end
    when Pattern::EnhanciveStatisticsSection
      State.set(State::EnhanciveStatistics) if State.get == State::EnhanciveSpells
      :ok
    when Pattern::EnhanciveStatistic
      if State.get == State::EnhanciveStatistics
        match = Regexp.last_match
        case match[:name]
        when 'Enhancive Items'
          @enhancive_hold.push(['enhancive.stats.item_count', match[:value].to_i])
        when 'Enhancive Properties'
          @enhancive_hold.push(['enhancive.stats.property_count', match[:value].to_i])
        when 'Total Enhancive Amount'
          @enhancive_hold.push(['enhancive.stats.total_amount', match[:value].to_i])
        end
        :ok
      else
        :noop
      end
    when Pattern::EnhanciveEnd
      if State.enhancive_state?
        Infomon.upsert_batch(@enhancive_hold)
        Infomon.mutex_unlock
        State.set(State::Ready)
        :ok
      else
        :noop
      end
    when Pattern::EnhanciveNone
      # Player has no enhancives - reset all values to 0
      Lich::Gemstone::Enhancive.reset_all
      :ok
    when Pattern::EnhanciveOn
      Infomon.set('enhancive.active', true)
      :ok
    when Pattern::EnhanciveOff
      Infomon.set('enhancive.active', false)
      :ok
    when Pattern::EnhancivePauses
      match = Regexp.last_match
      Infomon.set('enhancive.pauses', match[:pauses].to_i)
      :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