bdoap 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a2c463012b75ab5e6a2ad6d2558aaf0d13d4ca815b0092d7384efa44903c124d
+  data.tar.gz: ffd6889945d22837ba488133f5d364d086352dd945adf95cb4adb6512036963e
+SHA512:
+  metadata.gz: cf5c5d4011b0febc18953536d8bd94d90fa1df257386685dbce8e6d1dbc745e8ed4afbab2f079be71e1f2d13767802cf8d054ffeb90f2c2342f2dc9093e39c29
+  data.tar.gz: 2c6626ef2c4222dc002db072403d55bec2c06c7b87a860795b739d1b312419283ab6fdc3b6ace8a31f1da9374131a6045d3fd8ce3b2dbd581c40add167cf1ba5

data/bin/bdoap

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/bdo_alchemy_profits'
+
+profit_calculator = BDOAlchemyProfits.new
+
+profit_calculator.start_cli

data/lib/bdo_alchemy_profits.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# MIT License
+#
+# Copyright (c) 2025 jpegzilla
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+require 'optparse'
+
+require_relative './utils/user_cli'
+require_relative './central_market/market_searcher'
+require_relative './bdo_codex/bdo_codex_searcher'
+
+class BDOAlchemyProfits
+  include Utils
+
+  def start_cli
+    options = {}
+
+    OptionParser.new do |opt|
+      opt.on('--silent', '-s') { options[:silent] = true }
+    end.parse!
+
+    cli = UserCLI.new options
+
+    # option setup
+
+    category = cli.choose_category
+
+    cli.end_cli if category == 'exit'
+
+    region = cli.choose_region
+
+    cli.end_cli if region == 'exit'
+
+    lang = cli.choose_lang
+
+    cli.end_cli if lang == 'exit'
+
+    aggression = cli.choose_aggression
+
+    cli.end_cli if aggression == 'exit'
+
+    if aggression == 'hyperaggressive'
+      puts cli.orange("\nWARN: hyperagressive mode is RISKY AND SLOW. this will evaluate every substitution for every recipe. hammers apis violently. you will get rate limited. you will get IP blocked. her royal holiness imperva incapsula WILL get you. select if you know what all that stuff means and you are ok with waiting 20 minutes.")
+    end
+
+    # start searching
+
+    cli.vipiko("\n♫ let's see if #{cli.yellow category} alchemy items are profitable in #{cli.yellow region}!")
+
+    market_searcher = MarketSearcher.new region, cli
+
+    market_item_list = market_searcher.get_alchemy_market_data category
+
+    cli.vipiko("I'll look for #{cli.yellow(market_item_list.length)} item#{
+      market_item_list.empty? || market_item_list.length > 1 ? 's' : ''
+    } in #{category == 'all' ? cli.yellow('all categories'): "the #{cli.yellow category} category"}!")
+
+    bdo_codex_searcher = BDOCodexSearcher.new(region, lang, cli, aggression == 'hyperaggressive')
+
+    item_codex_data = bdo_codex_searcher.get_item_codex_data market_item_list
+
+    recipe_prices = market_searcher.get_all_recipe_prices item_codex_data, category
+
+    mapped_prices = recipe_prices.sort_by { |recipe| recipe[:silver_per_hour].to_i }.map { |recipe| recipe[:information] }
+
+    if mapped_prices.length > 0
+      cli.vipiko_overwrite "done!"
+      puts "\n\n"
+      puts mapped_prices
+    else
+      cli.vipiko_overwrite "none of those recipes look profitable right now...let's go gathering!"
+    end
+  end
+end

