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

Defined in:: documented/gemstone/infomon/parser.rb

Defined Under Namespace

Modules: Pattern, State

Class Method Summary collapse

.find_cat(category) ⇒ String^?
Determines the category of a given string based on its content.
.parse(line) ⇒ Symbol
Parses a line of game output and updates the internal state accordingly.

Class Method Details

.find_cat(category) ⇒ `String`^?

Determines the category of a given string based on its content.

Examples:

find_cat("Armor") # => "Armor"
find_cat("Combat") # => "CMan"

Parameters:

category (String) —
the category string to analyze

Returns:

(String, nil) —
the determined category or nil if not matched

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

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) ⇒ `Symbol`

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

This method uses regex patterns to identify and extract relevant data from the input line, updating the Infomon database with the parsed information.

Parameters:

line (String) —
the line of game output to parse

Returns:

(Symbol) —
status of the parsing operation, e.g., :ok, :noop

Raises:

(StandardError) —
if an error occurs during parsing

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

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])
      # Store base stats if present (from 'info full' command)
      if match[:base_value]
        @stat_hold.push(['stat.%s.base' % match[:stat], match[:base_value].to_i],
                        ['stat.%s.base_bonus' % match[:stat], match[:base_bonus].to_i])
      end
      :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::InnCheckedOut
      respond
      _respond Lich::Messaging.monsterbold('You just left an Inn.  Lich will gather your updated Stats and skills.')
      respond
      respond "[infomon_sync]#{$SEND_CHARACTER}skills"
      Game._puts("#{$cmd_prefix}skills")
      respond "[infomon_sync]#{$SEND_CHARACTER}info"
      Game._puts("#{$cmd_prefix}info")
      :ok
    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 Lich::Common::Account.name.nil?
        match = Regexp.last_match
        Lich::Common::Account.name = match[:name].upcase
        :ok
      else
        :noop
      end
    when Pattern::AccountSubscription
      match = Regexp.last_match
      Lich::Common::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
    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 ===
    # Any section header can start enhancive parsing (output may not include all sections)
    when Pattern::EnhanciveStart
      unless State.enhancive_state?
        @enhancive_hold = []
        Infomon.mutex_lock
        Lich::Gemstone::Enhancive.reset_all
      end
      State.set(State::EnhanciveStats)
      :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]) if stat_key
        :ok
      else
        :noop
      end
    when Pattern::EnhanciveSkillsSection
      unless State.enhancive_state?
        @enhancive_hold = []
        Infomon.mutex_lock
        Lich::Gemstone::Enhancive.reset_all
      end
      State.set(State::EnhanciveSkills)
      :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
      unless State.enhancive_state?
        @enhancive_hold = []
        Infomon.mutex_lock
        Lich::Gemstone::Enhancive.reset_all
      end
      State.set(State::EnhanciveResources)
      :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::EnhanciveMartialSection
      unless State.enhancive_state?
        @enhancive_hold = []
        Infomon.mutex_lock
        Lich::Gemstone::Enhancive.reset_all
      end
      State.set(State::EnhanciveMartial)
      :ok
    when Pattern::EnhanciveMartialSkill
      if State.get == State::EnhanciveMartial
        match = Regexp.last_match
        martial_key = Lich::Gemstone::Enhancive.martial_display_to_symbol(match[:name].strip)
        @enhancive_hold.push(["enhancive.martial.#{martial_key}", match[:value].to_i]) if martial_key
        :ok
      else
        :noop
      end
    when Pattern::EnhanciveSpellsSection
      unless State.enhancive_state?
        @enhancive_hold = []
        Infomon.mutex_lock
        Lich::Gemstone::Enhancive.reset_all
      end
      State.set(State::EnhanciveSpells)
      :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
      unless State.enhancive_state?
        @enhancive_hold = []
        Infomon.mutex_lock
        Lich::Gemstone::Enhancive.reset_all
      end
      State.set(State::EnhanciveStatistics)
      :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