data/lib/bdo_codex/bdo_codex_searcher.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'httparty'
+require 'nokogiri'
+require 'awesome_print'
+
+require_relative '../utils/user_cli'
+require_relative '../utils/array_utils'
+require_relative '../utils/hash_cache'
+
+# some variables that are necessary for parsing bdocodex data
+class BDO_CODEX_UTILS
+  BDOCODEX_QUERY_DATA_KEY = 'aaData'
+  RECIPE_COLUMNS = [
+    'id',
+    'icon',
+    'title',
+    'type',
+    'skill level',
+    'exp',
+    'materials',
+    'total weight of materials',
+    'products',
+    'all ingredients',
+  ]
+end
+
+# used to retrieve items from BDOCodex
+class BDOCodexSearcher
+  include Utils
+
+  RECIPE_INGREDIENTS_INDEX = 2
+
+  def initialize(region, lang, cli, hyper_aggressive = false)
+    @region = region
+    @root_url = ENVData.get_root_url region
+    @cli = cli
+    @region_lang = lang
+    @cache = HashCache.new ENVData::BDO_CODEX_CACHE
+    @hyper_aggressive = hyper_aggressive
+  end
+
+  def get_recipe_url(url)
+    begin
+      data = HTTParty.get(
+        URI(url),
+        headers: ENVData::REQUEST_OPTS[:bdo_codex_headers],
+        content_type: 'application/x-www-form-urlencoded'
+      )
+
+      JSON.parse data unless data.body.nil? or data.body.empty?
+    rescue
+      {}
+    end
+  end
+
+  # TODO: is there a way to get rid of all these nested loops in this class?
+  def get_recipe_substitutions(recipe_with_substitute_ids, all_potion_recipes, name)
+    all_recipe_substitutions = []
+    all_potion_recipes.each do |recipe|
+      original_recipe = recipe[RECIPE_INGREDIENTS_INDEX]
+      original_ingredient_indices = original_recipe.map do |item|
+        recipe_with_substitute_ids.find_index { |id| id == item[:id] }
+      end
+
+      chunked_by_substitution_groups = []
+
+      original_ingredient_indices.each.with_index do |_arr_index, idx|
+        slice_from = [0, original_ingredient_indices[idx].to_i].max
+        slice_to = slice_from + 1
+        slice_to = original_ingredient_indices[idx + 1] if @hyper_aggressive
+        # set hyper_aggressive to true if you want to check every
+        # permutation of this recipe, with all substitutions considered
+        # this will be exceedingly slow and generate hundreds and hundreds
+        # of post requests, hammering the black desert market api and
+        # potentially causing incapsula to GET YOU (block your IP)
+
+        chunked_by_substitution_groups.push(
+          recipe_with_substitute_ids[slice_from..(slice_to ? slice_to - 1 : -1)]
+        )
+      end
+
+      original_recipe_length = original_recipe.length
+      permutated_chunks = ArrayUtils.deep_permute chunked_by_substitution_groups, original_recipe_length
+
+      permutated_chunks.each do |id_list|
+        recipe_with_new_items = [*recipe]
+        recipe_with_new_items[RECIPE_INGREDIENTS_INDEX] = [*recipe][RECIPE_INGREDIENTS_INDEX].map.with_index do |recipe_list, idx|
+          { **recipe_list, id: id_list[idx] }
+        end
+
+        all_recipe_substitutions.push recipe_with_new_items
+      end
+    end
+
+    # 1 in elem[1] is the index of the recipe name
+    all_recipe_substitutions.filter { |elem| elem[1].downcase == name.downcase }
+  end
+
+  def parse_raw_recipe(recipe_data, item_name)
+    item_with_ingredients = recipe_data.dig(BDO_CODEX_UTILS::BDOCODEX_QUERY_DATA_KEY)
+
+    if item_with_ingredients
+      recipe_with_substitute_ids = item_with_ingredients.map do |arr|
+        arr.filter.with_index { |_, idx| idx == 9 }
+         .map { |item| JSON.parse(item) }
+         .first
+      end.first
+
+      all_potion_recipes = item_with_ingredients.map do |arr|
+        mapped_item_data = arr
+          .filter.with_index { |_, idx | !BDO_CODEX_UTILS::RECIPE_COLUMNS[idx].nil? }
+          .map.with_index do |raw_element, idx|
+            category = BDO_CODEX_UTILS::RECIPE_COLUMNS[idx]
+
+            next if ['skill level', 'exp', 'type', 'icon', 'total weight of materials'].include? category
+
+            element = Nokogiri::HTML5 raw_element.to_s
+
+            result = {
+              :category => category,
+              :element => element
+            }
+
+            result[:element] = element.text.downcase if category == 'title'
+
+            result[:element] = element.text.downcase if category == 'id'
+
+            if %w[materials products].include? category
+              quants = element.text.scan(/\](\d+)/im).map { |e| e[0].to_i }
+
+              ids = element.to_s.scan(/#{@region_lang}\/item\/(\d+)/).map { |e| e[0].to_i }
+              result[:element] = ids.map.with_index { |id, i| { id: id, quant: quants[i]} }.flatten
+            end
+
+            result
+        end
+
+        filtered_item_data = mapped_item_data
+                               .compact
+                               .filter { |e| %w[id title materials products].include? e[:category] }
+                               .map { |e| e[:element] }
+
+        filtered_item_data
+      end
+
+      get_recipe_substitutions recipe_with_substitute_ids, all_potion_recipes, item_name
+    end
+  end
+
+  def get_item_recipes(item_id, item_name)
+    recipe_direct_url = "https://bdocodex.com/query.php?a=recipes&type=product&item_id=#{item_id}&l=#{@region_lang}"
+    mrecipe_direct_url = "https://bdocodex.com/query.php?a=mrecipes&type=product&item_id=#{item_id}&l=#{@region_lang}"
+    # houserecipe_direct_url = "https://bdocodex.com/query.php?a=designs&type=product&item_id=#{item_id}&l=#{@region_lang}"
+
+    # TODO: there MUST be a better way to determine which recipe to use, rather than just trying them both.
+    begin
+      direct_data = get_recipe_url recipe_direct_url
+
+      if !direct_data || direct_data.empty?
+        mrecipe_data = get_recipe_url mrecipe_direct_url
+
+        return parse_raw_recipe mrecipe_data, item_name
+      else
+        parsed = parse_raw_recipe direct_data, item_name
+
+        if !parsed || parsed.empty?
+          mrecipe_data = get_recipe_url mrecipe_direct_url
+
+          return parse_raw_recipe mrecipe_data, item_name
+        end
+
+        parsed
+      end
+    rescue StandardError => error
+      puts @cli.red("if you're not messing with the code, you should never see this. get_item_recipes broke.")
+
+      File.open(ENVData::ERROR_LOG, 'a+') do |file|
+        file.write(error.full_message)
+        file.write("\n\r")
+      end
+
+      []
+    end
+  end
+
+  # m_recipes_first may be useful if a lot of recipes aren't working
+  # refer to the original javascript implementation of
+  # searchCodexForRecipes
+  # m_recipes_first should be used to hit the /mrecipe version of a recipe
+  # for manufacturing-type recipes
+  def search_codex_for_recipes(item, m_recipes_first)
+    item_id = item[:main_key]
+    item_name = item[:name]
+    item_index = "#{item_id} #{item[:name]}"
+    potential_cached_recipes = @cache.read item_index
+    cache_data = {}
+
+    # TODO: remove this check
+    # return unless item_name.downcase == 'harmony draught'
+
+    unless potential_cached_recipes.to_a.empty?
+      recipe_to_maybe_select = potential_cached_recipes.filter { |elem| elem[1].downcase == item_name.downcase }
+      return recipe_to_maybe_select unless recipe_to_maybe_select.empty?
+    end
+
+    recipes = get_item_recipes item_id, item_name
+    cache_data[item_index] = recipes
+
+    @cache.write cache_data
+
+    recipes
+  end
+
+  # pass in a list of items as retrieved from the central market API
+  def get_item_codex_data(item_list)
+    recipes = []
+
+    # newline because vipiko is about to start carriage returning
+    puts "\n"
+    item_list.each.with_index do |item_hash, index|
+      item = item_hash.transform_keys { |key|
+        key.gsub(/(.)([A-Z])/,'\1_\2').downcase.to_sym
+      }
+
+      next unless item[:main_key]
+
+      begin
+        search_results = search_codex_for_recipes item, false
+
+        if search_results
+          # res[0] is the recipe ID
+          all_recipes_for_item = search_results.map { |res|
+            recipe_array = [res[0], res[RECIPE_INGREDIENTS_INDEX]]
+            recipe_array
+          }
+
+          @cli.vipiko_overwrite "(#{index + 1} / #{item_list.length}) let's read the recipe for #{@cli.yellow "[#{item[:name].downcase}]"}. hmm..."
+
+          stock_count = item[:total_in_stock].to_i.zero? ? item[:count].to_i : item[:total_in_stock].to_i
+          recipe_hash = {
+            name: item[:name],
+            recipe_list: all_recipes_for_item,
+            price: item[:price_per_one],
+            id: item[:main_key],
+            total_trade_count: item[:total_trade_count],
+            total_in_stock: stock_count,
+            main_category: item[:main_category],
+            sub_category: item[:sub_category]
+          }
+
+          recipes.push recipe_hash
+        end
+      rescue StandardError => error
+        puts @cli.red("if you're not messing with the code, you should never see this. get_item_codex_data broke.")
+
+        File.open(ENVData::ERROR_LOG, 'a+') do |file|
+          file.write(error.full_message)
+          file.write("\n\r")
+        end
+
+        next
+      end
+    end
+
+    recipes
+  end
+end

data/lib/central_market/category_search_options.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require_relative '../utils/constants'
+
+module MarketSearchTools
+  include Utils
+
+  CONSUMABLE_CATEGORY = 35
+  CONSUMABLE_SUBCATEGORIES = {
+    offensive: 1,
+    defensive: 2,
+    functional: 3,
+    potion: 5,
+    other: 8,
+    all: [1, 2, 3, 5, 8]
+  }.freeze
+
+  # get information used for searching specific categories
+  def category_search_options(url, search_url) # rubocop:disable Metrics/AbcSize
+    # TODO: there's probably a smart / concise way to construct this array
+    [
+      {
+        name: 'black stone',
+        url: url,
+        query_string: "#{ENVData::RVT}&mainCategory=30&subCategory=1",
+        # update: ->(data) { { blackStoneResponse: data['list'] } },
+        update: ->(data) { data['list'] }
+      },
+      {
+        name: 'misc',
+        url: url,
+        query_string: "#{ENVData::RVT}&mainCategory=25&subCategory=8",
+        # update: ->(data) { { blackStoneResponse: data['list'] } },
+        update: ->(data) { data['list'] }
+      },
+      {
+        name: 'other tools',
+        url: url,
+        query_string: "#{ENVData::RVT}&mainCategory=40&subCategory=10",
+        # update: ->(data) { { blackStoneResponse: data['list'] } },
+        update: ->(data) { data['list'] }
+      },
+      {
+        name: 'blood',
+        url: search_url,
+        query_string: "#{ENVData::RVT}&searchText='s+blood",
+        # update: ->(data) { { bloodResponse: data['list'] } },
+        update: ->(data) { data['list'] }
+      },
+      {
+        name: 'reagent',
+        url: search_url,
+        query_string: "#{ENVData::RVT}&searchText=reagent",
+        # update: ->(data) { { reagentResponse: data['list'] } },
+        update: ->(data) { data['list'] }
+      },
+      {
+        name: 'oil',
+        url: search_url,
+        query_string: "#{ENVData::RVT}&searchText=oil+of",
+        # update: ->(data) { { oilResponse: data['list'] } },
+        update: ->(data) { data['list'] }
+      },
+      {
+        name: 'alchemy stone',
+        url: search_url,
+        query_string: "#{ENVData::RVT}&searchText=stone+of",
+        # update: ->(data) { { alchemyStoneResponse: data['list'] } },
+        update: ->(data) { data['list'].filter { |i| i['grade'] == 0 } }
+      },
+      # {
+      #   name: 'magic crystal',
+      #   url: search_url,
+      #   query_string: "#{ENVData::RVT}&searchText=magic+crystal",
+      #   # update: ->(data) { { magicCrystalResponse: data['list'] } },
+      #   update: ->(data) { data['list'] }
+      # },
+      {
+        name: 'offensive',
+        url: url,
+        query_string:
+          "#{ENVData::RVT}&mainCategory=#{CONSUMABLE_CATEGORY}&subCategory=#{CONSUMABLE_SUBCATEGORIES[:offensive]}",
+        # update: ->(data) { { offensiveResponse: data['marketList'] } },
+        update: ->(data) { data['marketList'] }
+      },
+      {
+        name: 'defensive',
+        url: url,
+        query_string:
+          "#{ENVData::RVT}&mainCategory=#{CONSUMABLE_CATEGORY}&subCategory=#{CONSUMABLE_SUBCATEGORIES[:defensive]}",
+        # update: ->(data) { { defensiveResponse: data['marketList'] } },
+        update: ->(data) { data['marketList'] }
+      },
+      {
+        name: 'functional',
+        url: url,
+        query_string:
+          "#{ENVData::RVT}&mainCategory=#{CONSUMABLE_CATEGORY}&subCategory=#{CONSUMABLE_SUBCATEGORIES[:functional]}",
+        # update: ->(data) { { functionalResponse: data['marketList'] } },
+        update: ->(data) { data['marketList'] }
+      },
+      {
+        name: 'potion',
+        url: url,
+        query_string:
+          "#{ENVData::RVT}&mainCategory=#{CONSUMABLE_CATEGORY}&subCategory=#{CONSUMABLE_SUBCATEGORIES[:potion]}",
+        # update: ->(data) { { potionResponse: data['marketList'] } },
+        update: ->(data) { data['marketList'] }
+      },
+      {
+        name: 'other',
+        url: url,
+        query_string:
+          "#{ENVData::RVT}&mainCategory=#{CONSUMABLE_CATEGORY}&subCategory=#{CONSUMABLE_SUBCATEGORIES[:other]}",
+        # update: ->(data) { { otherResponse: data['marketList'] } },
+        update: ->(data) { data['marketList'] }
+      }
+    ]
+  end
+end