Path of Exile Wiki

Wiki поддерживается сообществом, поэтому подумайте над тем, чтобы внести свой вклад.

ПОДРОБНЕЕ

Path of Exile Wiki
Регистрация
Нет описания правки
Magiczocker (обсуждение | вклад)
м (Отмена правки 540808, сделанной Magiczocker (обсуждение))
Метка: отмена
 
(не показано 79 промежуточных версий 4 участников)
Строка 1: Строка 1:
  +
-------------------------------------------------------------------------------
-- Cargo reworked item module
 
  +
--
  +
-- Module:Item2
  +
--
  +
-- This module implements Template:Item and Template:Itembox
  +
-------------------------------------------------------------------------------
   
 
-- ----------------------------------------------------------------------------
 
-- ----------------------------------------------------------------------------
Строка 30: Строка 35:
 
--
 
--
 
-- remove the ul if name_list is not provided
 
-- remove the ul if name_list is not provided
-- maybe smw
 
   
  +
require('Module:No globals')
-- ----------------------------------------------------------------------------
 
  +
local getArgs = require('Module:Arguments').getArgs
-- Imports
 
-- ----------------------------------------------------------------------------
 
 
local m_util = require('Module:Util')
 
local m_util = require('Module:Util')
local getArgs = require('Module:Arguments').getArgs
 
local m_game = require('Module:Game')
 
local m_skill = require('Module:Skill')
 
local m_area = require('Module:Area')
 
 
local m_cargo = require('Module:Cargo')
 
local m_cargo = require('Module:Cargo')
local f_item_link = require('Module:Item link').item_link
 
   
local p = {}
+
local m_game = mw.loadData('Module:Game')
local c = {}
 
c.image_size = 39
 
c.image_size_full = c.image_size * 2
 
c.query_default = 50
 
c.query_max = 200
 
   
  +
-- Should we use the sandbox version of our submodules?
c.lang = mw.language.new('en')
 
  +
local use_sandbox = m_util.misc.maybe_sandbox('Item2')
   
  +
-- Lazy loading
-- ----------------------------------------------------------------------------
 
  +
local f_skill -- require('Module:Skill')._skill
-- Strings
 
  +
local f_item_link -- require('Module:Item link').item_link
-- ----------------------------------------------------------------------------
 
  +
local f_query_area_info -- require('Module:Area').query_area_info
-- This section contains strings used by this module.
 
  +
local f_process_upgraded_from -- require('Module:Item2/upgrade').process_upgraded_from
-- Add new strings here instead of in-code directly, this will help other
 
  +
local f_append_schema -- require('Module:Item2/cargo').append_schema
-- people to correct spelling mistakes easier and help with translation to
 
-- other PoE wikis.
 
--
 
-- TODO: Maybe move this out to a separate sub-page module
 
local i18n = {
 
inventory_icon = 'File:%s inventory icon.png',
 
status_icon = 'File:%s status icon.png',
 
divination_card_art = 'File:%s card art.png',
 
gem_tag_category = '[[:Категория:%s (тег камня)|%s]]',
 
 
misc = {
 
-- used to identify betrayal map series to avoid showing area infobox.
 
betrayal = 'Предательство',
 
upgraded_from_map = 'случайная карта уровнем выше того же региона',
 
},
 
   
  +
-- The cfg table contains all localisable strings and configuration, to make it
categories = {
 
  +
-- easier to port this module to another wiki.
-- maintenance cats
 
  +
local cfg = use_sandbox and mw.loadData('Module:Item2/config/sandbox') or mw.loadData('Module:Item2/config')
improper_modifiers = 'Предметы с неправильными модификаторами',
 
missing_release_version = 'Предметы без версии выпуска',
 
broken_upgraded_from_reference = 'Предметы со сломанными ссылками предметов в параметрах "upgraded_from"',
 
duplicate_upgraded_from_reference = 'Предметы с повторяющимися наборами в параметрах "upgraded_from"',
 
duplicate_query_area_ids = 'Предметы с повторяющимися идентификаторами областей из запросов',
 
base_items = 'Базовые предметы',
 
derived_items = 'Производные предметы',
 
sell_prices_override = 'Предметы с изменёнными ценами продаж',
 
   
  +
local i18n = cfg.i18n
-- regular cats
 
alternate_artwork = 'Предметы с альтернативным внешним видом',
 
   
  +
local core = use_sandbox and require('Module:Item2/core/sandbox') or require('Module:Item2/core')
-- misc
 
gem_tag_affix = '%s (тег камня)',
 
unique_affix = 'Уникальные %s',
 
 
prophecies = 'Пророчества',
 
blight_item = 'Масла',
 
talismans = 'Талисманы',
 
essences = 'Сущности',
 
},
 
   
  +
-- Declare early to avoid errors
stat_skip_patterns = {
 
maps = {
+
local c = {}
'%d+%% увеличение количества найденных предметов в этой области',
 
'%d+%% повышение редкости найденных предметов в этой области',
 
'%+%d+%% увеличение размера групп монстров',
 
-- ranges
 
'%(%d+%-%d+%)%% увеличение количества найденных предметов в этой области',
 
'%(%d+%-%d+%)%% повышение редкости найденных предметов в этой области',
 
'%+%(%d+%-%d+%)%% увеличение размера групп монстров',
 
},
 
jewels = {
 
'Limited to %d+ %(Hidden%)',
 
'Jewel has a radius of %d+ %(Hidden%)',
 
},
 
},
 
 
 
help_text_defaults = {
 
active_gem = 'Для получения умения выберите предмет и поместите камень в гнездо соответствующего цвета. Щелкните ПКМ, чтобы вынуть камень из гнезда.',
 
support_gem = 'Это камень поддержки. Он дает преимущества не герою, а камню умения в связанных гнездах. Вставьте камень поддержки в гнездо, соединенное с гнездом усиливаемого камня активного умения. Щелкните ПКМ, чтобы вынуть камень из гнезда.',
 
jewel = 'Поместите самоцвет в доступное гнездо на дереве пассивных умений. Чтобы вынуть самоцвет, щёлкните по нему правой кнопкой мыши.',
 
},
 
 
-- texts specific to upgraded from
 
upgraded_from_tooltips = {
 
-- formatters
 
f = {
 
random = 'случайный %s',
 
random_2 = 'случайная %s',
 
random_3 = 'случайное %s',
 
random_4 = 'случайные %s',
 
random_corrupted = string.format('случайный %s %%s', m_util.html.poe_color('corrupted', 'осквернённый')),
 
random_corrupted_2 = string.format('случайная %s %%s', m_util.html.poe_color('corrupted', 'осквернённая')),
 
random_corrupted_3 = string.format('случайное %s %%s', m_util.html.poe_color('corrupted', 'осквернённое')),
 
random_corrupted_4 = string.format('случайные %s %%s', m_util.html.poe_color('corrupted', 'осквернённые')),
 
random_unidentified_corrupted = string.format('случайный %s %%s', m_util.html.poe_color('corrupted', 'неопознанный осквернённый')),
 
random_unidentified_corrupted_2 = string.format('случайная %s %%s', m_util.html.poe_color('corrupted', 'неопознанная осквернённая')),
 
random_two_implicit_corrupted = string.format('случайный %s %%s %s', m_util.html.poe_color('corrupted', 'осквернённый'), m_util.html.poe_color('corrupted', 'с двумя собственными свойствами')),
 
random_item_level_x = 'случайный %s %s уровня',
 
random_item_level_x_2 = 'случайная %s %s уровня',
 
random_item_level_x_3 = 'случайное %s %s уровня',
 
random_item_level_x_4 = 'случайные %s %s уровня',
 
random_x_link = 'случайный %s с %s связанными гнёздами',
 
random_x_link_item_level_y = 'случайный %s с %s связанными гнёздами %s уровня',
 
random_x_link_item_level_y_random_influenced = 'случайный %s с %s связанными гнёздами %s уровня и случайным влиянием',
 
random_x_amount = 'случайный %s (%s шт.)',
 
random_x_amount_2 = 'случайная %s (%s шт.)',
 
random_x_amount_3 = 'случайное %s (%s шт.)',
 
random_x_amount_4 = 'случайные %s (%s шт.)',
 
random_influenced = 'случайный предмет %s с влиянием',
 
random_two_influenced = 'случайная %s с двойным влиянием',
 
random_two_influenced_x_2 = 'случайная %s с двойным влиянием %s уровня',
 
random_two_influenced_x_3 = 'случайное %s с двойным влиянием %s уровня',
 
random_shaper = 'случайный %s с влиянием Создателя',
 
random_shaper_item_level_x = 'случайный %s с влиянием Создателя %s уровня',
 
random_shaper_item_level_x_2 = 'случайная %s с влиянием Создателя %s уровня',
 
random_shaper_item_level_x_3 = 'случайное %s с влиянием Создателя %s уровня',
 
random_shaper_item_level_x_4 = 'случайные %s с влиянием Создателя %s уровня',
 
random_shaper_hunter_item_level_x = 'случайный %s с влиянием Создателя и Охотника %s уровня',
 
random_shaper_hunter_item_level_x_2 = 'случайная %s с влиянием Создателя и Охотника %s уровня',
 
random_shaper_hunter_item_level_x_3 = 'случайное %s с влиянием Создателя и Охотника %s уровня',
 
random_shaper_hunter_item_level_x_4 = 'случайные %s с влиянием Создателя и Охотника %s уровня',
 
random_elder_item_level_x = 'случайный %s с влиянием Древнего %s уровня',
 
random_elder_item_level_x_2 = 'случайная %s с влиянием Древнего %s уровня',
 
random_elder_item_level_x_3 = 'случайное %s с влиянием Древнего %s уровня',
 
random_elder_item_level_x_4 = 'случайные %s с влиянием Древнего %s уровня',
 
random_eternal_labyrinth_enchantment = string.format('случайный %%s со случайным %s', m_util.html.poe_color('enchanted', 'зачарованием Вечного Лабиринта')),
 
random_veiled = 'случайный %s с завуалированным свойством',
 
random_two_veiled = 'случайный %s с двумя завуалированными свойствами',
 
random_primordial = string.format('случайный %s %%s', m_util.html.poe_color('magic', 'Первородный')),
 
random_map_level = 'случайная %s, осквернённая и %s уровня',
 
 
tier_x_map = 'карта %s уровня',
 
level_x_gem = 'камень %s уровня',
 
level_x_y_gem = 'камень с меткой "%s" %s уровня',
 
superior_gem_q_x = 'камень с качеством %s',
 
superior_x_gem_q_y = 'камень с меткой "%s" и качеством %s',
 
superior_level_x_y_gem_q_z = 'камень с меткой "%s" %s уровня и качеством %s',
 
superior_skill_gem = 'камень умения случайного качества',
 
superior_level_x_skill_gem_q_y = 'камень умения %s уровня и качеством %s',
 
superior_level_x_support_plus_gem_q_y = 'пробужденный камень поддержки %s уровня и качеством %s',
 
 
x_item = 'предмет %s',
 
},
 
 
-- items / rewards not covered by module game
 
agate_amulet = 'амулет с агатом',
 
unset_ring = 'кольцо без камня',
 
gold_ring = 'золотое кольцо',
 
prismatic_ring = 'радужное кольцо',
 
two_stone_ring = 'кольцо с двумя камнями',
 
crystal_sceptre = 'кристальный скипетр',
 
nightmare_bascinet = 'кошмарный бацинет',
 
rustic_sash = 'кушак',
 
talisman = 'талисман',
 
tier_1_talisman = 'талисман 1 уровня',
 
breachstone_splinter = 'осколок Разлома',
 
breachstone = 'камень Разлома',
 
pure_breachstone = 'очищенный камень Разлома',
 
scarab = 'скарабей',
 
gilded_scarab = 'золочёный скарабей',
 
divination_card = 'гадальная карта',
 
quality_currency = 'валюта, повышающая качество',
 
essence = 'сущность',
 
deafening_essence = 'оглушающая сущность',
 
shrieking_essence = 'визжащая сущность',
 
fossil = 'ископаемое',
 
fragment = 'фрагмент',
 
sacrifice_fragment = 'фрагмент жертвы',
 
mortal_fragment = 'смертный фрагмент',
 
uber_elder_fragment = 'фрагмент убер-Древнего',
 
harbinger_fragment = 'фрагмент Предвестника',
 
body_armour = 'нательный доспех',
 
shield = 'щит',
 
map = 'карта',
 
belt = 'пояс',
 
armour = 'доспех',
 
helmet = 'шлем',
 
weapon = 'оружие',
 
jewel = 'самоцвет',
 
timeless_jewel = 'вневременной самоцвет',
 
jewellery = 'бижутерия',
 
one_hand_weapon = 'одноручное оружие',
 
two_hand_weapon = 'двуручное оружие',
 
sword = 'меч',
 
axe = 'топор',
 
flask = 'флакон',
 
granite_flask = 'гранитный флакон',
 
amulet = 'амулет',
 
ring = 'кольцо',
 
league_specific_item = 'предмет из лиги',
 
item = 'предмет',
 
fated_item = 'судьбоносный уникальный предмет',
 
 
-- prefix
 
life = 'со здоровьем',
 
 
--
 
-- used within essences
 
--
 
essence_plus_one_level = string.format('+1 уровень в результате %s' ,m_util.html.poe_color('corrupted', 'осквернения')),
 
essence_type_change = string.format('изменение типа в результате %s' ,m_util.html.poe_color('corrupted', 'осквернения')),
 
},
 
 
-- Used by the item info box
 
tooltips = {
 
corrupted = m_util.html.poe_color('corrupted', 'Осквернено'),
 
support_icon = 'Изображение: %s',
 
radius = 'Радиус: %s',
 
mana_reserved = 'Удержано маны: %s',
 
mana_cost = 'Расход маны: %s',
 
mana_multiplier = 'Множитель маны: %s',
 
vaal_souls_per_use = 'Разовый расход душ: %s',
 
stored_uses = 'Максимум зарядов: %s',
 
vaal_soul_gain_prevention_time = 'Нельзя получать души: %s',
 
cooldown_time = 'Перезарядка: %s',
 
cast_time = 'Время применения: %s',
 
critical_strike_chance = 'Шанс критического удара: %s',
 
attack_speed_multiplier = 'Скорость атаки: %s',
 
attack_speed_multiplier_fmt = '%i%% от базовой',
 
damage_effectiveness = 'Эффективность добавленного урона: %s',
 
projectile_speed = 'Скорость снаряда: %s',
 
quality = 'Качество: %s',
 
physical_damage = 'Физический урон: %s',
 
elemental_damage = 'Урон от стихий: %s',
 
chaos_damage = 'Урон хаосом: %s',
 
attacks_per_second = 'Атак в секунду: %s',
 
weapon_range = 'Дальность оружия: %s',
 
map_level = 'Уровень области: %s',
 
map_tier = 'Уровень карты: %s',
 
map_guild_character = m_util.html.abbr('Редактор тега гильдии', 'При редактировании тега гильдии эта карта может быть использована для данного символа') .. ': %s',
 
item_quantity = 'Количество предметов: %s',
 
item_rarity = 'Редкость предметов: %s',
 
monster_pack_size = 'Размер групп монстров: %s',
 
limited_to = 'Максимум: %s',
 
flask_mana_recovery = 'Восстанавливает маны: %s за %s сек.',
 
flask_life_recovery = 'Восстанавливает здоровья: %s за %s сек.',
 
flask_duration = 'Длится %s сек.',
 
flask_charges_per_use = 'Расходует %s из %s зарядов при использовании',
 
chance_to_block = 'Шанс заблокировать удар: %s',
 
armour = 'Броня: %s',
 
evasion = 'Уклонение: %s',
 
energy_shield = 'Энерг. щит: %s',
 
movement_speed = 'Скорость передвижения: %s',
 
talisman_tier = 'Уровень талисмана: %s',
 
stack_size = 'Размер стопки: %s',
 
essence_level = 'Уровень сущности: %s',
 
blight_item_tier = 'Уровень масла: %s',
 
requires = 'Требуется %s',
 
level_inline = 'Уровень %s',
 
level = 'Уровень: %s',
 
gem_quality = 'За 1% качества:',
 
gem_quality_1 = 'По умолчанию',
 
gem_quality_2 = 'Аномальный',
 
gem_quality_3 = 'Искривлённый',
 
gem_quality_4 = 'Фантомный',
 
variation_singular = 'Изменений:',
 
variation_plural = 'Изменений:',
 
favour_cost = 'Цена расположения: %s',
 
seal_cost = 'Стоимость печати: <br>%s',
 
cannot_be_traded_or_modified = 'Этот предмет нельзя отдать или изменить',
 
 
-- harvest seeds
 
 
seed_tier = 'Уровень семени: %s',
 
seed_monster = 'При сборе появляется монстр ? уровня',
 
seed_lifeforce_gained = 'При сборе даёт ? едениц(-ы) чистой %s жизненной силы',
 
seed_growth_cycles = 'Можно собрать после %s циклов роста',
 
 
seed_lifeforce_consumed = 'Потребляет (%s%%) единиц(-ы) конденсированной %s жизненной силы из распылителя за цикл роста',
 
seed_required_seeds = 'Для роста требует соседства %s %s растений как минимум %s уровня',
 
 
-- harvest plant boosters, not used at the moment
 
plant_booster_extra_chances = 'Seeds in radius give the rarest of %s chosen Crafting Options when Harvested',
 
plant_booster_lifeforce = 'Seeds in radius produce %s more Lifeforce when Harvested',
 
plant_booster_additional_crafting_optioons = 'Seeds in radius have %s chance to generate additional Crafting Options when Harvested',
 
 
 
-- heist
 
heist_required_npc = 'Этот предмет могут использовать: %s',
 
heist_required_job = 'Требуется %s %s уровня',
 
heist_any_job = 'Любая роль',
 
 
-- ClientStrings.dat -> WeaponClassDisplayName.*
 
item_class_map = {
 
['Staff'] = 'Посох',
 
['Bow'] = 'Лук',
 
['Wand'] = 'Жезл',
 
['Two Hand Axe'] = 'Двуручный топор',
 
['Two Hand Sword'] = 'Двуручный меч',
 
['Two Hand Mace'] = 'Двуручная булава',
 
['Warstaff'] = 'Воинский посох',
 
['Sceptre'] = 'Скипетр',
 
['One Hand Mace'] = 'Одноручная булава',
 
['One Hand Axe'] = 'Одноручный топор',
 
['One Hand Sword'] = 'Одноручный меч',
 
['Thrusting One Hand Sword'] = 'Одноручный меч',
 
['Claw'] = 'Когти',
 
['Dagger'] = 'Кинжал',
 
['Rune Dagger'] = 'Рунический кинжал',
 
['FishingRod'] = 'Удочка',
 
},
 
 
random_mod = '&lt;&lt;случайное свойство %s&gt;&gt;',
 
 
--
 
-- secondary infobox
 
--
 
extra_info = 'Дополнительная информация',
 
header_overall = 'Диаграмма улучшения области',
 
header_upgrades = 'Уровень улучшения',
 
header_map_tier = 'Уровень карты',
 
header_map_level = 'Уровень области',
 
header_connections = 'Соединения',
 
 
drop_restrictions = 'Получение',
 
league_restriction = m_util.html.abbr('Лига(-и):', 'Предмет может быть получен только в Лиге(-ах)') .. ' %s',
 
drop_disabled = 'НЕ ВЫПАДАЕТ',
 
 
purchase_costs = m_util.html.abbr('Стоимость покупки', 'Стоимость покупки предмета такого типа у торгующих NPC. Это не означает, действительно ли NPC продаст вам этот предмет.'),
 
sell_price = m_util.html.abbr('Цена продажи', 'Товары или валюта, полученные при продаже этого товара у торгующих NPC. Некоторые рецепты торговцев могут переопределить это значение.'),
 
 
damage_per_second = 'УВС Оружия',
 
physical_dps = m_game.constants.damage_types.physical.short_upper,
 
fire_dps = m_game.constants.damage_types.fire.short_upper,
 
cold_dps = m_game.constants.damage_types.cold.short_upper,
 
lightning_dps = m_game.constants.damage_types.lightning.short_upper,
 
chaos_dps = m_game.constants.damage_types.chaos.short_upper,
 
elemental_dps = 'Стихийный',
 
poison_dps = 'Физ+Хаос',
 
dps = 'Общий',
 
 
misc = 'Прочее',
 
item_class = 'Класс предмета: %s',
 
metadata_id = 'ID: %s',
 
},
 
 
item_class_infobox = {
 
page = '[[Класс предметов]]',
 
info = m_util.html.abbr('(?)', 'Классы предметов помогают классифицировать предметы. Классы в основном используются для разграничения предметов или камней умений по определенному классу или для создания фильтров предметов.'),
 
also_referred_to_as = 'Также упоминается как:',
 
},
 
 
debug = {
 
base_item_field_not_found = 'Base item property not found: %s.%s',
 
field_value_mismatch = 'Value for argument "%s" is set to something else then default: %s',
 
},
 
 
errors = {
 
missing_base_item = 'Rarity is set to above normal, but base item is not set. A base item for rarities above normal is required!',
 
missing_rarity = 'Base item parameter is set, but rarity is set to normal. A rarity above normal is required!',
 
missing_amount = 'Item amount is missing or not a number (%s)',
 
upgraded_from_broken_reference = 'Item reference in %s is broken (value: %s)',
 
upgraded_from_duplicate = 'Automatic upgraded from entry is duplicated on page in upgraded_from_set%s',
 
duplicate_base_items = 'More then one result found for the specified base item. Consider using base_item_page or base_item_id to narrow down the results.',
 
base_item_not_found = 'Базовый предмет не найден в базе данных. Проверьте орфографические ошибки или наличие страницы базового предмета на вики. Если страница базового предмета существует на вики, но не может быть найдена, пожалуйста, отредактируйте страницу.',
 
invalid_league = '%s не распознаётся как "лига"',
 
invalid_tag = '%s не является допустимым тегом',
 
generic_argument_parameter = 'Unrecognized %s parameter "%s"',
 
generic_required_parameter = 'Parameter "%s" must be specified for this item type.',
 
non_unique_flag = 'Only unique items can are egible for the flag "%s".',
 
duplicate_area_id_from_query = 'Query found duplicate area ids that do not need to be set on the item. Duplicate ids: "%s"',
 
duplicate_metadata = 'Дубликат ID метаданных "%s" на странице "%s"',
 
invalid_influence = 'The influence "%s" is invalid. Acceptable values are "shaper", "elder", "crusader", "redeemer", "hunter" and "warlord".',
 
invalid_class = 'The item class name "%s" is invalid.',
 
invalid_class_id = 'Данный класс id не верный "%s". Для правильной работы модуля Item2 и шаблона, необходимо использовать правильный идентификатор.',
 
invalid_rarity_id = 'Недопустимый идентификатор редкости "%s". Допустимые значения: "normal", "magic", "rare" и "unique".',
 
invalid_region_upgrade_count = 'atlas_connection%s_tier: Invalid amount (%s) of connections, only 5 are allowed',
 
},
 
}
 
   
 
-- ----------------------------------------------------------------------------
 
-- ----------------------------------------------------------------------------
-- Other stuff
+
-- Helper functions
 
-- ----------------------------------------------------------------------------
 
-- ----------------------------------------------------------------------------
   
 
local h = {}
 
local h = {}
   
  +
-- Lazy loading for Module:Skill
function h.debug(tpl_args, func)
 
if tpl_args.debug == nil then
+
function h.skill(tpl_args, frame)
return
+
if not f_skill then
  +
f_skill = use_sandbox and require('Module:Skill/sandbox')._skill or require('Module:Skill')._skill
 
end
 
end
  +
return f_skill(tpl_args, frame)
func()
 
 
end
 
end
   
  +
-- Lazy loading for Module:Item link
function h.na_or_val(tr, value, func)
 
  +
function h.item_link(args)
if value == nil then
 
  +
if not f_item_link then
tr:wikitext(m_util.html.td.na())
 
  +
f_item_link = require('Module:Item link').item_link
else
 
local raw_value = value
 
if func ~= nil then
 
value = func(value)
 
end
 
tr
 
:tag('td')
 
:attr('data-sort-value', raw_value)
 
:wikitext(value)
 
:done()
 
 
end
 
end
  +
return f_item_link(args)
 
end
 
end
   
  +
-- Lazy loading for Module:Item link
-- helper to loop over the range variables easier
 
  +
function h.query_area_info(args)
h.range_map = {
 
  +
if not f_query_area_info then
min = {
 
  +
f_query_area_info = require('Module:Area').query_area_info
var = '_range_minimum',
 
},
+
end
  +
return f_query_area_info(args)
max = {
 
var = '_range_maximum',
 
},
 
avg = {
 
var = '_range_average',
 
},
 
}
 
 
h.range_fields = {
 
{
 
field = '_range_minimum',
 
type = nil,
 
},
 
{
 
field = '_range_maximum',
 
type = nil,
 
},
 
{
 
field = '_range_average',
 
type = nil,
 
},
 
{
 
field = '_range_text',
 
type = 'Text',
 
},
 
{
 
field = '_range_colour',
 
type = 'String',
 
},
 
{
 
field = '_html',
 
type = 'Text',
 
},
 
 
}
 
 
function h.handle_range_args(tpl_args, frame, argument_key, field, value, fmt_options)
 
fmt_options = mw.clone(fmt_options)
 
fmt_options.return_color = true
 
local html, colour = m_util.html.format_value(tpl_args, frame, value, fmt_options)
 
tpl_args[argument_key .. '_html'] = html
 
tpl_args[field .. '_html'] = html
 
tpl_args[field .. '_range_colour'] = colour
 
 
fmt_options = mw.clone(fmt_options)
 
fmt_options.no_color = true
 
tpl_args[field .. '_range_text'] = m_util.html.format_value(tpl_args, frame, value, fmt_options)
 
 
end
 
end
   
  +
-- Lazy loading for Module:Item2/cargo
function h.stats_update(tpl_args, id, value, modid, key)
 
  +
function h.append_schema(tpl_args, frame, tables)
if tpl_args[key][id] == nil then
 
  +
if not f_append_schema then
tpl_args[key][id] = {
 
  +
f_append_schema = use_sandbox and require('Module:Item2/cargo/sandbox').append_schema or require('Module:Item2/cargo').append_schema
references = {modid},
 
min = value.min,
 
max = value.max,
 
avg = value.avg,
 
}
 
else
 
if modid ~= nil then
 
table.insert(tpl_args[key][id].references, modid)
 
end
 
tpl_args[key][id].min = tpl_args[key][id].min + value.min
 
tpl_args[key][id].max = tpl_args[key][id].max + value.max
 
tpl_args[key][id].avg = tpl_args[key][id].avg + value.avg
 
 
end
 
end
  +
return f_append_schema(tpl_args, frame, tables)
 
end
 
end
   
  +
-- Lazy loading for Module:Item2/upgrade
h.stat = {}
 
function h.stat.add (value, stat_cached)
+
function h.process_upgraded_from(tpl_args, frame)
  +
if not f_process_upgraded_from then
value.min = value.min + stat_cached.min
 
  +
f_process_upgraded_from = use_sandbox and require('Module:Item2/upgrade/sandbox').process_upgraded_from or require('Module:Item2/upgrade').process_upgraded_from
value.max = value.max + stat_cached.max
 
end
 
 
function h.stat.more (value, stat_cached)
 
value.min = value.min * (1 + stat_cached.min / 100)
 
value.max = value.max * (1 + stat_cached.max / 100)
 
end
 
 
function h.stat.more_inverse (value, stat_cached)
 
value.min = value.min / (1 + stat_cached.min / 100)
 
value.max = value.max / (1 + stat_cached.max / 100)
 
end
 
 
-- ----------------------------------------------------------------------------
 
-- core
 
-- ----------------------------------------------------------------------------
 
 
local core = {}
 
 
function core.build_cargo_data(tpl_args, frame)
 
for _, table_name in ipairs(core.item_classes[tpl_args.class_id].tables) do
 
-- Need to clone the table here because we'll be changing the table as we run though
 
-- TODO: Optimize this?
 
for k, _ in pairs(mw.clone(core.cargo[table_name].fields)) do
 
field_data = core.cargo[table_name].fields[k]
 
field_data.table = table_name
 
for _, stat_data in pairs(core.stat_map) do
 
if stat_data.field == k then
 
for _, range_field in ipairs(h.range_fields) do
 
local field_name = stat_data.field .. range_field.field
 
 
local data = {
 
no_copy = true,
 
table = table_name,
 
field = field_name,
 
-- if the type is nil, use the parent type
 
-- this is set integer/float values correctly
 
type = range_field.type or field_data.type,
 
}
 
 
core.cargo[table_name].fields[field_name] = data
 
core.map[field_name] = data
 
end
 
break
 
end
 
end
 
if table_name == 'weapons' then
 
for _, dps_data in ipairs(core.dps_map) do
 
for _, range_field in ipairs(h.range_fields) do
 
local field_name = dps_data.field .. range_field.field
 
 
local data = {
 
no_copy = true,
 
table = table_name,
 
field = field_name,
 
-- dps values are floating points
 
type = range_field.type or 'Float',
 
}
 
 
core.cargo[table_name].fields[field_name] = data
 
core.map[field_name] = data
 
end
 
end
 
end
 
end
 
 
end
 
end
  +
return f_process_upgraded_from(tpl_args, frame)
 
end
 
end
   
function core.validate_mod(tpl_args, frame, args)
+
function h.validate_mod(tpl_args, frame, args)
 
-- args:
 
-- args:
 
-- key - implict or explicit
 
-- key - implict or explicit
Строка 587: Строка 117:
 
local prefix = args.key .. args.i
 
local prefix = args.key .. args.i
 
local value = tpl_args[prefix]
 
local value = tpl_args[prefix]
  +
local is_implicit = args.key == 'implicit'
 
local out = {
 
local out = {
 
result=nil,
 
result=nil,
Строка 592: Строка 123:
 
id=nil,
 
id=nil,
 
stat_text=nil,
 
stat_text=nil,
is_implicit=(args.key == 'implicit'),
+
is_implicit=is_implicit,
 
is_random=nil,
 
is_random=nil,
 
}
 
}
 
 
  +
local mods_table = is_implicit and tpl_args._defined_implicit_mods or tpl_args._mods
 
if value ~= nil then
 
if value ~= nil then
 
out.id = value
 
out.id = value
 
out.stat_text = tpl_args[prefix .. '_text']
 
out.stat_text = tpl_args[prefix .. '_text']
 
out.is_random = false
 
out.is_random = false
table.insert(tpl_args._mods, out)
+
table.insert(mods_table, out)
 
 
 
return true
 
return true
Строка 607: Строка 139:
 
value = m_util.string.split(tpl_args[prefix .. '_random_list'], ',%s*')
 
value = m_util.string.split(tpl_args[prefix .. '_random_list'], ',%s*')
 
for _, mod_id in ipairs(value) do
 
for _, mod_id in ipairs(value) do
table.insert(tpl_args._mods, {
+
table.insert(mods_table, {
 
result = nil,
 
result = nil,
 
id = mod_id,
 
id = mod_id,
 
stat_text = tpl_args[prefix .. '_text'] or string.format(i18n.tooltips.random_mod, args.i),
 
stat_text = tpl_args[prefix .. '_text'] or string.format(i18n.tooltips.random_mod, args.i),
is_implicit = (args.key == 'implicit'),
+
is_implicit = is_implicit,
 
is_random = true,
 
is_random = true,
 
})
 
})
Строка 623: Строка 155:
 
out.stat_text = value
 
out.stat_text = value
 
out.is_random = false
 
out.is_random = false
table.insert(tpl_args._mods, out)
+
table.insert(mods_table, out)
 
 
 
return true
 
return true
Строка 631: Строка 163:
 
end
 
end
   
function core.process_smw_mods(tpl_args, frame)
+
function h.handle_range_args(tpl_args, frame, argument_key, field, value, fmt_options)
  +
fmt_options = mw.clone(fmt_options)
if #tpl_args._mods > 0 then
 
  +
fmt_options.return_color = true
local mods = {}
 
  +
local html, colour = m_util.html.format_value(tpl_args, frame, value, fmt_options)
local mod_ids = {}
 
  +
tpl_args[argument_key .. '_html'] = html
local non_random_mod_ids = {}
 
  +
tpl_args[field .. '_html'] = html
for _, mod_data in ipairs(tpl_args._mods) do
 
  +
tpl_args[field .. '_range_colour'] = colour
if mod_data.result == nil then
 
  +
mods[mod_data.id] = mod_data
 
  +
fmt_options = mw.clone(fmt_options)
mod_ids[#mod_ids+1] = mod_data.id
 
  +
fmt_options.no_color = true
if not mod_data.is_random then
 
  +
tpl_args[field .. '_range_text'] = m_util.html.format_value(tpl_args, frame, value, fmt_options)
table.insert(non_random_mod_ids, mod_data.id)
 
end
 
end
 
tpl_args._subobjects[#tpl_args._subobjects+1] = {
 
_table = 'item_mods',
 
id = mod_data.id,
 
text = mod_data.stat_text,
 
is_implicit = mod_data.is_implicit,
 
is_random = mod_data.is_random,
 
}
 
end
 
 
local results = m_cargo.array_query{
 
tables={'mods'},
 
fields={'mods._pageName', 'mods.id', 'mods.required_level', 'mods.stat_text'},
 
id_field='mods.id',
 
id_array=mod_ids,
 
}
 
 
for _, data in ipairs(results) do
 
local mod_data = mods[data['mods.id']]
 
mod_data.result = data
 
 
if mod_data.is_random == false then
 
-- update item level requirement
 
local keys = {'required_level_final'}
 
-- only update base item requirement if this is an implicit
 
if mod_data.key == 'implicit' then
 
keys[#keys+1] = 'required_level'
 
end
 
 
for _, key in ipairs(keys) do
 
local req = math.floor(tonumber(data['mods.required_level']) * 0.8)
 
if req > tpl_args[key] then
 
tpl_args[key] = req
 
end
 
end
 
end
 
end
 
 
-- fetch stats
 
 
results = m_cargo.query(
 
{'mods', 'mod_stats'},
 
{'mods.id', 'mod_stats.id', 'mod_stats.min', 'mod_stats.max'},
 
{
 
join='mods._pageID=mod_stats._pageID',
 
where=string.format('mod_stats.id IS NOT NULL AND mods.id IN ("%s")', table.concat(mod_ids, '", "')),
 
}
 
)
 
for _, data in ipairs(results) do
 
-- Stat subobject
 
local mod_data = mods[data['mods.id']]
 
if mod_data.result.stats == nil then
 
mod_data.result.stats = {data, }
 
else
 
mod_data.result.stats[#mod_data.result.stats+1] = data
 
end
 
 
local id = data['mod_stats.id']
 
local value = {
 
min = tonumber(data['mod_stats.min']),
 
max = tonumber(data['mod_stats.max']),
 
}
 
value.avg = (value.min+value.max)/2
 
 
local prefix = ''
 
if mod_data.is_random then
 
prefix = '_random'
 
end
 
h.stats_update(tpl_args, id, value, mod_data.result['mods.id'], prefix .. '_stats')
 
if mod_data.is_implicit then
 
h.stats_update(tpl_args, id, value, mod_data.result['mods.id'], prefix .. '_implicit_stats')
 
else
 
h.stats_update(tpl_args, id, value, mod_data.result['mods.id'], prefix .. '_explicit_stats')
 
end
 
end
 
 
if tpl_args._flags.sell_prices_override ~= true then
 
-- fetch sell prices
 
results = m_cargo.query(
 
{'mods', 'mod_sell_prices'},
 
{'mods.id', 'mod_sell_prices.amount', 'mod_sell_prices.name'},
 
{
 
join='mods._pageID=mod_sell_prices._pageID',
 
-- must be non random mods to avoid accumulating sell prices of randomized modifiers
 
where=string.format('mod_sell_prices.amount IS NOT NULL AND mods.id IN ("%s")', table.concat(non_random_mod_ids, '", "')),
 
}
 
)
 
 
for _, data in ipairs(results) do
 
local mod_data = mods[data['mods.id']]
 
if not mod_data.is_implicit then
 
local values = {
 
name = data['mod_sell_prices.name'],
 
amount = tonumber(data['mod_sell_prices.amount']),
 
}
 
-- sell_prices is defined in tpl_args.sell_prices_override
 
tpl_args.sell_prices[values.name] = (tpl_args.sell_prices[values.name] or 0) + values.amount
 
end
 
end
 
end
 
end
 
if tpl_args._flags.sell_prices_override ~= true then
 
local missing_sell_price = true
 
for _, _ in pairs(tpl_args.sell_prices) do
 
missing_sell_price = false
 
break
 
end
 
 
if missing_sell_price then
 
tpl_args.sell_prices['Обрывок свитка'] = 1
 
end
 
 
-- Set sell price on page
 
for name, amount in pairs(tpl_args.sell_prices) do
 
-- sell_price_order is defined in tpl_args.sell_prices_override
 
tpl_args.sell_price_order[#tpl_args.sell_price_order+1] = name
 
tpl_args._subobjects[#tpl_args._subobjects+1] = {
 
_table = 'item_sell_prices',
 
amount = amount,
 
name = name,
 
}
 
end
 
table.sort(tpl_args.sell_price_order)
 
end
 
 
end
 
end
   
  +
h.stat = {}
function core.process_base_item(tpl_args, frame, args)
 
  +
function h.stat.add(value, stat_cached)
local where
 
  +
value.min = value.min + stat_cached.min
if tpl_args.base_item_id ~= nil then
 
  +
value.max = value.max + stat_cached.max
where = string.format('items.metadata_id="%s"', tpl_args.base_item_id)
 
elseif tpl_args.base_item_page ~= nil then
 
where = string.format('items._pageName="%s"' , tpl_args.base_item_page)
 
elseif tpl_args.base_item ~= nil then
 
where = string.format('items.name="%s"' , tpl_args.base_item)
 
elseif tpl_args.rarity_id ~= 'normal' then
 
error(m_util.html.error{msg=i18n.errors.missing_base_item})
 
else
 
return
 
end
 
 
if where ~= nil and tpl_args.rarity_id == 'normal' and not tpl_args._flags.is_prophecy then
 
error(m_util.html.error{msg=i18n.errors.missing_rarity})
 
end
 
 
where = string.format('%s AND items.class_id="%s" AND items.rarity_id="normal"', where, tpl_args.class_id)
 
 
local join = {}
 
 
for _, table_name in ipairs(core.item_classes[tpl_args.class_id].tables) do
 
if table_name ~= 'items' then
 
join[#join+1] = string.format('items._pageID=%s._pageID', table_name)
 
end
 
end
 
 
local fields = {
 
'items._pageName',
 
'items.name',
 
'items.metadata_id',
 
}
 
 
for _, k in ipairs(tpl_args._base_item_args) do
 
local data = core.map[k]
 
if data.field ~= nil then
 
fields[#fields+1] = string.format('%s.%s', data.table, data.field)
 
end
 
end
 
 
local result = m_cargo.query(
 
core.item_classes[tpl_args.class_id].tables,
 
fields,
 
{
 
where=where,
 
join=table.concat(join, ','),
 
groupBy='items._pageID',
 
}
 
)
 
 
if #result > 1 then
 
error(m_util.html.error{msg=i18n.errors.duplicate_base_items})
 
-- TODO be more explicit in the error?
 
elseif #result == 0 then
 
error(m_util.html.error{msg=i18n.errors.base_item_not_found})
 
end
 
 
result = result[1]
 
 
tpl_args.base_item_data = result
 
core.process_arguments(tpl_args, frame, {array={'base_item', 'base_item_page', 'base_item_id'}})
 
 
--Copy values..
 
for _, k in ipairs(tpl_args._base_item_args) do
 
local data = core.map[k]
 
if data.field ~= nil and data.func_fetch == nil then
 
local value = result[string.format('%s.%s', data.table, data.field)]
 
-- I can just use data.default since it will be nil if not provided (nil == nil). Neat! ;)
 
if value ~= nil and (tpl_args[k] == data.default or type(data.default) == 'function') then
 
tpl_args[k] = value
 
if data.func ~= nil then
 
data.func(tpl_args, frame)
 
end
 
if data.func_copy ~= nil then
 
data.func_copy(tpl_args, frame)
 
end
 
elseif value == nil and not data.debug_ignore_nil then
 
h.debug(tpl_args, function ()
 
error(string.format(i18n.debug.base_item_field_not_found, data.table, data.field))
 
end)
 
elseif tpl_args[k] ~= data.default then
 
h.debug(tpl_args, function ()
 
error(string.format(i18n.debug.field_value_mismatch, k, tostring(tpl_args[k])))
 
end)
 
end
 
elseif data.func_fetch ~= nil then
 
data.func_fetch(tpl_args, frame)
 
end
 
end
 
 
end
 
end
   
function core.process_arguments(tpl_args, frame, args)
+
function h.stat.more(value, stat_cached)
  +
value.min = value.min * (1 + stat_cached.min / 100)
for _, k in ipairs(args.array) do
 
  +
value.max = value.max * (1 + stat_cached.max / 100)
local data = core.map[k]
 
if data == nil then
 
error(string.format('Invalid key or missing data for "%s"', k))
 
end
 
if data.no_copy == nil then
 
table.insert(tpl_args._base_item_args, k)
 
end
 
if data.func ~= nil then
 
data.func(tpl_args, frame)
 
--[[local status, err = pcall(data.func)
 
-- an error was raised, return the error string instead of the template
 
if not status then
 
return err
 
end
 
]]--
 
end
 
if tpl_args[k] == nil then
 
if tpl_args.class_id and core.item_classes[tpl_args.class_id].defaults ~= nil and core.item_classes[tpl_args.class_id].defaults[k] ~= nil then
 
tpl_args[k] = core.item_classes[tpl_args.class_id].defaults[k]
 
elseif data.default ~= nil then
 
if type(data.default) == 'function' then
 
tpl_args[k] = data.default(tpl_args, frame)
 
else
 
tpl_args[k] = data.default
 
end
 
end
 
end
 
end
 
end
 
 
function core.process_mod_stats(tpl_args, args)
 
local lines = {}
 
 
local skip = core.class_specifics[tpl_args.class_id]
 
if skip then
 
skip = skip.skip_stat_lines
 
end
 
 
local random_mods = {}
 
 
for _, modinfo in ipairs(tpl_args._mods) do
 
if modinfo.is_implicit == args.is_implicit then
 
if modinfo.is_random == true then
 
if random_mods[modinfo.stat_text] then
 
table.insert(random_mods[modinfo.stat_text], modinfo)
 
else
 
random_mods[modinfo.stat_text] = {modinfo}
 
end
 
else
 
if modinfo.id == nil then
 
table.insert(lines, modinfo.result)
 
-- Allows the override of the SMW fetched mod texts for this modifier via <modtype><id>_text parameter
 
elseif modinfo.text ~= nil then
 
table.insert(lines, modinfo.text)
 
else
 
for _, line in ipairs(m_util.string.split(modinfo.result['mods.stat_text'] or '', '<br>')) do
 
if line ~= '' then
 
if skip == nil then
 
table.insert(lines, line)
 
else
 
local skipped = false
 
for _, pattern in ipairs(skip) do
 
if string.match(line, pattern) then
 
skipped = true
 
break
 
end
 
end
 
if not skipped then
 
table.insert(lines, line)
 
end
 
end
 
end
 
end
 
end
 
end
 
end
 
end
 
 
for stat_text, modinfo_list in pairs(random_mods) do
 
local text = {}
 
for _, modinfo in ipairs(modinfo_list) do
 
table.insert(text, modinfo.result['mods.stat_text'])
 
end
 
 
local tbl = mw.html.create('table')
 
tbl
 
:attr('class', 'random-modifier-stats mw-collapsed')
 
:attr('style', 'text-align: left')
 
:tag('tr')
 
:tag('th')
 
:attr('class', 'mw-customtoggle-31')
 
:wikitext(stat_text)
 
:done()
 
:done()
 
:tag('tr')
 
:attr('class', 'mw-collapsible mw-collapsed')
 
:attr('id', 'mw-customcollapsible-31')
 
:tag('td')
 
:wikitext(table.concat(text, '<hr style="width: 20%">'))
 
:done()
 
:done()
 
table.insert(lines, tostring(tbl))
 
end
 
 
if #lines == 0 then
 
return
 
else
 
return table.concat(lines, '<br>')
 
end
 
 
end
 
end
   
function core.process_quest_rewards(tpl_args, frame)
+
function h.stat.more_inverse(value, stat_cached)
  +
value.min = value.min / (1 + stat_cached.min / 100)
local rid = 1
 
  +
value.max = value.max / (1 + stat_cached.max / 100)
local continue
 
tpl_args.quest_rewards = {}
 
tpl_args.vendor_rewards = {}
 
repeat
 
continue = true
 
local prefix = string.format('quest_reward%s_', rid)
 
 
local input_args = {
 
shared = {
 
['type'] = true,
 
['quest'] = false,
 
['quest_id'] = false,
 
['act'] = true,
 
['class_ids'] = false,
 
},
 
vendor = {
 
['npc'] = true,
 
},
 
quest = {
 
['sockets'] = false,
 
['item_level'] = false,
 
['rarity_id'] = false,
 
['notes'] = false,
 
},
 
}
 
 
local rdata = {}
 
 
for key, is_required in pairs(input_args.shared) do
 
rdata[key] = tpl_args[prefix .. key]
 
if is_required then
 
if rdata[key] == nil then
 
continue = false
 
break
 
end
 
end
 
end
 
 
if rdata.quest == nil or rdata.quest_id == nil then
 
continue = false
 
end
 
 
if continue and rdata.type == 'vendor' or rdata.type == 'quest' then
 
for key, is_required in pairs(input_args[rdata.type]) do
 
rdata[key] = tpl_args[prefix .. key]
 
if is_required then
 
if rdata[key] == nil then
 
continue = false
 
break
 
end
 
end
 
end
 
else
 
continue = false
 
end
 
 
if continue then
 
rdata.classes = {}
 
if rdata.class_ids ~= nil then
 
rdata.class_ids = m_util.string.split(rdata.class_ids, ',%s*')
 
for index, class_id in ipairs(rdata.class_ids) do
 
local class = m_game.constants.characters[class_id]
 
if class == nil then
 
error(string.format('Class id %s is invalid', class_id))
 
else
 
rdata.class_ids[index] = class.str_id
 
rdata.classes[index] = class.name
 
end
 
end
 
end
 
 
 
if rdata.item_level then
 
rdata.item_level = m_util.cast.number(rdata.item_level)
 
end
 
 
if rdata.rarity_id then
 
if m_game.constants.rarities[rdata.rarity_id] == nil then
 
error(string.format(i18n.errors.invalid_rarity_id, tostring(rdata.rarity_id)))
 
end
 
end
 
 
rdata._table = rdata.type .. '_rewards'
 
rdata.type = nil
 
 
tpl_args[rdata._table] = rdata
 
 
m_cargo.store(frame, rdata)
 
 
-- TODO: Verify quests and quest ids?
 
end
 
 
rid = rid + 1
 
until continue == false
 
 
end
 
end
   
  +
--
  +
-- Processing
  +
--
   
function core.process_upgraded_from(tpl_args, frame)
+
function h.process_arguments(tpl_args, frame, params)
  +
tpl_args._processed_args = tpl_args._processed_args or {}
local query_data = {
 
id = {},
+
for _, k in ipairs(params) do
name = {},
+
local data = core.map[k]
page = {},
+
if data == nil then
  +
if tpl_args.debug then
}
 
  +
error(string.format(i18n.debug.invalid_argument_key, k))
local sets = {}
 
 
-- ------------------------------------------------------------------------
 
-- Manual data
 
-- ------------------------------------------------------------------------
 
local setid = #sets + 1
 
local set
 
repeat
 
local prefix = string.format('upgraded_from_set%s_', setid)
 
local groupid = 1
 
local group
 
set = {
 
groups = {},
 
text = m_util.cast.text(tpl_args[prefix .. 'text']),
 
automatic = false,
 
}
 
repeat
 
local group_prefix = string.format('%sgroup%s_', prefix, groupid)
 
group = {
 
item_name = tpl_args[group_prefix .. 'item_name'],
 
item_id = tpl_args[group_prefix .. 'item_id'],
 
item_page = tpl_args[group_prefix .. 'item_page'],
 
amount = tonumber(tpl_args[group_prefix .. 'amount']),
 
notes = m_util.cast.text(tpl_args[group_prefix .. 'notes']),
 
}
 
 
if group.item_name ~= nil or group.item_id ~= nil or group.item_page ~= nil then
 
if group.amount == nil then
 
error(string.format(i18n.errors.missing_amount, group_prefix .. 'amount'))
 
else
 
for key, array in pairs(query_data) do
 
local value = group['item_' .. key]
 
if value then
 
if array[value] then
 
table.insert(array[value], {setid, groupid})
 
else
 
array[value] = {{setid, groupid}, }
 
end
 
end
 
end
 
set.groups[#set.groups+1] = group
 
end
 
 
end
 
end
 
groupid = groupid + 1
 
until group.item_name == nil and group.item_id == nil and group.item_page == nil
 
 
-- set was empty, can terminate safely
 
if #set.groups == 0 then
 
set = nil
 
 
else
 
else
setid = setid + 1
+
if data.inherit ~= false then
  +
table.insert(tpl_args._base_item_args, k)
sets[#sets+1] = set
 
end
 
until set == nil
 
-- ------------------------------------------------------------------------
 
-- Automatic
 
-- ------------------------------------------------------------------------
 
 
--
 
-- maps
 
--
 
local automatic_index = #sets + 1
 
-- TODO: 3.9.0 Unsure how this works yet, so disabled for now
 
--[[if tpl_args.atlas_connections and tpl_args.rarity_id == "normal" then
 
local results = m_cargo.query(
 
{'items', 'maps'},
 
{'items._pageName', 'items.name'},
 
{
 
join='items._pageID=maps._pageID',
 
where=string.format('items.class_id = "Map" AND items.rarity_id = "normal" AND maps.tier < %s AND items._pageName IN ("%s")', tpl_args.map_tier, table.concat(tpl_args.atlas_connections, '", "')),
 
}
 
)
 
for _, row in ipairs(results) do
 
sets[#sets+1] = {
 
text = i18n.misc.upgraded_from_map,
 
groups = {
 
{
 
item_name = row['items.name'],
 
item_page = row['items._pageName'],
 
amount = 3,
 
notes = nil,
 
},
 
},
 
automatic = true,
 
}
 
end
 
end]]
 
 
--
 
-- oils
 
--
 
if tpl_args._flags.is_blight_item and tpl_args.blight_item_tier > 1 then
 
local results = m_cargo.query(
 
{'items', 'blight_items'},
 
{'items._pageName', 'items.name'},
 
{
 
join='items._pageID=blight_items._pageID',
 
where=string.format('blight_items.tier = %s', tpl_args.blight_item_tier - 1),
 
}
 
)
 
for _, row in ipairs(results) do
 
sets[#sets+1] = {
 
text = nil,
 
groups = {
 
{
 
item_name = row['items.name'],
 
item_page = row['items._pageName'],
 
amount = 3,
 
notes = nil,
 
},
 
},
 
automatic = true,
 
}
 
end
 
end
 
 
 
--
 
-- essences
 
--
 
 
-- exclude remnant of corruption via type
 
if tpl_args.is_essence and tpl_args.essence_type > 0 then
 
local results = m_cargo.query(
 
{'items', 'essences'},
 
{
 
'items._pageName',
 
'items.name',
 
'items.metadata_id',
 
'essences.category',
 
'essences.type',
 
},
 
{
 
join='items._pageID=essences._pageID',
 
where=string.format([[
 
(essences.category="%s" AND essences.level = %s)
 
OR (essences.type = %s AND essences.level = %s)
 
OR items.metadata_id = 'Metadata/Items/Currency/CurrencyCorruptMonolith'
 
OR (%s = 6 AND essences.type = 5 AND essences.level >= 5)
 
]],
 
tpl_args.essence_category, tpl_args.essence_level - 1,
 
tpl_args.essence_type - 1, tpl_args.essence_level,
 
-- special case for corruption only essences
 
tpl_args.essence_type
 
),
 
orderBy='essences.level ASC, essences.type ASC',
 
}
 
)
 
 
local remnant = results[1]
 
if remnant['items.metadata_id'] ~= 'Metadata/Items/Currency/CurrencyCorruptMonolith' then
 
error(string.format('Something went seriously wrong here. Got results: %s', mw.dumpObject(results)))
 
end
 
for i=2, #results do
 
local row = results[i]
 
if row['essences.category'] == tpl_args.essence_category then
 
-- 3 to 1 recipe
 
sets[#sets+1] = {
 
automatic = true,
 
text = nil,
 
groups = {
 
{
 
item_id = row['items.metadata_id'],
 
item_page = row['items._pageName'],
 
item_name = row['items.name'],
 
amount = 3,
 
},
 
},
 
}
 
-- corruption +1
 
sets[#sets+1] = {
 
automatic = true,
 
text = i18n.upgraded_from_tooltips.essence_plus_one_level,
 
groups = {
 
{
 
item_id = row['items.metadata_id'],
 
item_page = row['items._pageName'],
 
item_name = row['items.name'],
 
amount = 1,
 
},
 
{
 
item_id = remnant['items.metadata_id'],
 
item_page = remnant['items._pageName'],
 
item_name = remnant['items.name'],
 
amount = 1,
 
},
 
},
 
}
 
elseif tonumber(row['essences.type']) == tpl_args.essence_type - 1 then
 
-- corruption type change
 
sets[#sets+1] = {
 
automatic = true,
 
text = i18n.upgraded_from_tooltips.essence_type_change,
 
groups = {
 
{
 
item_id = row['items.metadata_id'],
 
item_page = row['items._pageName'],
 
item_name = row['items.name'],
 
amount = 1,
 
},
 
{
 
item_id = remnant['items.metadata_id'],
 
item_page = remnant['items._pageName'],
 
item_name = remnant['items.name'],
 
amount = 1,
 
},
 
},
 
}
 
 
end
 
end
end
+
if data.func ~= nil then
  +
tpl_args[k] = data.func(tpl_args, frame, tpl_args[k])
end
 
 
-- data based on mapping
 
if tpl_args.drop_enabled and not tpl_args.upgraded_from_disabled then
 
for _, data in ipairs(core.automatic_upgraded_from) do
 
data.defaults = data.defaults or {}
 
local continue = true
 
for key, value in pairs(core.automatic_upgraded_from_defaults) do
 
local func
 
local v = data.defaults[key]
 
if v == false then
 
-- check is disabled specifically, continue
 
elseif v == nil then
 
func = value
 
elseif type(v) == 'function' then
 
func = v
 
else
 
error(string.format('Invalid value for defaults at data %s', mw.dumpObject(data)))
 
end
 
if func then
 
continue = func(tpl_args, frame) and continue
 
if not continue then
 
break
 
end
 
end
 
 
end
 
end
for _, condition in ipairs(data.condition) do
+
if tpl_args[k] == nil then
continue = condition(tpl_args, frame) and continue
+
if tpl_args.class_id and tpl_args._item_config.defaults ~= nil and tpl_args._item_config.defaults[k] ~= nil then
if not continue then
+
-- Item defaults
break
+
tpl_args[k] = tpl_args._item_config.defaults[k]
end
+
elseif data.default ~= nil then
end
+
-- Generic defaults
  +
if type(data.default) == 'function' then
 
  +
tpl_args[k] = data.default(tpl_args, frame)
if continue then
 
sets[#sets+1] = {
 
automatic = true,
 
text = data.text(tpl_args, frame),
 
groups = data.groups,
 
}
 
for groupid, row in ipairs(data.groups) do
 
if query_data['id'][row.item_id] then
 
table.insert(query_data['id'][row.item_id], {#sets, groupid})
 
 
else
 
else
query_data['id'][row.item_id] = {{#sets, groupid}, }
+
tpl_args[k] = data.default
 
end
 
end
 
end
 
end
 
end
 
end
  +
tpl_args._processed_args[k] = true
end
 
end
 
 
if #sets == 0 then
 
return
 
end
 
--
 
-- Fetch item data in a single query to sacrifice database load with a lot of upgraded_from references
 
--
 
local query_data_array = {
 
id = {},
 
name = {},
 
page = {},
 
}
 
local query_fields = {
 
id = 'items.metadata_id',
 
page = 'items._pageName',
 
name = 'items.name',
 
}
 
local where = {}
 
local expected_count = 0
 
for key, thing_array in pairs(query_data) do
 
for thing, _ in pairs(thing_array) do
 
table.insert(query_data_array[key], thing)
 
end
 
if #query_data_array[key] > 0 then
 
expected_count = expected_count + #query_data_array[key]
 
local q_data = table.concat(query_data_array[key], '", "')
 
table.insert(where, string.format('%s IN ("%s")', query_fields[key], q_data))
 
end
 
end
 
local results = m_cargo.query(
 
{'items'},
 
{'items._pageName', 'items.name', 'items.metadata_id'},
 
{
 
where=table.concat(where, ' OR '),
 
}
 
)
 
 
for _, row in ipairs(results) do
 
for key, thing_array in pairs(query_data) do
 
local set_groups = thing_array[row[query_fields[key]]]
 
if set_groups then
 
for _, set_group in ipairs(set_groups) do
 
local entry = sets[set_group[1]].groups[set_group[2]]
 
for entry_key, data_key in pairs(query_fields) do
 
-- metadata_id may be nil, since we don't know them for unique items
 
if row[data_key] then
 
entry['item_' .. entry_key] = row[data_key]
 
end
 
end
 
end
 
-- set this to nil for error checking in later step
 
thing_array[row[query_fields[key]]] = nil
 
end
 
end
 
end
 
 
-- sbow the broken references if needed
 
if #results ~= expected_count then
 
-- query data was pruned of existing keys earlier, so only broken keys remain
 
for key, array in pairs(query_data) do
 
for thing, set_groups in pairs(array) do
 
for _, set_group in ipairs(set_groups) do
 
tpl_args._flags.broken_upgraded_from_reference = true
 
tpl_args._errors[#tpl_args._errors+1] = string.format(i18n.errors.upgraded_from_broken_reference, string.format('upgraded_from_set%s_group%s_item_%s', set_group[1], set_group[2], key), thing)
 
end
 
end
 
end
 
end
 
 
--
 
-- Check for duplicates
 
--
 
local delete_sets = {}
 
for i=automatic_index, #sets do
 
for j=1, automatic_index-1 do
 
if #sets[i].groups == #sets[j].groups then
 
local match = true
 
for row_id, row in ipairs(sets[i].groups) do
 
-- Only the fields from the database query are matched since we can be sure they're correct. Other fields may be subject to user error.
 
for _, key in ipairs({'item_id', 'item_name', 'item_page'}) do
 
match = match and (row[key] == sets[j].groups[row_id][key])
 
end
 
end
 
if match then
 
tpl_args._flags.duplicate_upgraded_from_reference = true
 
tpl_args._errors[#tpl_args._errors+1] = string.format(i18n.errors.upgraded_from_duplicate, j)
 
delete_sets[#delete_sets+1] = j
 
end
 
end
 
end
 
end
 
 
for offset, index in ipairs(delete_sets) do
 
table.remove(sets, index-(offset-1))
 
end
 
--
 
-- Set data
 
--
 
tpl_args.upgrade_from_sets = sets
 
 
-- set upgraded_from data
 
for i, set in ipairs(sets) do
 
tpl_args._subobjects[#tpl_args._subobjects+1] = {
 
_table = 'upgraded_from_sets',
 
set_id = i,
 
text = set.text,
 
automatic = set.automatic,
 
}
 
 
for j, group in ipairs(set.groups) do
 
tpl_args._subobjects[#tpl_args._subobjects+1] = {
 
_table = 'upgraded_from_groups',
 
group_id = j,
 
set_id = i,
 
item_name = group.item_name,
 
item_id = group.item_id,
 
item_page = group.item_page,
 
amount = group.amount,
 
notes = group.notes,
 
}
 
 
end
 
end
 
end
 
end
Строка 1464: Строка 230:
   
 
--
 
--
  +
-- Display
-- function factory
 
 
--
 
--
core.factory = {}
 
   
  +
function h.strip_random_stats(tpl_args, frame, stat_text, container_type)
function core.factory.cast_text(k, args)
 
  +
if tpl_args._flags.random_mods and container_type == 'inline' then
args = args or {}
 
  +
repeat
return function (tpl_args, frame)
 
  +
local text = string.match(stat_text, '<th class="mw%-customtoggle%-31">(.+)</th>')
tpl_args[args.key_out or k] = m_util.cast.text(tpl_args[k])
 
  +
if text ~= nil then
  +
stat_text = string.gsub(stat_text, '<table class="random%-modifier%-stats.+</table>', text, 1)
  +
end
  +
until text == nil
 
end
 
end
  +
return stat_text
 
end
 
end
   
  +
function h.add_to_container_from_map(tpl_args, frame, container, mapping, container_type)
function core.factory.display_value(args)
 
  +
local statcont = mw.html.create('span')
-- args:
 
  +
statcont
-- type: Type of the keys (nil = regular, gem = skill gems, stat = stats)
 
  +
:attr('class', 'item-stats')
-- options<Array>:
 
-- key: key to use
+
:done()
  +
local count = 0 -- Number of groups in container
-- allow_zero: allow zero values
 
  +
for _, group in ipairs(mapping) do
-- hide_default: hide the value if this is set
 
  +
local lines = {}
-- hide_default_key: key to use if it isn't equal to the key parameter
 
-- -- from m_util.html.format_value --
+
if group.func == nil then
-- fmt: formatter to use for the value instead of valfmt
+
for _, line in ipairs(group) do
-- fmt_range: formatter to use for the range values. Default: (%s to %s)
+
local show = true
  +
if container_type == 'inline' and line.inline == false then -- TODO: This is not used currently. Need to address what is hidden in inline view.
-- insert: insert results into this object
 
-- func: Function to adjust the value with before output
+
show = false
  +
elseif line.show == false then
-- color: colour code for m_util.html.poe_color, overrides mod colour
 
-- no_color: set to true to ingore colour entirely
+
show = false
  +
elseif type(line.show) == 'function' then
-- truncate: set to true to truncate the line
 
  +
show = line.show(tpl_args, frame, container_type)
 
for k, default in pairs({options = {}}) do
 
if args[k] == nil then
 
args[k] = default
 
end
 
end
 
 
return function (tpl_args, frame)
 
local base_values = {}
 
local temp_values = {}
 
if args.type == 'gem' then
 
if not core.class_groups.gems.keys[tpl_args.class_id] then
 
return
 
end
 
for i, data in ipairs(args.options) do
 
local value = tpl_args.skill_levels[0][data.key]
 
if value ~= nil then
 
base_values[#base_values+1] = value
 
temp_values[#temp_values+1] = {value={min=value,max=value}, index=i}
 
else
 
value = {
 
min=tpl_args.skill_levels[1][data.key],
 
max=tpl_args.skill_levels[tpl_args.max_level][data.key],
 
}
 
if value.min == nil or value.max == nil then
 
else
 
base_values[#base_values+1] = value.min
 
temp_values[#temp_values+1] = {value=value, index=i}
 
end
 
 
end
 
end
end
+
if show then
  +
lines[#lines+1] = line.func(tpl_args, frame, container_type)
elseif args.type == 'stat' then
 
for i, data in ipairs(args.options) do
 
local value = tpl_args._stats[data.key]
 
if value ~= nil then
 
base_values[i] = value.min
 
temp_values[#temp_values+1] = {value=value, index=i}
 
 
end
 
end
 
end
 
end
 
else
 
else
for i, data in ipairs(args.options) do
+
lines = group.func(tpl_args, frame, container_type)
base_values[i] = tpl_args[data.key]
 
local value = {}
 
if tpl_args[data.key .. '_range_minimum'] ~= nil then
 
value.min = tpl_args[data.key .. '_range_minimum']
 
value.max = tpl_args[data.key .. '_range_maximum']
 
elseif tpl_args[data.key] ~= nil then
 
value.min = tpl_args[data.key]
 
value.max = tpl_args[data.key]
 
end
 
if value.min == nil then
 
else
 
temp_values[#temp_values+1] = {value=value, index=i}
 
end
 
end
 
 
end
 
end
+
if #lines > 0 then
local final_values = {}
+
count = count + 1
for i, data in ipairs(temp_values) do
+
local heading = ''
local opt = args.options[data.index]
+
if group.heading == nil then
local insert = false
+
elseif type(group.heading) == 'function' then
if opt.hide_default == nil then
+
heading = group.heading()
insert = true
 
elseif opt.hide_default_key == nil then
 
local v = data.value
 
if opt.hide_default ~= v.min and opt.hide_default ~= v.max then
 
insert = true
 
end
 
 
else
 
else
local v = {
+
heading = string.format('<em class="header">%s</em><br>', group.heading)
min = tpl_args[opt.hide_default_key .. '_range_minimum'],
 
max = tpl_args[opt.hide_default_key .. '_range_maximum'],
 
}
 
if v.min == nil or v.max == nil then
 
if opt.hide_default ~= tpl_args[opt.hide_default_key] then
 
insert = true
 
end
 
elseif opt.hide_default ~= v.min and opt.hide_default ~= v.max then
 
insert = true
 
end
 
end
 
 
if insert == true then
 
table.insert(final_values, data)
 
 
end
 
end
end
+
statcont
+
:tag('span')
  +
:attr('class', 'group ' .. (group.class or ''))
-- all zeros = dont display and return early
 
  +
:wikitext(heading .. table.concat(lines, '<br>'))
if #final_values == 0 then
 
return nil
+
:done()
end
 
 
local out = {}
 
 
for i, data in ipairs(final_values) do
 
local value = data.value
 
value.base = base_values[data.index]
 
 
local options = args.options[data.index]
 
 
if options.color == nil and args.type == 'gem' then
 
value.color = 'value'
 
end
 
if options.truncate then
 
options.class = 'u-truncate-line'
 
end
 
 
out[#out+1] = m_util.html.format_value(tpl_args, frame, value, options)
 
end
 
 
if args.inline then
 
return m_util.html.poe_color(args.color or 'default', string.format(args.inline, unpack(out)))
 
else
 
return table.concat(out, '')
 
 
end
 
end
 
end
 
end
end
 
   
  +
-- Add groups to container
function core.factory.display_value_only(key)
 
  +
if count > 0 then
return function(tpl_args, frame)
 
return tpl_args[key]
+
container:node(statcont)
 
end
 
end
 
end
 
end
   
  +
function h.make_main_container(tpl_args, frame, container_type)
function core.factory.descriptor_value(args)
 
-- Arguments:
 
-- key
 
-- tbl
 
args = args or {}
 
return function (tpl_args, frame, value)
 
args.tbl = args.tbl or tpl_args
 
if args.tbl[args.key] then
 
value = m_util.html.abbr(value, args.tbl[args.key])
 
end
 
return value
 
end
 
end
 
 
function core.factory.damage_html(args)
 
return function(tpl_args, frame)
 
if args.key ~= 'physical' then
 
args.color = args.key
 
args.no_color = true
 
end
 
local keys = {
 
min=args.key .. '_damage_min',
 
max=args.key .. '_damage_max',
 
}
 
local value = {}
 
 
for ktype, key in pairs(keys) do
 
value[ktype] = core.factory.display_value{options={ [1] = {
 
key = key,
 
no_color = args.no_color,
 
hide_default = 0
 
}}}(tpl_args, frame)
 
end
 
 
if value.min and value.max then
 
value = value.min .. '&ndash;' .. value.max
 
if args.color ~= nil then
 
value = m_util.html.poe_color(args.color, value)
 
end
 
tpl_args[args.key .. '_damage_html'] = value
 
end
 
end
 
end
 
 
--
 
-- Display
 
--
 
core.display = {}
 
 
function core.display.make_main_container(tpl_args, frame, container_type)
 
 
local container = mw.html.create('span')
 
local container = mw.html.create('span')
 
:attr('class', 'item-box -' .. tpl_args.frame_type)
 
:attr('class', 'item-box -' .. tpl_args.frame_type)
Строка 1704: Строка 333:
 
else
 
else
 
local header_css
 
local header_css
  +
local line_type
 
if tpl_args.base_item and tpl_args.rarity_id ~= 'normal' then
 
if tpl_args.base_item and tpl_args.rarity_id ~= 'normal' then
 
line_type = 'double'
 
line_type = 'double'
Строка 1748: Строка 378:
 
:done()
 
:done()
 
 
core.display.add_to_container_from_map(tpl_args, frame, container, core.item_display_groups, container_type)
+
h.add_to_container_from_map(tpl_args, frame, container, c.item_infobox_groups, container_type)
 
end
 
end
 
 
Строка 1758: Строка 388:
 
end
 
end
   
  +
--
function core.display.add_to_container_from_map(tpl_args, frame, container, mapping, container_type)
 
  +
-- Factory
local grpcont
 
  +
--
local valid
 
local statcont = mw.html.create('span')
 
statcont
 
:attr('class', 'item-stats')
 
:done()
 
 
local count = 0
 
 
for _, group in ipairs(mapping) do
 
grpcont = {}
 
if group.func == nil then
 
for _, disp in ipairs(group) do
 
valid = true
 
if container_type == 'inline' and disp.inline == false then
 
valid = false
 
else
 
-- No args to verify which means always valid
 
if disp.args == nil then
 
elseif type(disp.args) == 'table' then
 
for _, key in ipairs(disp.args) do
 
if tpl_args[key] == nil then
 
valid = false
 
break
 
end
 
end
 
elseif type(disp.args) == 'function' then
 
valid = disp.args(tpl_args, frame, container_type)
 
end
 
end
 
if valid then
 
grpcont[#grpcont+1] = disp.func(tpl_args, frame, container_type)
 
end
 
end
 
else
 
grpcont = group.func(tpl_args, frame, container_type)
 
end
 
 
if #grpcont > 0 then
 
count = count + 1
 
local header = ''
 
if group.header == nil then
 
elseif type(group.header) == 'function' then
 
header = group.header()
 
else
 
header = string.format('<em class="header">%s</em><br>', group.header)
 
end
 
statcont
 
:tag('span')
 
:attr('class', 'group ' .. (group.css_class or ''))
 
:wikitext(header .. table.concat(grpcont, '<br>'))
 
:done()
 
end
 
end
 
 
-- Don't add empty containers
 
if count > 0 then
 
container:node(statcont)
 
end
 
end
 
   
  +
h.factory = {}
function core.display.strip_random_stats(tpl_args, frame, stat_text, container_type)
 
if tpl_args._flags.random_mods and container_type == 'inline' then
 
repeat
 
local text = string.match(stat_text, '<th class="mw%-customtoggle%-31">(.+)</th>')
 
if text ~= nil then
 
stat_text = string.gsub(stat_text, '<table class="random%-modifier%-stats.+</table>', text, 1)
 
end
 
until text == nil
 
end
 
return stat_text
 
end
 
   
  +
function h.factory.maybe_show_infobox_line(args)
--
 
  +
-- Verifies that a list of keys are present in tpl_args and that the item
-- argument mapping
 
  +
-- should use those keys. Returns true if all conditions are met, otherwise
--
 
  +
-- returns false.
-- format:
 
  +
return function (tpl_args)
-- tpl_args key = {
 
  +
local keys = args.keys or {}
-- no_copy = true or nil -- When loading an base item, dont copy this key
 
  +
local conditions = args.conditions or {}
-- property = 'prop', -- Property associated with this key
 
  +
if #keys == 0 then
-- property_func = function or nil -- Function to unpack the property into a native lua value.
 
-- If not specified, func is used.
 
-- If neither is specified, value is copied as string
 
-- func = function or nil -- Function to unpack the argument into a native lua value and validate it.
 
-- If not specified, value will not be set.
 
-- default = object -- Default value if the parameter is nil
 
-- }
 
core.map = {
 
-- special params
 
html = {
 
no_copy = true,
 
field = 'html',
 
type = 'Text',
 
func = nil,
 
},
 
html_extra = {
 
no_copy = true,
 
field = 'html_extra',
 
type = 'Text',
 
func = nil,
 
},
 
implicit_stat_text = {
 
field = 'implicit_stat_text',
 
type = 'Text',
 
func = function(tpl_args, frame)
 
tpl_args.implicit_stat_text = core.process_mod_stats(tpl_args, {is_implicit=true})
 
end,
 
},
 
explicit_stat_text = {
 
field = 'explicit_stat_text',
 
type = 'Text',
 
func = function(tpl_args, frame)
 
tpl_args.explicit_stat_text = core.process_mod_stats(tpl_args, {is_implicit=false})
 
 
if tpl_args.is_talisman or tpl_args.is_corrupted then
 
if tpl_args.explicit_stat_text == nil or tpl_args.explicit_stat_text == '' then
 
tpl_args.explicit_stat_text = i18n.tooltips.corrupted
 
else
 
tpl_args.explicit_stat_text = (tpl_args.explicit_stat_text or '') .. '<br>' .. i18n.tooltips.corrupted
 
end
 
end
 
end,
 
},
 
stat_text = {
 
field = 'stat_text',
 
type = 'Text',
 
func = function(tpl_args, frame)
 
local sep = ''
 
if tpl_args.implicit_stat_text and tpl_args.explicit_stat_text then
 
sep = string.format('<span class="item-stat-separator -%s"></span>', tpl_args.frame_type)
 
end
 
local text = (tpl_args.implicit_stat_text or '') .. sep .. (tpl_args.explicit_stat_text or '')
 
 
if string.len(text) > 0 then
 
tpl_args.stat_text = text
 
end
 
end,
 
},
 
class = {
 
no_copy = true,
 
field = 'class',
 
type = 'String',
 
func = function (tpl_args, frame)
 
tpl_args.class = m_game.constants.item.classes[tpl_args.class_id]['long_upper']
 
-- Avoids errors with empty item class names later on
 
if tpl_args.class == '' then
 
tpl_args.class = nil
 
end
 
end,
 
},
 
-- processed in core.build_item_classes
 
class_id = {
 
no_copy = true,
 
field = 'class_id',
 
type = 'String',
 
func = function (tpl_args, frame)
 
if m_game.constants.item.classes[tpl_args.class_id] == nil then
 
error(string.format(i18n.errors.invalid_class_id, tostring(tpl_args.class_id)))
 
end
 
end
 
},
 
-- generic
 
rarity_id = {
 
no_copy = true,
 
field = 'rarity_id',
 
type = 'String',
 
func = function (tpl_args, frame)
 
if m_game.constants.rarities[tpl_args.rarity_id] == nil then
 
error(string.format(i18n.errors.invalid_rarity_id, tostring(tpl_args.rarity_id)))
 
end
 
end
 
},
 
rarity = {
 
no_copy = true,
 
field = 'rarity',
 
type = 'String',
 
func = function(tpl_args, frame)
 
tpl_args.rarity = m_game.constants.rarities[tpl_args.rarity_id]['long_upper']
 
end
 
},
 
name = {
 
no_copy = true,
 
field = 'name',
 
type = 'String',
 
func = nil,
 
},
 
size_x = {
 
field = 'size_x',
 
type = 'Integer',
 
func = m_util.cast.factory.number('size_x'),
 
},
 
size_y = {
 
field = 'size_y',
 
type = 'Integer',
 
func = m_util.cast.factory.number('size_y'),
 
},
 
drop_rarities_ids = {
 
no_copy = true,
 
field = 'drop_rarity_ids',
 
type = 'List (,) of Text',
 
func = function(tpl_args, frame)
 
tpl_args.drop_rarities_ids = nil
 
if true then return end
 
-- Drop rarities only matter for base items.
 
if tpl_args.rarity_id ~= 'normal' then
 
return
 
end
 
 
if tpl_args.drop_rarities_ids == nil then
 
tpl_args.drop_rarities_ids = {}
 
return
 
end
 
 
tpl_args.drop_rarities_ids = m_util.string.split(tpl_args.drop_rarities_ids, ',%s*')
 
for _, rarity_id in ipairs(tpl_args.drop_rarities_ids) do
 
if m_game.constants.rarities[rarity_id] == nil then
 
error(string.format(i18n.errors.invalid_rarity_id, tostring(rarity_id)))
 
end
 
end
 
end,
 
},
 
drop_rarities = {
 
no_copy = true,
 
field = nil,
 
type = 'List (,) of Text',
 
func = function(tpl_args, frame)
 
tpl_args.drop_rarities = nil
 
if true then return end
 
-- Drop rarities only matter for base items.
 
if tpl_args.rarity_id ~= 'normal' then
 
return
 
end
 
 
local rarities = {}
 
for _, rarity_id in ipairs(tpl_args.drop_rarities_ids) do
 
rarities[#rarities+1] = m_game.constants.rarities[rarity_id].full
 
end
 
tpl_args.drop_rarities = rarities
 
end,
 
},
 
drop_enabled = {
 
no_copy = true,
 
field = 'drop_enabled',
 
type = 'Boolean',
 
func = m_util.cast.factory.boolean('drop_enabled'),
 
default = true,
 
},
 
drop_level = {
 
no_copy = true,
 
field = 'drop_level',
 
type = 'Integer',
 
func = m_util.cast.factory.number('drop_level'),
 
},
 
drop_level_maximum = {
 
no_copy = true,
 
field = 'drop_level_maximum',
 
type = 'Integer',
 
func = m_util.cast.factory.number('drop_level_maximum'),
 
},
 
drop_leagues = {
 
no_copy = true,
 
field = 'drop_leagues',
 
type = 'List (,) of String',
 
func = m_util.cast.factory.assoc_table('drop_leagues', {tbl=m_game.constants.leagues, errmsg=i18n.errors.invalid_league}),
 
},
 
drop_areas = {
 
no_copy = true,
 
field = 'drop_areas',
 
type = 'List (,) of String',
 
func = function(tpl_args, frame)
 
if tpl_args.drop_areas ~= nil then
 
tpl_args.drop_areas = m_util.string.split(tpl_args.drop_areas, ',%s*')
 
tpl_args.drop_areas_data = m_cargo.array_query{
 
tables={'areas'},
 
fields={'areas._pageName', 'areas.id', 'areas.name', 'areas.main_page'},
 
id_field='areas.id',
 
id_array=tpl_args.drop_areas,
 
query={limit=5000},
 
}
 
end
 
 
-- find areas based on item tags for atlas bases
 
local query_data
 
for _, tag in ipairs(tpl_args.tags or {}) do
 
query_data = nil
 
if string.match(tag, '[%w_]*atlas[%w_]*') ~= nil and tag ~= 'atlas_base_type' then
 
query_data = m_cargo.query(
 
{'atlas_maps', 'maps', 'areas', 'atlas_base_item_types'},
 
{'areas._pageName', 'areas.id', 'areas.name', 'areas.main_page'},
 
{
 
join='atlas_maps._pageID=maps._pageID, maps.area_id=areas.id, atlas_maps.region_id=atlas_base_item_types.region_id',
 
where=string.format([[
 
atlas_base_item_types.tag = "%s"
 
AND atlas_base_item_types.weight > 0
 
AND (
 
atlas_maps.map_tier0 >= tier_min AND atlas_maps.map_tier0 <= atlas_base_item_types.tier_max
 
OR atlas_maps.map_tier1 >= tier_min AND atlas_maps.map_tier1 <= atlas_base_item_types.tier_max
 
OR atlas_maps.map_tier2 >= tier_min AND atlas_maps.map_tier2 <= atlas_base_item_types.tier_max
 
OR atlas_maps.map_tier3 >= tier_min AND atlas_maps.map_tier3 <= atlas_base_item_types.tier_max
 
OR atlas_maps.map_tier4 >= tier_min AND atlas_maps.map_tier4 <= atlas_base_item_types.tier_max
 
)]],
 
tag),
 
groupBy='areas.id',
 
}
 
)
 
end
 
 
if query_data ~= nil then
 
-- in case no manual drop areas have been set
 
if tpl_args.drop_areas == nil then
 
tpl_args.drop_areas = {}
 
tpl_args.drop_areas_data = {}
 
end
 
local drop_areas_assoc = {}
 
for _, id in ipairs(tpl_args.drop_areas) do
 
drop_areas_assoc[id] = true
 
end
 
 
local duplicates = {}
 
 
for _, row in ipairs(query_data) do
 
if drop_areas_assoc[row['areas.id']] == nil then
 
tpl_args.drop_areas[#tpl_args.drop_areas+1] = row['areas.id']
 
tpl_args.drop_areas_data[#tpl_args.drop_areas_data+1] = row
 
else
 
duplicates[#duplicates+1] = row['areas.id']
 
end
 
end
 
 
if #duplicates > 0 then
 
tpl_args._errors[#tpl_args._errors+1] = string.format(i18n.errors.duplicate_area_id_from_query, table.concat(duplicates, ', '))
 
tpl_args._flags.duplicate_query_area_ids = true
 
end
 
end
 
end
 
end,
 
},
 
drop_monsters = {
 
no_copy = true,
 
field = 'drop_monsters',
 
type = 'List (,) of Text',
 
func = function (tpl_args, frame)
 
if tpl_args.drop_monsters ~= nil then
 
tpl_args.drop_monsters = m_util.string.split(tpl_args.drop_monsters, ',%s*')
 
end
 
end,
 
},
 
drop_text = {
 
no_copy = true,
 
field = 'drop_text',
 
type = 'Text',
 
func = core.factory.cast_text('drop_text'),
 
},
 
required_level = {
 
field = 'required_level_base',
 
type = 'Integer',
 
func = m_util.cast.factory.number('required_level'),
 
default = 1,
 
},
 
required_level_final = {
 
field = 'required_level',
 
type = 'Integer',
 
func = function(tpl_args, frame)
 
tpl_args.required_level_final = tpl_args.required_level
 
end,
 
default = 1,
 
},
 
required_dexterity = {
 
field = 'required_dexterity',
 
type = 'Integer',
 
func = m_util.cast.factory.number('required_dexterity'),
 
default = 0,
 
},
 
required_strength = {
 
field = 'required_strength',
 
type = 'Integer',
 
func = m_util.cast.factory.number('required_strength'),
 
default = 0,
 
},
 
required_intelligence = {
 
field = 'required_intelligence',
 
type = 'Integer',
 
func = m_util.cast.factory.number('required_intelligence'),
 
default = 0,
 
},
 
inventory_icon = {
 
no_copy = true,
 
field = 'inventory_icon',
 
type = 'String',
 
func = function(tpl_args, frame)
 
if tpl_args.class_id == 'DivinationCard' then
 
tpl_args.inventory_icon = tpl_args.inventory_icon or 'Divination card'
 
end
 
tpl_args.inventory_icon_id = tpl_args.inventory_icon or tpl_args.name
 
tpl_args.inventory_icon = string.format(i18n.inventory_icon, tpl_args.inventory_icon_id)
 
end,
 
},
 
-- note: this must be called after inventory item to work correctly as it depends on tpl_args.inventory_icon_id being set
 
alternate_art_inventory_icons = {
 
no_copy = true,
 
field = 'alternate_art_inventory_icons',
 
type = 'List (,) of String',
 
func = function(tpl_args, frame)
 
local icons = {}
 
if tpl_args.alternate_art_inventory_icons ~= nil then
 
local names = m_util.string.split(tpl_args.alternate_art_inventory_icons, ',%s*')
 
 
for _, name in ipairs(names) do
 
icons[#icons+1] = string.format(i18n.inventory_icon, string.format('%s %s', tpl_args.inventory_icon_id, name))
 
end
 
end
 
tpl_args.alternate_art_inventory_icons = icons
 
end,
 
default = function (tpl_args, frame) return {} end,
 
},
 
cannot_be_traded_or_modified = {
 
no_copy = true,
 
field = 'cannot_be_traded_or_modified',
 
type = 'Boolean',
 
func = m_util.cast.factory.boolean('cannot_be_traded_or_modified'),
 
default = false,
 
},
 
help_text = {
 
debug_ignore_nil = true,
 
field = 'help_text',
 
type = 'Text',
 
func = core.factory.cast_text('help_text'),
 
},
 
flavour_text = {
 
no_copy = true,
 
field = 'flavour_text',
 
type = 'Text',
 
func = core.factory.cast_text('flavour_text'),
 
},
 
flavour_text_id = {
 
no_copy = true,
 
field = 'flavour_text_id',
 
type = 'String',
 
func = nil,
 
},
 
tags = {
 
field = 'tags',
 
type = 'List (,) of String',
 
func = m_util.cast.factory.assoc_table('tags', {
 
tbl = m_game.constants.tags,
 
errmsg = i18n.errors.invalid_tag,
 
}),
 
},
 
metadata_id = {
 
no_copy = true,
 
field = 'metadata_id',
 
type = 'String',
 
--type = 'String(unique; size=200)',
 
func = function(tpl_args, frame)
 
if tpl_args.metadata_id == nil then
 
return
 
end
 
local results = m_cargo.query(
 
{'items'},
 
{'items._pageName'},
 
{
 
where=string.format('items.metadata_id="%s" AND items._pageName != "%s"', tpl_args.metadata_id, mw.title.getCurrentTitle().fullText)
 
}
 
)
 
if #results > 0 and tpl_args.debug_id == nil and not tpl_args.debug then
 
error(string.format(i18n.errors.duplicate_metadata, tpl_args.metadata_id, results[1]['items._pageName']))
 
end
 
end,
 
},
 
influences = {
 
no_copy = true,
 
field = 'influences',
 
type = 'List (,) of String',
 
func = m_util.cast.factory.assoc_table('influences', {
 
tbl = m_game.constants.influences,
 
errmsg = i18n.errors.invalid_influence,
 
}),
 
},
 
is_fractured = {
 
no_copy = true,
 
field = 'is_fractured',
 
type = 'Boolean',
 
func = m_util.cast.factory.boolean('is_fractured'),
 
default = false,
 
},
 
is_synthesised = {
 
no_copy = true,
 
field = 'is_synthesised',
 
type = 'Boolean',
 
func = m_util.cast.factory.boolean('is_synthesised'),
 
default = false,
 
},
 
is_veiled = {
 
no_copy = true,
 
field = 'is_veiled',
 
type = 'Boolean',
 
func = m_util.cast.factory.boolean('is_veiled'),
 
default = false,
 
},
 
is_replica = {
 
no_copy = true,
 
field = 'is_replica',
 
type = 'Boolean',
 
func = function(tpl_args, frame)
 
m_util.cast.factory.boolean('is_replica')(tpl_args, frame)
 
if tpl_args.is_replica == true and tpl_args.rarity_id ~= 'unique' then
 
error(string.format(i18n.errors.non_unique_flag, 'is_replica'))
 
end
 
end,
 
default = false,
 
},
 
is_corrupted = {
 
no_copy = true,
 
field = 'is_corrupted',
 
type = 'Boolean',
 
func = m_util.cast.factory.boolean('is_corrupted'),
 
default = false,
 
},
 
is_relic = {
 
no_copy = true,
 
field = 'is_relic',
 
type = 'Boolean',
 
func = function(tpl_args, frame)
 
m_util.cast.factory.boolean('is_relic')(tpl_args, frame)
 
if tpl_args.is_relic == true and tpl_args.rarity_id ~= 'unique' then
 
error(string.format(i18n.errors.non_unique_flag, 'is_relic'))
 
end
 
end,
 
default = false,
 
},
 
is_fated = {
 
no_copy = true,
 
field = 'is_fated',
 
type = 'Boolean',
 
func = function(tpl_args, frame)
 
m_util.cast.factory.boolean('is_fated')(tpl_args, frame)
 
if tpl_args.is_fated == true and tpl_args.rarity_id ~= 'unique' then
 
error(string.format(i18n.errors.non_unique_flag, 'is_fated'))
 
end
 
end,
 
default = false,
 
},
 
is_prophecy = {
 
no_copy = true,
 
field = nil,
 
type = nil,
 
func = function(tpl_args, frame)
 
tpl_args._flags.is_prophecy = (tpl_args.metadata_id == 'Metadata/Items/Currency/CurrencyItemisedProphecy' or tpl_args.base_item == 'Пророчество' or tpl_args.base_item_page == 'Пророчество' or tpl_args.base_item_id == 'Metadata/Items/Currency/CurrencyItemisedProphecy')
 
end
 
},
 
is_blight_item = {
 
no_copy = true,
 
field = nil,
 
type = nil,
 
func = function(tpl_args, frame)
 
tpl_args._flags.is_blight_item = (tpl_args.blight_item_tier ~= nil)
 
end
 
},
 
is_drop_restricted = {
 
no_copy = true,
 
field = 'is_drop_restricted',
 
type = 'Boolean',
 
func = m_util.cast.factory.boolean('is_drop_restricted'),
 
default = function(tpl_args, frame)
 
-- Generally items that are obtained only from specific monsters can't be obtained via cards or other means unless specifically specified
 
for _, var in ipairs({'is_talisman', 'is_fated', 'is_relic', 'drop_monsters'}) do
 
if tpl_args[var] then
 
return true
 
end
 
end
 
for _, flag in ipairs({'is_prophecy', 'is_blight_item'}) do
 
if tpl_args._flags[flag] then
 
return true
 
end
 
end
 
 
return false
 
return false
end,
 
},
 
purchase_costs = {
 
func = function(tpl_args, frame)
 
local purchase_costs = {}
 
for _, rarity_id in ipairs(m_game.constants.rarity_order) do
 
local rtbl = {}
 
local prefix = string.format('purchase_cost_%s', rarity_id)
 
local i = 1
 
while i ~= -1 do
 
local iprefix = prefix .. i
 
local values = {
 
name = tpl_args[iprefix .. '_name'],
 
amount = tonumber(tpl_args[iprefix .. '_amount']),
 
rarity = rarity_id,
 
}
 
if values.name ~= nil and values.amount ~= nil then
 
rtbl[#rtbl+1] = values
 
i = i + 1
 
 
tpl_args._subobjects[#tpl_args._subobjects+1] = {
 
_table = 'item_purchase_costs',
 
amount = values.amount,
 
name = values.name,
 
rarity = values.rarity,
 
}
 
else
 
i = -1
 
end
 
end
 
 
purchase_costs[rarity_id] = rtbl
 
end
 
 
tpl_args.purchase_costs = purchase_costs
 
end,
 
func_fetch = function(tpl_args, frame)
 
if tpl_args.rarity_id ~= 'unique' then
 
return
 
end
 
 
local results = m_cargo.query(
 
{'items' ,'item_purchase_costs'},
 
{'item_purchase_costs.amount', 'item_purchase_costs.name', 'item_purchase_costs.rarity'},
 
{
 
join = 'items._pageID=item_purchase_costs._pageID',
 
where = string.format('items._pageName="%s" AND item_purchase_costs.rarity="unique"', tpl_args.base_item_page),
 
}
 
)
 
 
for _, row in ipairs(results) do
 
local values = {
 
rarity = row['item_purchase_costs.rarity'],
 
name = row['item_purchase_costs.name'],
 
amount = tonumber(row['item_purchase_costs.amount']),
 
}
 
local datavar = tpl_args.purchase_costs[string.lower(values.rarity)]
 
datavar[#datavar+1] = values
 
 
tpl_args._subobjects[#tpl_args._subobjects+1] = {
 
_table = 'item_purchase_costs',
 
amount = values.amount,
 
name = values.name,
 
rarity = values.rarity,
 
}
 
end
 
end,
 
},
 
sell_prices_override = {
 
no_copy = true,
 
func = function(tpl_args, frame)
 
-- these variables are also used by mods when setting automatic sell prices
 
tpl_args.sell_prices = {}
 
tpl_args.sell_price_order = {}
 
 
 
local name
 
local amount
 
local i = 0
 
repeat
 
i = i + 1
 
name = tpl_args[string.format('sell_price%s_name', i)]
 
amount = tpl_args[string.format('sell_price%s_amount', i)]
 
 
if name ~= nil and amount ~= nil then
 
tpl_args.sell_price_order[#tpl_args.sell_price_order+1] = name
 
tpl_args.sell_prices[name] = amount
 
tpl_args._subobjects[#tpl_args._subobjects+1] = {
 
_table = 'item_sell_prices',
 
amount = amount,
 
name = name,
 
}
 
end
 
until name == nil or amount == nil
 
 
-- if sell prices are set, the override is active
 
for _, _ in pairs(tpl_args.sell_prices) do
 
tpl_args._flags.sell_prices_override = true
 
break
 
end
 
end,
 
},
 
--
 
-- specific section
 
--
 
 
-- Most item classes
 
quality = {
 
no_copy = true,
 
field = 'quality',
 
type = 'Integer',
 
-- Can be set manually, but default to Q20 for unique weapons/body armours
 
-- Also must copy to stat for the stat adjustments to work properly
 
func = function(tpl_args, frame)
 
local quality = tonumber(tpl_args.quality)
 
--
 
if quality == nil then
 
if tpl_args.rarity_id ~= 'unique' then
 
quality = 0
 
elseif core.class_groups.weapons.keys[tpl_args.class_id] or core.class_groups.armor.keys[tpl_args.class_id] then
 
quality = 20
 
else
 
quality = 0
 
end
 
end
 
 
tpl_args.quality = quality
 
 
local stat = {
 
min = quality,
 
max = quality,
 
avg = quality,
 
}
 
 
h.stats_update(tpl_args, 'quality', stat, nil, '_stats')
 
 
if tpl_args.class_id == 'UtilityFlask' or tpl_args.class_id == 'UtilityFlaskCritical' then
 
h.stats_update(tpl_args, 'quality_flask_duration', stat, nil, '_stats')
 
-- quality is added to quantity for maps
 
elseif tpl_args.class_id == 'Map' then
 
h.stats_update(tpl_args, 'map_item_drop_quantity_+%', stat, nil, '_stats')
 
end
 
end,
 
},
 
-- amulets
 
is_talisman = {
 
field = 'is_talisman',
 
type = 'Boolean',
 
func = m_util.cast.factory.boolean('is_talisman'),
 
default = false,
 
},
 
 
talisman_tier = {
 
field = 'talisman_tier',
 
type = 'Integer',
 
func = m_util.cast.factory.number('talisman_tier'),
 
},
 
 
-- flasks
 
charges_max = {
 
field = 'charges_max',
 
type = 'Integer',
 
func = m_util.cast.factory.number('charges_max'),
 
},
 
charges_per_use = {
 
field = 'charges_per_use',
 
type = 'Integer',
 
func = m_util.cast.factory.number('charges_per_use'),
 
},
 
flask_mana = {
 
field = 'mana',
 
type = 'Integer',
 
func = m_util.cast.factory.number('flask_mana'),
 
},
 
flask_life = {
 
field = 'life',
 
type = 'Integer',
 
func = m_util.cast.factory.number('flask_life'),
 
},
 
flask_duration = {
 
field = 'duration',
 
type = 'Float',
 
func = m_util.cast.factory.number('flask_duration'),
 
},
 
buff_id = {
 
field = 'id',
 
type = 'String',
 
func = nil,
 
},
 
buff_values = {
 
field = 'buff_values',
 
type = 'List (,) of Integer',
 
func = function(tpl_args, frame)
 
local values = {}
 
local i = 0
 
repeat
 
i = i + 1
 
local key = 'buff_value' .. i
 
values[i] = tonumber(tpl_args[key])
 
tpl_args[key] = nil
 
until values[i] == nil
 
 
-- needed so the values copyied from unique item base isn't overriden
 
if #values >= 1 then
 
tpl_args.buff_values = values
 
end
 
end,
 
func_copy = function(tpl_args, frame)
 
tpl_args.buff_values = m_util.string.split(tpl_args.buff_values, ',%s*')
 
end,
 
default = function (tpl_args, frame) return {} end,
 
},
 
buff_stat_text = {
 
field = 'stat_text',
 
type = 'String',
 
func = nil,
 
},
 
buff_icon = {
 
field = 'icon',
 
type = 'String',
 
func = function(tpl_args, frame)
 
tpl_args.buff_icon = string.format(i18n.status_icon, tpl_args.name)
 
end,
 
},
 
 
-- weapons
 
critical_strike_chance = {
 
field = 'critical_strike_chance',
 
type = 'Float',
 
func = m_util.cast.factory.number('critical_strike_chance'),
 
},
 
attack_speed = {
 
field = 'attack_speed',
 
type = 'Float',
 
func = m_util.cast.factory.number('attack_speed'),
 
},
 
weapon_range = {
 
field = 'weapon_range',
 
type = 'Integer',
 
func = m_util.cast.factory.number('weapon_range'),
 
},
 
physical_damage_min = {
 
field = 'physical_damage_min',
 
type = 'Integer',
 
func = m_util.cast.factory.number('physical_damage_min'),
 
},
 
physical_damage_max = {
 
field = 'physical_damage_max',
 
type = 'Integer',
 
func = m_util.cast.factory.number('physical_damage_max'),
 
},
 
fire_damage_min = {
 
field = 'fire_damage_min',
 
type = 'Integer',
 
func = m_util.cast.factory.number('fire_damage_min'),
 
default = 0,
 
},
 
fire_damage_max = {
 
field = 'fire_damage_max',
 
type = 'Integer',
 
func = m_util.cast.factory.number('fire_damage_max'),
 
default = 0,
 
},
 
cold_damage_min = {
 
field = 'cold_damage_min',
 
type = 'Integer',
 
func = m_util.cast.factory.number('cold_damage_min'),
 
default = 0,
 
},
 
cold_damage_max = {
 
field = 'cold_damage_max',
 
type = 'Integer',
 
func = m_util.cast.factory.number('cold_damage_max'),
 
default = 0,
 
},
 
lightning_damage_min = {
 
field = 'lightning_damage_min',
 
type = 'Integer',
 
func = m_util.cast.factory.number('lightning_damage_min'),
 
default = 0,
 
},
 
lightning_damage_max = {
 
field = 'lightning_damage_max',
 
type = 'Integer',
 
func = m_util.cast.factory.number('lightning_damage_max'),
 
default = 0,
 
},
 
chaos_damage_min = {
 
field = 'chaos_damage_min',
 
type = 'Integer',
 
func = m_util.cast.factory.number('chaos_damage_min'),
 
default = 0,
 
},
 
chaos_damage_max = {
 
field = 'chaos_damage_max',
 
type = 'Integer',
 
func = m_util.cast.factory.number('chaos_damage_max'),
 
default = 0,
 
},
 
-- armor-type stuff
 
armour = {
 
field = 'armour',
 
type = 'Integer',
 
func = m_util.cast.factory.number('armour'),
 
default = 0,
 
},
 
energy_shield = {
 
field = 'energy_shield',
 
type = 'Integer',
 
func = m_util.cast.factory.number('energy_shield'),
 
default = 0,
 
},
 
evasion = {
 
field = 'evasion',
 
type = 'Integer',
 
func = m_util.cast.factory.number('evasion'),
 
default = 0,
 
},
 
-- This is the inherent penality from the armour piece if any
 
movement_speed = {
 
field = 'movement_speed',
 
type = 'Integer',
 
func = m_util.cast.factory.number('movement_speed'),
 
default = 0,
 
},
 
-- shields
 
block = {
 
field = 'block',
 
type = 'Integer',
 
func = m_util.cast.factory.number('block'),
 
},
 
-- skill gem stuff
 
gem_description = {
 
field = 'gem_description',
 
type = 'Text',
 
func = core.factory.cast_text('gem_description'),
 
},
 
dexterity_percent = {
 
field = 'dexterity_percent',
 
type = 'Integer',
 
func = m_util.cast.factory.percentage('dexterity_percent'),
 
},
 
strength_percent = {
 
field = 'strength_percent',
 
type = 'Integer',
 
func = m_util.cast.factory.percentage('strength_percent'),
 
},
 
intelligence_percent = {
 
field = 'intelligence_percent',
 
type = 'Integer',
 
func = m_util.cast.factory.percentage('intelligence_percent'),
 
},
 
primary_attribute = {
 
field = 'primary_attribute',
 
type = 'String',
 
func = function(tpl_args, frame)
 
for _, attr in ipairs(m_game.constants.attribute_order) do
 
local val = tpl_args[attr .. '_percent']
 
if val and val >= 60 then
 
tpl_args['primary_attribute'] = attr
 
return
 
end
 
end
 
tpl_args['primary_attribute'] = 'none'
 
end,
 
},
 
gem_tags = {
 
field = 'gem_tags',
 
type = 'List (,) of String',
 
-- TODO: default rework
 
func = function(tpl_args, frame)
 
if tpl_args.gem_tags then
 
tpl_args.gem_tags = m_util.string.split(tpl_args.gem_tags, ',%s*')
 
end
 
end,
 
default = function (tpl_args, frame) return {} end,
 
},
 
-- Support gems only
 
support_gem_letter = {
 
field = 'support_gem_letter',
 
type = 'String(size=1)',
 
func = nil,
 
},
 
support_gem_letter_html = {
 
field = 'support_gem_letter_html',
 
type = 'Text',
 
func = function(tpl_args, frame)
 
if tpl_args.support_gem_letter == nil then
 
return
 
end
 
 
-- TODO replace this with a loop possibly
 
local css_map = {
 
strength = 'red',
 
intelligence = 'blue',
 
dexterity = 'green',
 
}
 
local id
 
for k, v in pairs(css_map) do
 
k = string.format('%s_percent', k)
 
if tpl_args[k] and tpl_args[k] > 50 then
 
id = v
 
break
 
end
 
end
 
 
if id ~= nil then
 
local container = mw.html.create('span')
 
container
 
:attr('class', string.format('support-gem-id-%s', id))
 
:wikitext(tpl_args.support_gem_letter)
 
:done()
 
tpl_args.support_gem_letter_html = tostring(container)
 
end
 
end,
 
},
 
--
 
-- Maps
 
--
 
map_tier = {
 
field = 'tier',
 
type = 'Integer',
 
func = m_util.cast.factory.number('map_tier'),
 
},
 
map_guild_character = {
 
field = 'guild_character',
 
type = 'String(size=1)',
 
func = nil,
 
},
 
map_area_id = {
 
field = 'area_id',
 
type = 'String',
 
func = nil, -- TODO: Validate against a query?
 
},
 
map_area_level = {
 
field = 'area_level',
 
type = 'Integer',
 
func = m_util.cast.factory.number('map_area_level'),
 
},
 
unique_map_guild_character = {
 
field = 'unique_guild_character',
 
type = 'String(size=1)',
 
func_copy = function(tpl_args, frame)
 
tpl_args.map_guild_character = tpl_args.unique_map_guild_character
 
end,
 
func = nil,
 
},
 
unique_map_area_id = {
 
field = 'unique_area_id',
 
type = 'String',
 
func = nil, -- TODO: Validate against a query?
 
func_copy = function(tpl_args, frame)
 
tpl_args.map_area_id = tpl_args.unique_map_area_id
 
end,
 
},
 
unique_map_area_level = {
 
field = 'unique_area_level',
 
type = 'Integer',
 
func = m_util.cast.factory.number('unique_map_area_level'),
 
func_copy = function(tpl_args, frame)
 
tpl_args.map_area_level = tpl_args.unique_map_area_level
 
end,
 
},
 
map_series = {
 
field = 'series',
 
type = 'String',
 
func = function(tpl_args, frame)
 
if tpl_args.rarity == 'normal' and tpl_args.map_series == nil then
 
error(string.format(i18n.errors.generic_required_parameter, 'map_series'))
 
end
 
end,
 
},
 
-- atlas info is only for the current map series
 
atlas_x = {
 
field = 'x',
 
type = 'Float',
 
func = m_util.cast.factory.number('atlas_x'),
 
},
 
atlas_y = {
 
field = 'y',
 
type = 'Float',
 
func = m_util.cast.factory.number('atlas_y'),
 
},
 
atlas_region_id = {
 
field = 'region_id',
 
type = 'String',
 
func = nil,
 
},
 
atlas_region_minimum = {
 
field = 'region_minimum',
 
type = 'Integer',
 
func = m_util.cast.factory.number('atlas_region_minimum'),
 
},
 
atlas_x0 = {
 
field = 'x0',
 
type = 'Float',
 
func = m_util.cast.factory.number('atlas_x0'),
 
},
 
atlas_x1 = {
 
field = 'x1',
 
type = 'Float',
 
func = m_util.cast.factory.number('atlas_x1'),
 
},
 
atlas_x2 = {
 
field = 'x2',
 
type = 'Float',
 
func = m_util.cast.factory.number('atlas_x2'),
 
},
 
atlas_x3 = {
 
field = 'x3',
 
type = 'Float',
 
func = m_util.cast.factory.number('atlas_x3'),
 
},
 
atlas_x4 = {
 
field = 'x4',
 
type = 'Float',
 
func = m_util.cast.factory.number('atlas_x4'),
 
},
 
atlas_y0 = {
 
field = 'y0',
 
type = 'Float',
 
func = m_util.cast.factory.number('atlas_0'),
 
},
 
atlas_y1 = {
 
field = 'y1',
 
type = 'Float',
 
func = m_util.cast.factory.number('atlas_y1'),
 
},
 
atlas_y2 = {
 
field = 'y2',
 
type = 'Float',
 
func = m_util.cast.factory.number('atlas_y2'),
 
},
 
atlas_y3 = {
 
field = 'y3',
 
type = 'Float',
 
func = m_util.cast.factory.number('atlas_y3'),
 
},
 
atlas_y4 = {
 
field = 'y4',
 
type = 'Float',
 
func = m_util.cast.factory.number('atlas_y4'),
 
},
 
atlas_map_tier0 = {
 
field = 'map_tier0',
 
type = 'Integer',
 
func = m_util.cast.factory.number('atlas_map_tier0'),
 
},
 
atlas_map_tier1 = {
 
field = 'map_tier1',
 
type = 'Integer',
 
func = m_util.cast.factory.number('atlas_map_tier1'),
 
},
 
atlas_map_tier2 = {
 
field = 'map_tier2',
 
type = 'Integer',
 
func = m_util.cast.factory.number('atlas_map_tier2'),
 
},
 
atlas_map_tier3 = {
 
field = 'map_tier3',
 
type = 'Integer',
 
func = m_util.cast.factory.number('atlas_map_tier3'),
 
},
 
atlas_map_tier4 = {
 
field = 'map_tier4',
 
type = 'Integer',
 
func = m_util.cast.factory.number('atlas_map_tier4'),
 
},
 
atlas_connections = {
 
field = nil,
 
type = nil,
 
func = function(tpl_args, frame)
 
tpl_args.atlas_connections = {}
 
 
local cont = true
 
local i = 1
 
while cont do
 
local prefix = string.format('atlas_connection%s_', i)
 
local regions = tpl_args[prefix .. 'tier']
 
local data = {
 
_table = 'atlas_connections',
 
map1 = string.format('%s (%s)', tpl_args.name, tpl_args.map_series or ''),
 
map2 = tpl_args[prefix .. 'target'],
 
}
 
 
if regions and data.map2 then
 
regions = m_util.string.split(regions, ',%s*')
 
if #regions ~= 5 then
 
error(string.format(i18n.errors.invalid_region_upgrade_count, i, #regions))
 
end
 
for index, value in ipairs(regions) do
 
data['region' .. (index - 1)] = m_util.cast.boolean(value)
 
end
 
 
tpl_args.atlas_connections[data.map2] = data
 
table.insert(tpl_args._subobjects, data)
 
else
 
cont = false
 
if i == 1 then
 
tpl_args.atlas_connections = nil
 
end
 
end
 
 
i = i + 1
 
end
 
end,
 
default = nil,
 
},
 
--
 
-- Currency-like items
 
--
 
stack_size = {
 
field = 'stack_size',
 
type = 'Integer',
 
func = m_util.cast.factory.number('stack_size'),
 
},
 
stack_size_currency_tab = {
 
field = 'stack_size_currency_tab',
 
type = 'Integer',
 
func = m_util.cast.factory.number('stack_size_currency_tab'),
 
},
 
description = {
 
field = 'description',
 
type = 'Text',
 
func = core.factory.cast_text('description'),
 
},
 
cosmetic_type = {
 
field = 'cosmetic_type',
 
type = 'String',
 
func = core.factory.cast_text('cosmetic_type'),
 
},
 
-- for essences
 
is_essence = {
 
field = nil,
 
func = m_util.cast.factory.boolean('is_essence'),
 
default = false,
 
},
 
essence_level_restriction = {
 
field = 'level_restriction',
 
type = 'Integer',
 
func = m_util.cast.factory.number('essence_level_restriction'),
 
},
 
essence_level = {
 
field = 'level',
 
type = 'Integer',
 
func = m_util.cast.factory.number('essence_level'),
 
},
 
essence_type = {
 
field = 'type',
 
type = 'Integer',
 
func = m_util.cast.factory.number('essence_type'),
 
},
 
essence_category = {
 
field = 'category',
 
type = 'String',
 
func = nil,
 
},
 
-- blight crafting items (i.e. oils)
 
blight_item_tier = {
 
field = 'tier',
 
type = 'Integer',
 
func = m_util.cast.factory.number('blight_item_tier'),
 
},
 
-- harvest seeds
 
seed_type_id = {
 
field = 'type_id',
 
type = 'String',
 
},
 
seed_type = {
 
field = 'type',
 
type = 'String',
 
func = function (tpl_args, frame)
 
if tpl_args.seed_type_id ~= 'none' or tpl_args.seed_type_id ~= nil then
 
tpl_args.seed_type = m_game.seed_types[tpl_args.seed_type_id]
 
end
 
 
end
 
end
  +
for _, k in ipairs(keys) do
},
 
  +
if tpl_args[k] == nil then
seed_type_html = {
 
field = nil,
+
return false
type = nil,
 
func = function (tpl_args, frame)
 
if tpl_args.seed_type ~= nil then
 
tpl_args.seed_type_html = m_util.html.poe_color(tpl_args.seed_type_id, tpl_args.seed_type)
 
 
end
 
end
end
+
local t = type(tpl_args[k])
  +
if (t == 'table' or t == 'string') and #tpl_args[k] == 0 then
},
 
  +
return false
seed_effect = {
 
field = 'effect',
 
type = 'Text',
 
},
 
seed_tier = {
 
field = 'tier',
 
type = 'Integer',
 
func = m_util.cast.factory.number('seed_tier'),
 
},
 
seed_growth_cycles = {
 
field = 'growth_cycles',
 
type = 'Integer',
 
func = m_util.cast.factory.number('seed_growth_cycles'),
 
},
 
seed_required_nearby_seed_tier = {
 
field = 'required_nearby_seed_tier',
 
type = 'Integer',
 
func = m_util.cast.factory.number('seed_required_nearby_seed_tier'),
 
},
 
seed_required_nearby_seed_amount = {
 
field = 'required_nearby_seed_amount',
 
type = 'Integer',
 
func = m_util.cast.factory.number('seed_required_nearby_seed_amount'),
 
},
 
seed_consumed_wild_lifeforce_percentage = {
 
field = 'consumed_wild_lifeforce_percentage',
 
type = 'Integer',
 
func = m_util.cast.factory.number('seed_consumed_wild_lifeforce_percentage'),
 
default = 0,
 
},
 
seed_consumed_vivid_lifeforce_percentage = {
 
field = 'consumed_vivid_lifeforce_percentage',
 
type = 'Integer',
 
func = m_util.cast.factory.number('seed_consumed_vivid_lifeforce_percentage'),
 
default = 0,
 
},
 
seed_consumed_primal_lifeforce_percentage = {
 
field = 'consumed_primal_lifeforce_percentage',
 
type = 'Integer',
 
func = m_util.cast.factory.number('seed_consumed_primal_lifeforce_percentage'),
 
default = 0,
 
},
 
seed_granted_craft_option_ids = {
 
field = 'granted_craft_option_ids',
 
type = 'List (,) of String',
 
func = m_util.cast.factory.number('seed_grandted_craft_option_ids'),
 
default = 0,
 
},
 
--
 
-- harvest planet boosters
 
--
 
plant_booster_radius = {
 
field = 'radius',
 
type = 'Integer',
 
func = m_util.cast.factory.number('plant_booster_radius'),
 
},
 
plant_booster_lifeforce = {
 
field = 'lifeforce',
 
type = 'Integer',
 
func = m_util.cast.factory.number('plant_booster_lifeforce'),
 
},
 
plant_booster_additional_crafting_options = {
 
field = 'additional_crafting_options',
 
type = 'Integer',
 
func = m_util.cast.factory.number('plant_booster_additional_crafting_options'),
 
},
 
plant_booster_extra_chances = {
 
field = 'extra_chances',
 
type = 'Integer',
 
func = m_util.cast.factory.number('plant_booster_extra_chances'),
 
},
 
--
 
-- Heist properties
 
--
 
heist_required_job_id = {
 
field = 'required_job_id',
 
type = 'String',
 
func = core.factory.cast_text('heist_required_job_id'),
 
},
 
heist_required_job_level = {
 
field = 'required_job_level',
 
type = 'Integer',
 
func = m_util.cast.factory.number('heist_required_job_level'),
 
},
 
heist_data = {
 
func = function (tpl_args, frame)
 
if tpl_args.heist_required_job_level then
 
if tpl_args.heist_required_job_id then
 
local results = m_cargo.query(
 
{'heist_jobs', 'heist_npcs', 'heist_npc_skills'},
 
{'heist_npcs.name', 'heist_jobs.name'},
 
{
 
join = 'heist_npc_skills.job_id=heist_jobs.id, heist_npc_skills.npc_id=heist_npcs.id',
 
where = string.format('heist_npc_skills.job_id = "%s" AND heist_npc_skills.level >= %s', tpl_args.heist_required_job_id, tpl_args.heist_required_job_level),
 
}
 
)
 
 
local npcs = {}
 
 
for _, row in ipairs(results) do
 
npcs[#npcs+1] = row['heist_npcs.name']
 
end
 
 
tpl_args.heist_required_npcs = table.concat(npcs, ', ')
 
tpl_args.heist_required_job = results[1]['heist_jobs.name']
 
else
 
tpl_args.heist_required_job = i18n.tooltips.heist_any_job
 
end
 
 
end
 
end
  +
if conditions.processed == true and tpl_args._processed_args[k] == nil then
end,
 
  +
return false
},
 
--
 
-- hideout doodads (HideoutDoodads.dat)
 
--
 
is_master_doodad = {
 
field = 'is_master_doodad',
 
type = 'Boolean',
 
func = m_util.cast.factory.boolean('is_master_doodad'),
 
},
 
master = {
 
field = 'master',
 
type = 'String',
 
-- todo validate against list of master names
 
func = m_util.cast.factory.table('master', {key='full', tbl=m_game.constants.masters}),
 
},
 
master_level_requirement = {
 
field = 'level_requirement',
 
type = 'Integer',
 
func = m_util.cast.factory.number('master_level_requirement'),
 
},
 
master_favour_cost = {
 
field = 'favour_cost',
 
type = 'Integer',
 
func = m_util.cast.factory.number('master_favour_cost'),
 
},
 
variation_count = {
 
field = 'variation_count',
 
type = 'Integer',
 
func = m_util.cast.factory.number('variation_count'),
 
},
 
-- Propehcy
 
prophecy_id = {
 
field = 'prophecy_id',
 
type = 'String',
 
func = nil,
 
},
 
prediction_text = {
 
field = 'prediction_text',
 
type = 'Text',
 
func = core.factory.cast_text('prediction_text'),
 
},
 
seal_cost = {
 
field = 'seal_cost',
 
type = 'Integer',
 
func = m_util.cast.factory.number('seal_cost'),
 
},
 
prophecy_reward = {
 
field = 'reward',
 
type = 'Text',
 
func = core.factory.cast_text('prophecy_reward'),
 
},
 
prophecy_objective = {
 
field = 'objective',
 
type = 'Text',
 
func = core.factory.cast_text('prophecy_objective'),
 
},
 
-- Divination cards
 
card_art = {
 
field = 'card_art',
 
type = 'Page',
 
func = function(tpl_args, frame)
 
tpl_args.card_art = string.format(i18n.divination_card_art, tpl_args.card_art or tpl_args.name)
 
end,
 
},
 
-- ------------------------------------------------------------------------
 
-- derived stats
 
-- ------------------------------------------------------------------------
 
 
-- For rarity != normal, rarity already verified
 
base_item = {
 
no_copy = true,
 
field = 'base_item',
 
type = 'String',
 
func = function(tpl_args, frame)
 
tpl_args.base_item = tpl_args.base_item_data['items.name']
 
end,
 
},
 
base_item_id = {
 
no_copy = true,
 
field = 'base_item_id',
 
type = 'String',
 
func = function(tpl_args, frame)
 
tpl_args.base_item_id = tpl_args.base_item_data['items.metadata_id']
 
end,
 
},
 
base_item_page = {
 
no_copy = true,
 
field = 'base_item_page',
 
type = 'Page',
 
func = function(tpl_args, frame)
 
tpl_args.base_item_page = tpl_args.base_item_data['items._pageName']
 
end,
 
},
 
name_list = {
 
no_copy = true,
 
field = 'name_list',
 
type = 'List (�) of String',
 
func = function(tpl_args, frame)
 
if tpl_args.name_list ~= nil then
 
tpl_args.name_list = m_util.string.split(tpl_args.name_list, ',%s*')
 
tpl_args.name_list[#tpl_args.name_list+1] = tpl_args.name
 
else
 
tpl_args.name_list = {tpl_args.name}
 
end
 
end,
 
},
 
frame_type = {
 
no_copy = true,
 
field = 'frame_type',
 
type = 'String',
 
property = nil,
 
func = function(tpl_args, frame)
 
if tpl_args._flags.is_prophecy then
 
tpl_args.frame_type = 'prophecy'
 
return
 
end
 
 
local var = core.class_specifics[tpl_args.class_id]
 
if var ~= nil and var.frame_type ~= nil then
 
tpl_args.frame_type = var.frame_type
 
return
 
end
 
 
if tpl_args.is_relic then
 
tpl_args.frame_type = 'relic'
 
return
 
end
 
 
tpl_args.frame_type = tpl_args.rarity_id
 
end,
 
},
 
--
 
-- args populated by mod validation
 
--
 
mods = {
 
default = function (tpl_args, frame) return {} end,
 
func_fetch = function (tpl_args, frame)
 
local results = m_cargo.query(
 
{'items' ,'item_mods'},
 
{'item_mods.id', 'item_mods.is_implicit', 'item_mods.is_random', 'item_mods.text'},
 
{
 
join = 'items._pageID=item_mods._pageID',
 
where = string.format('items._pageName="%s" AND item_mods.is_implicit=1', tpl_args.base_item_page),
 
}
 
)
 
for _, row in ipairs(results) do
 
-- Handle text-only mods
 
local result
 
if row['item_mods.id'] == nil then
 
result = row['item_mods.text']
 
end
 
tpl_args._mods[#tpl_args._mods+1] = {
 
result=result,
 
id=row['item_mods.id'],
 
stat_text=row['item_mods.text'],
 
is_implicit=m_util.cast.boolean(row['item_mods.is_implicit']),
 
is_random=m_util.cast.boolean(row['item_mods.is_random']),
 
}
 
end
 
end,
 
},
 
physical_damage_html = {
 
no_copy = true,
 
field = 'physical_damage_html',
 
type = 'Text',
 
func = core.factory.damage_html{key='physical'},
 
},
 
fire_damage_html = {
 
no_copy = true,
 
field = 'fire_damage_html',
 
type = 'Text',
 
func = core.factory.damage_html{key='fire'},
 
},
 
cold_damage_html = {
 
no_copy = true,
 
field = 'cold_damage_html',
 
type = 'Text',
 
func = core.factory.damage_html{key='cold'},
 
},
 
lightning_damage_html = {
 
no_copy = true,
 
field = 'lightning_damage_html',
 
type = 'Text',
 
func = core.factory.damage_html{key='lightning'},
 
},
 
chaos_damage_html = {
 
no_copy = true,
 
field = 'chaos_damage_html',
 
type = 'Text',
 
func = core.factory.damage_html{key='chaos'},
 
},
 
damage_avg = {
 
no_copy = true,
 
field = 'damage_avg',
 
type = 'Text',
 
func = function(tpl_args, frame)
 
local dmg = {min=0, max=0}
 
for key, _ in pairs(dmg) do
 
for _, dkey in ipairs(m_game.constants.damage_type_order) do
 
dmg[key] = dmg[key] + tpl_args[string.format('%s_damage_%s_range_average', dkey, key)]
 
end
 
end
 
 
dmg = (dmg.min + dmg.max) / 2
 
 
tpl_args.damage_avg = dmg
 
end,
 
},
 
damage_html = {
 
no_copy = true,
 
field = 'damage_html',
 
type = 'Text',
 
func = function(tpl_args, frame)
 
local text = {}
 
for _, dkey in ipairs(m_game.constants.damage_type_order) do
 
local value = tpl_args[dkey .. '_damage_html']
 
if value ~= nil then
 
text[#text+1] = value
 
end
 
end
 
if #text > 0 then
 
tpl_args.damage_html = table.concat(text, '<br>')
 
end
 
end,
 
},
 
item_limit = {
 
no_copy = true,
 
field = 'item_limit',
 
type = 'Integer',
 
func = m_util.cast.factory.number('item_limit'),
 
},
 
jewel_radius_html = {
 
no_copy = true,
 
field = 'radius_html',
 
type = 'Text',
 
func = function(tpl_args, frame)
 
local radius = tpl_args._stats.local_jewel_effect_base_radius
 
if radius then
 
radius = radius.min
 
tpl_args.jewel_radius_html = string.format('%s (%i)', (m_game.constants.item.jewel_radius_to_size[radius] or '?'), radius)
 
end
 
end,
 
},
 
incubator_effect = {
 
no_copy = true,
 
field = 'effect',
 
type = 'Text',
 
func = nil,
 
},
 
drop_areas_html = {
 
no_copy = true,
 
field = 'drop_areas_html',
 
type = 'Text',
 
func = function(tpl_args, frame)
 
if tpl_args.drop_areas_data == nil then
 
return
 
end
 
 
if tpl_args.drop_areas_html ~= nil then
 
return
 
end
 
 
local areas = {}
 
for _, data in pairs(tpl_args.drop_areas_data) do
 
-- skip legacy maps in the drop html listing
 
if not string.match(data['areas.id'], '^Map.*') or string.match(data['areas.id'], '^MapWorlds.*') or string.match(data['areas.id'], '^MapAtziri.*') then
 
areas[#areas+1] = string.format('[[%s|%s]]', data['areas.main_page'] or data['areas._pageName'], data['areas.main_page'] or data['areas.name'])
 
end
 
end
 
 
tpl_args.drop_areas_html = table.concat(areas, ' • ')
 
end,
 
},
 
release_version = {
 
no_copy = true,
 
field = 'release_version',
 
type = 'String'
 
},
 
removal_version = {
 
no_copy = true,
 
field = 'removal_version',
 
type = 'String',
 
},
 
--
 
-- args governing use of the template itself
 
--
 
suppress_improper_modifiers_category = {
 
no_copy = true,
 
field = nil,
 
func = m_util.cast.factory.boolean('suppress_improper_modifiers_category'),
 
default = false,
 
},
 
upgraded_from_disabled = {
 
no_copy = true,
 
field = nil,
 
func = m_util.cast.factory.boolean('upgraded_from_disabled'),
 
default = false,
 
},
 
}
 
 
core.stat_map = {
 
required_level_final = {
 
field = 'required_level',
 
stats_add = {
 
'local_level_requirement_+',
 
},
 
stats_override = {
 
['local_unique_tabula_rasa_no_requirement_or_energy_shield'] = {min=1, max=1},
 
},
 
minimum = 1,
 
html_fmt_options = {
 
fmt = '%i',
 
},
 
},
 
weapon_range = {
 
field = 'weapon_range',
 
stats_add = {
 
'local_weapon_range_+',
 
},
 
minimum = 0,
 
html_fmt_options = {
 
fmt = '%i',
 
},
 
},
 
physical_damage_min = {
 
field = 'physical_damage_min',
 
stats_add = {
 
'local_minimum_added_physical_damage',
 
},
 
stats_increased = {
 
'local_physical_damage_+%',
 
'quality',
 
},
 
stats_override = {
 
['local_weapon_no_physical_damage'] = {min=0, max=0},
 
},
 
minimum = 0,
 
html_fmt_options = {
 
fmt = '%i',
 
},
 
},
 
physical_damage_max = {
 
field = 'physical_damage_max',
 
stats_add = {
 
'local_maximum_added_physical_damage',
 
},
 
stats_increased = {
 
'local_physical_damage_+%',
 
'quality',
 
},
 
stats_override = {
 
['local_weapon_no_physical_damage'] = {min=0, max=0},
 
},
 
minimum = 0,
 
html_fmt_options = {
 
fmt = '%i',
 
},
 
},
 
fire_damage_min = {
 
field = 'fire_damage_min',
 
stats_add = {
 
'local_minimum_added_fire_damage',
 
},
 
minimum = 0,
 
html_fmt_options = {
 
color = 'fire',
 
fmt = '%i',
 
},
 
},
 
fire_damage_max = {
 
field = 'fire_damage_max',
 
stats_add = {
 
'local_maximum_added_fire_damage',
 
},
 
minimum = 0,
 
html_fmt_options = {
 
color = 'fire',
 
fmt = '%i',
 
},
 
},
 
cold_damage_min = {
 
field = 'cold_damage_min',
 
stats_add = {
 
'local_minimum_added_cold_damage',
 
},
 
minimum = 0,
 
html_fmt_options = {
 
color = 'cold',
 
fmt = '%i',
 
},
 
},
 
cold_damage_max = {
 
field = 'cold_damage_max',
 
stats_add = {
 
'local_maximum_added_cold_damage',
 
},
 
minimum = 0,
 
html_fmt_options = {
 
color = 'cold',
 
fmt = '%i',
 
},
 
},
 
lightning_damage_min = {
 
field = 'lightning_damage_min',
 
stats_add = {
 
'local_minimum_added_lightning_damage',
 
},
 
minimum = 0,
 
html_fmt_options = {
 
color = 'lightning',
 
fmt = '%i',
 
},
 
},
 
lightning_damage_max = {
 
field = 'lightning_damage_max',
 
stats_add = {
 
'local_maximum_added_lightning_damage',
 
},
 
minimum = 0,
 
html_fmt_options = {
 
color = 'lightning',
 
fmt = '%i',
 
},
 
},
 
chaos_damage_min = {
 
field = 'chaos_damage_min',
 
stats_add = {
 
'local_minimum_added_chaos_damage',
 
},
 
minimum = 0,
 
html_fmt_options = {
 
color = 'chaos',
 
fmt = '%i',
 
},
 
},
 
chaos_damage_max = {
 
field = 'chaos_damage_max',
 
stats_add = {
 
'local_maximum_added_chaos_damage',
 
},
 
minimum = 0,
 
html_fmt_options = {
 
color = 'chaos',
 
fmt = '%i',
 
},
 
},
 
critical_strike_chance = {
 
field = 'critical_strike_chance',
 
stats_add = {
 
'local_critical_strike_chance',
 
},
 
stats_increased = {
 
'local_critical_strike_chance_+%',
 
},
 
stats_override = {
 
['local_weapon_always_crit'] = {min=100, max=100},
 
},
 
minimum = 0,
 
html_fmt_options = {
 
fmt = '%.2f%%',
 
},
 
},
 
attack_speed = {
 
field = 'attack_speed',
 
stats_increased = {
 
'local_attack_speed_+%',
 
},
 
minimum = 0,
 
html_fmt_options = {
 
fmt = '%.2f',
 
},
 
},
 
flask_life = {
 
field = 'life',
 
stats_add = {
 
'local_flask_life_to_recover',
 
},
 
stats_increased = {
 
'local_flask_life_to_recover_+%',
 
'local_flask_amount_to_recover_+%',
 
'quality',
 
},
 
html_fmt_options = {
 
fmt = '%i',
 
},
 
},
 
flask_mana = {
 
field = 'mana',
 
stats_add = {
 
'local_flask_mana_to_recover',
 
},
 
stats_increased = {
 
'local_flask_mana_to_recover_+%',
 
'local_flask_amount_to_recover_+%',
 
'quality',
 
},
 
},
 
flask_duration = {
 
field = 'duration',
 
stats_increased = {
 
'local_flask_duration_+%',
 
-- regular quality isn't used here because it doesn't increase duration of life/mana/hybrid flasks
 
'quality_flask_duration',
 
},
 
stats_increased_inverse = {
 
'local_flask_recovery_speed_+%',
 
},
 
minimum = 0,
 
html_fmt_options = {
 
fmt = '%.2f',
 
},
 
},
 
charges_per_use = {
 
field = 'charges_per_use',
 
stats_increased = {
 
'local_charges_used_+%',
 
},
 
minimum = 0,
 
html_fmt_options = {
 
fmt = '%i',
 
},
 
},
 
charges_max = {
 
field = 'charges_max',
 
stats_add = {
 
'local_extra_max_charges',
 
},
 
stats_increased = {
 
'local_max_charges_+%',
 
},
 
minimum = 0,
 
html_fmt_options = {
 
fmt = '%i',
 
},
 
},
 
block = {
 
field = 'block',
 
stats_add = {
 
'local_additional_block_chance_%',
 
},
 
minimum = 0,
 
html_fmt_options = {
 
fmt = '%i%%',
 
},
 
},
 
armour = {
 
field = 'armour',
 
stats_add = {
 
'local_base_physical_damage_reduction_rating',
 
},
 
stats_increased = {
 
'local_physical_damage_reduction_rating_+%',
 
'local_armour_and_energy_shield_+%',
 
'local_armour_and_evasion_+%',
 
'local_armour_and_evasion_and_energy_shield_+%',
 
'quality',
 
},
 
minimum = 0,
 
html_fmt_options = {
 
fmt = '%i',
 
},
 
},
 
evasion = {
 
field = 'evasion',
 
stats_add = {
 
'local_base_evasion_rating',
 
'local_evasion_rating_and_energy_shield',
 
},
 
stats_increased = {
 
'local_evasion_rating_+%',
 
'local_evasion_and_energy_shield_+%',
 
'local_armour_and_evasion_+%',
 
'local_armour_and_evasion_and_energy_shield_+%',
 
'quality',
 
},
 
minimum = 0,
 
html_fmt_options = {
 
fmt = '%i',
 
},
 
},
 
energy_shield = {
 
field = 'energy_shield',
 
stats_add = {
 
'local_energy_shield',
 
'local_evasion_rating_and_energy_shield',
 
},
 
stats_increased = {
 
'local_energy_shield_+%',
 
'local_armour_and_energy_shield_+%',
 
'local_evasion_and_energy_shield_+%',
 
'local_armour_and_evasion_and_energy_shield_+%',
 
'quality',
 
},
 
stats_override = {
 
['local_unique_tabula_rasa_no_requirement_or_energy_shield'] = {min=0, max=0},
 
},
 
minimum = 0,
 
html_fmt_options = {
 
fmt = '%i',
 
},
 
},
 
required_dexterity = {
 
field = 'required_dexterity',
 
stats_add = {
 
'local_dexterity_requirement_+'
 
},
 
stats_increased = {
 
'local_dexterity_requirement_+%',
 
'local_attribute_requirements_+%',
 
},
 
stats_override = {
 
['local_unique_tabula_rasa_no_requirement_or_energy_shield'] = {min=0, max=0},
 
['local_no_attribute_requirements'] = {min=0, max=0},
 
},
 
minimum = 0,
 
html_fmt_options = {
 
fmt = '%i',
 
},
 
},
 
required_intelligence = {
 
field = 'required_intelligence',
 
stats_add = {
 
'local_intelligence_requirement_+'
 
},
 
stats_increased = {
 
'local_intelligence_requirement_+%',
 
'local_attribute_requirements_+%',
 
},
 
stats_override = {
 
['local_unique_tabula_rasa_no_requirement_or_energy_shield'] = {min=0, max=0},
 
['local_no_attribute_requirements'] = {min=0, max=0},
 
},
 
minimum = 0,
 
html_fmt_options = {
 
fmt = '%i',
 
},
 
},
 
required_strength = {
 
field = 'required_strength',
 
stats_add = {
 
'local_strength_requirement_+'
 
},
 
stats_increased = {
 
'local_strength_requirement_+%',
 
'local_attribute_requirements_+%',
 
},
 
stats_override = {
 
['local_unique_tabula_rasa_no_requirement_or_energy_shield'] = {min=0, max=0},
 
['local_no_attribute_requirements'] = {min=0, max=0},
 
},
 
minimum = 0,
 
html_fmt_options = {
 
fmt = '%i',
 
},
 
},
 
map_area_level = {
 
field = 'map_area_level',
 
stats_override = {
 
['map_item_level_override'] = true,
 
},
 
},
 
}
 
 
core.dps_map = {
 
{
 
name = 'physical_dps',
 
field = 'physical_dps',
 
damage_args = {'physical_damage', },
 
label_infobox = i18n.tooltips.physical_dps,
 
html_fmt_options = {
 
color = 'value',
 
fmt = '%.1f',
 
},
 
},
 
{
 
name = 'fire_dps',
 
field = 'fire_dps',
 
damage_args = {'fire_damage'},
 
label_infobox = i18n.tooltips.fire_dps,
 
html_fmt_options = {
 
color = 'fire',
 
fmt = '%.1f',
 
},
 
},
 
{
 
name = 'cold_dps',
 
field = 'cold_dps',
 
damage_args = {'cold_damage'},
 
label_infobox = i18n.tooltips.cold_dps,
 
html_fmt_options = {
 
color = 'cold',
 
fmt = '%.1f',
 
},
 
},
 
{
 
name = 'lightning_dps',
 
field = 'lightning_dps',
 
damage_args = {'lightning_damage'},
 
label_infobox = i18n.tooltips.lightning_dps,
 
html_fmt_options = {
 
color = 'lightning',
 
fmt = '%.1f',
 
},
 
},
 
{
 
name = 'chaos_dps',
 
field = 'chaos_dps',
 
damage_args = {'chaos_damage'},
 
label_infobox = i18n.tooltips.chaos_dps,
 
html_fmt_options = {
 
color = 'chaos',
 
fmt = '%.1f',
 
},
 
},
 
{
 
name = 'elemental_dps',
 
field = 'elemental_dps',
 
damage_args = {'fire_damage', 'cold_damage', 'lightning_damage'},
 
label_infobox = i18n.tooltips.elemental_dps,
 
html_fmt_options = {
 
color = 'value',
 
fmt = '%.1f',
 
},
 
},
 
{
 
name = 'poison_dps',
 
field = 'poison_dps',
 
damage_args = {'physical_damage', 'chaos_damage'},
 
label_infobox = i18n.tooltips.poison_dps,
 
html_fmt_options = {
 
color = 'value',
 
fmt = '%.1f',
 
},
 
},
 
{
 
name = 'dps',
 
field = 'dps',
 
damage_args = {'physical_damage', 'fire_damage', 'cold_damage', 'lightning_damage', 'chaos_damage'},
 
label_infobox = i18n.tooltips.dps,
 
html_fmt_options = {
 
color = 'value',
 
fmt = '%.1f',
 
},
 
},
 
}
 
 
core.cargo = {}
 
core.cargo.items = {
 
table = 'items',
 
fields = {
 
html = core.map.html,
 
html_extra = core.map.html_extra,
 
implicit_stat_text = core.map.implicit_stat_text,
 
explicit_stat_text = core.map.explicit_stat_text,
 
stat_text = core.map.stat_text,
 
class = core.map.class,
 
class_id = core.map.class_id,
 
rarity = core.map.rarity,
 
rarity_id = core.map.rarity_id,
 
name = core.map.name,
 
size_x = core.map.size_x,
 
size_y = core.map.size_y,
 
drop_enabled = core.map.drop_enabled,
 
drop_level = core.map.drop_level,
 
drop_level_maximum = core.map.drop_level_maximum,
 
drop_leagues = core.map.drop_leagues,
 
drop_areas = core.map.drop_areas,
 
drop_areas_html = core.map.drop_areas_html,
 
drop_monsters = core.map.drop_monsters,
 
drop_text = core.map.drop_text,
 
-- sightly different because of strange DB issues
 
drop_rarity_ids = core.map.drop_rarities_ids,
 
required_level = core.map.required_level,
 
required_level_final = core.map.required_level_final,
 
required_dexterity = core.map.required_dexterity,
 
required_strength = core.map.required_strength,
 
required_intelligence = core.map.required_intelligence,
 
inventory_icon = core.map.inventory_icon,
 
alternate_art_inventory_icons = core.map.alternate_art_inventory_icons,
 
buff_icon = core.map.buff_icon,
 
cannot_be_traded_or_modified = core.map.cannot_be_traded_or_modified,
 
help_text = core.map.help_text,
 
flavour_text = core.map.flavour_text,
 
flavour_text_id = core.map.flavour_text_id,
 
tags = core.map.tags,
 
metadata_id = core.map.metadata_id,
 
influences = core.map.influences,
 
is_fractured = core.map.is_fractured,
 
is_synthesised = core.map.is_synthesised,
 
is_veiled = core.map.is_veiled,
 
is_replica = core.map.is_replica,
 
is_corrupted = core.map.is_corrupted,
 
is_relic = core.map.is_relic,
 
is_fated = core.map.is_fated,
 
is_drop_restricted = core.map.is_drop_restricted,
 
quality = core.map.quality,
 
base_item = core.map.base_item,
 
base_item_id = core.map.base_item_id,
 
base_item_page = core.map.base_item_page,
 
frame_type = core.map.frame_type,
 
name_list = core.map.name_list,
 
description = core.map.description,
 
release_version = core.map.release_version,
 
removal_version = core.map.removal_version,
 
},
 
}
 
 
core.cargo.item_sell_prices = {
 
table = 'item_sell_prices',
 
fields = {
 
amount = {
 
field = 'amount',
 
type = 'Integer',
 
},
 
name = {
 
field = 'name',
 
type = 'String',
 
},
 
},
 
}
 
 
 
core.cargo.item_purchase_costs = {
 
table = 'item_purchase_costs',
 
fields = {
 
amount = {
 
field = 'amount',
 
type = 'Integer',
 
},
 
name = {
 
field = 'name',
 
type = 'String',
 
},
 
rarity = {
 
field = 'rarity',
 
type = 'String',
 
},
 
},
 
}
 
 
core.cargo.item_mods = {
 
table = 'item_mods',
 
fields = {
 
id = {
 
field = 'id',
 
type = 'String',
 
},
 
stat_text = {
 
field = 'text',
 
type = 'Text',
 
},
 
is_implicit = {
 
field = 'is_implicit',
 
type = 'Boolean',
 
},
 
is_random = {
 
field = 'is_random',
 
type = 'Boolean',
 
},
 
},
 
}
 
 
core.cargo.item_stats = {
 
table = 'item_stats',
 
fields = {
 
id = {
 
field = 'id',
 
type = 'String',
 
},
 
min = {
 
field = 'min',
 
type = 'Integer',
 
},
 
max = {
 
field = 'max',
 
type = 'Integer',
 
},
 
avg = {
 
field = 'avg',
 
type = 'Integer',
 
},
 
is_implicit = {
 
field = 'is_implicit',
 
type = 'Boolean',
 
},
 
is_random = {
 
field = 'is_random',
 
type = 'Boolean',
 
},
 
},
 
}
 
 
-- There probably will be a table named "buffs" in the future, so "item_buffs" is the best solution here
 
core.cargo.item_buffs = {
 
table = 'item_buffs',
 
fields = {
 
id = core.map.buff_id,
 
buff_values = core.map.buff_values,
 
stat_text = core.map.buff_stat_text,
 
icon = core.map.buff_icon,
 
},
 
}
 
 
core.cargo.upgraded_from_sets = {
 
table = 'upgraded_from_sets',
 
fields = {
 
set_id = {
 
field = 'set_id',
 
type = 'Integer',
 
},
 
text = {
 
field = 'text',
 
type = 'Text',
 
},
 
automatic = {
 
field = 'automatic',
 
type = 'Boolean',
 
},
 
}
 
}
 
 
core.cargo.upgraded_from_groups = {
 
table = 'upgraded_from_groups',
 
fields = {
 
group_id = {
 
field = 'group_id',
 
type = 'Integer',
 
},
 
set_id = {
 
field = 'set_id',
 
type = 'Integer',
 
},
 
item_id = {
 
field = 'item_id',
 
type = 'String',
 
},
 
item_name = {
 
field = 'item_name',
 
type = 'String',
 
},
 
item_page = {
 
field = 'item_page',
 
type = 'Page',
 
},
 
integer = {
 
field = 'amount',
 
type = 'Integer',
 
},
 
notes = {
 
field = 'notes',
 
type = 'Text',
 
},
 
}
 
}
 
 
core.cargo.amulets = {
 
table = 'amulets',
 
fields = {
 
is_talisman = core.map.is_talisman,
 
talisman_tier = core.map.talisman_tier,
 
},
 
}
 
 
core.cargo.flasks = {
 
table = 'flasks',
 
fields = {
 
-- All flasks
 
duration = core.map.flask_duration,
 
charges_max = core.map.charges_max,
 
charges_per_use = core.map.charges_per_use,
 
-- Life/Mana/Hybrid flasks
 
life = core.map.flask_life,
 
mana = core.map.flask_mana,
 
},
 
}
 
 
core.cargo.weapons = {
 
table = 'weapons',
 
fields = {
 
critical_strike_chance = core.map.critical_strike_chance,
 
attack_speed = core.map.attack_speed,
 
weapon_range = core.map.weapon_range,
 
physical_damage_min = core.map.physical_damage_min,
 
physical_damage_max = core.map.physical_damage_max,
 
physical_damage_html = core.map.physical_damage_html,
 
fire_damage_html = core.map.fire_damage_html,
 
cold_damage_html = core.map.cold_damage_html,
 
lightning_damage_html = core.map.lightning_damage_html,
 
chaos_damage_html = core.map.chaos_damage_html,
 
damage_avg = core.map.damage_avg,
 
damage_html = core.map.damage_html,
 
 
-- Values added via stat population
 
fire_damage_min = core.map.fire_damage_min,
 
fire_damage_max = core.map.fire_damage_max,
 
cold_damage_min = core.map.cold_damage_min,
 
cold_damage_max = core.map.cold_damage_max,
 
lightning_damage_min = core.map.lightning_damage_min,
 
lightning_damage_max = core.map.lightning_damage_max,
 
chaos_damage_min = core.map.chaos_damage_min,
 
chaos_damage_max = core.map.chaos_damage_max,
 
},
 
}
 
 
core.cargo.armours = {
 
table = 'armours',
 
fields = {
 
armour = core.map.armour,
 
energy_shield = core.map.energy_shield,
 
evasion = core.map.evasion,
 
movement_speed = core.map.movement_speed,
 
},
 
}
 
 
core.cargo.shields = {
 
table = 'shields',
 
fields = {
 
block = core.map.block,
 
}
 
}
 
 
core.cargo.skill_gems = {
 
table = 'skill_gems',
 
fields = {
 
gem_description = core.map.gem_description,
 
dexterity_percent = core.map.dexterity_percent,
 
strength_percent = core.map.strength_percent,
 
intelligence_percent = core.map.intelligence_percent,
 
primary_attribute = core.map.primary_attribute,
 
gem_tags = core.map.gem_tags,
 
-- Support Skill Gems
 
support_gem_letter = core.map.support_gem_letter,
 
support_gem_letter_html = core.map.support_gem_letter_html,
 
},
 
}
 
 
core.cargo.maps = {
 
table = 'maps',
 
fields = {
 
tier = core.map.map_tier,
 
guild_character = core.map.map_guild_character,
 
unique_guild_character = core.map.unique_map_guild_character,
 
area_id = core.map.map_area_id,
 
unique_area_id = core.map.unique_map_area_id,
 
series = core.map.map_series,
 
 
-- REMOVE?
 
area_level = core.map.map_area_level,
 
unique_area_level = core.map.unique_map_area_level,
 
},
 
}
 
 
core.cargo.atlas_maps = {
 
table = 'atlas_maps',
 
fields = {
 
x = core.map.atlas_x,
 
y = core.map.atlas_y,
 
region_id = core.map.atlas_region_id,
 
region_minimum = core.map.atlas_region_minimum,
 
x0 = core.map.atlas_x0,
 
x1 = core.map.atlas_x1,
 
x2 = core.map.atlas_x2,
 
x3 = core.map.atlas_x3,
 
x4 = core.map.atlas_x4,
 
y0 = core.map.atlas_y0,
 
y1 = core.map.atlas_y1,
 
y2 = core.map.atlas_y2,
 
y3 = core.map.atlas_y3,
 
y4 = core.map.atlas_y4,
 
map_tier0 = core.map.atlas_map_tier0,
 
map_tier1 = core.map.atlas_map_tier1,
 
map_tier2 = core.map.atlas_map_tier2,
 
map_tier3 = core.map.atlas_map_tier3,
 
map_tier4 = core.map.atlas_map_tier4,
 
},
 
}
 
 
core.cargo.atlas_connections = {
 
table = 'atlas_connections',
 
fields = {
 
map1 = {
 
field = 'map1',
 
type = 'String',
 
},
 
map2 = {
 
field = 'map2',
 
type = 'String',
 
},
 
region0 = {
 
field = 'region0',
 
type = 'Boolean',
 
},
 
region1 = {
 
field = 'region1',
 
type = 'Boolean',
 
},
 
region2 = {
 
field = 'region2',
 
type = 'Boolean',
 
},
 
region3 = {
 
field = 'region3',
 
type = 'Boolean',
 
},
 
region4 = {
 
field = 'region4',
 
type = 'Boolean',
 
},
 
},
 
}
 
 
core.cargo.stackables = {
 
table = 'stackables',
 
fields = {
 
stack_size = core.map.stack_size,
 
stack_size_currency_tab = core.map.stack_size_currency_tab,
 
cosmetic_type = core.map.cosmetic_type,
 
},
 
}
 
 
core.cargo.essences = {
 
table = 'essences',
 
fields = {
 
level_restriction = core.map.essence_level_restriction,
 
level = core.map.essence_level,
 
type = core.map.essence_type,
 
category = core.map.essence_category,
 
},
 
}
 
 
core.cargo.blight_items = {
 
table = 'blight_items',
 
fields = {
 
tier = core.map.blight_item_tier,
 
},
 
}
 
 
core.cargo.hideout_doodads = {
 
table = 'hideout_doodads',
 
fields = {
 
is_master_doodad = core.map.is_master_doodad,
 
master = core.map.master,
 
master_level_requirement = core.map.master_level_requirement,
 
master_favour_cost = core.map.master_favour_cost,
 
variation_count = core.map.variation_count,
 
},
 
}
 
 
core.cargo.prophecies = {
 
table = 'prophecies',
 
fields = {
 
prophecy_id = core.map.prophecy_id,
 
prediction_text = core.map.prediction_text,
 
seal_cost = core.map.seal_cost,
 
objective = core.map.prophecy_objective,
 
reward = core.map.prophecy_reward,
 
},
 
}
 
 
core.cargo.divination_cards = {
 
table = 'divination_cards',
 
fields = {
 
card_art = core.map.card_art,
 
},
 
}
 
 
core.cargo.jewels = {
 
table = 'jewels',
 
fields = {
 
item_limit = core.map.item_limit,
 
radius_html = core.map.jewel_radius_html,
 
},
 
}
 
 
core.cargo.incubators = {
 
table = 'incubators',
 
fields = {
 
effect = core.map.incubator_effect,
 
},
 
}
 
 
core.cargo.harvest_seeds = {
 
table = 'harvest_seeds',
 
fields = {
 
effect = core.map.seed_effect,
 
type_id = core.map.seed_type_id,
 
type = core.map.seed_type,
 
tier = core.map.seed_tier,
 
growth_cycles = core.map.seed_growth_cycles,
 
required_nearby_seed_tier = core.map.seed_required_nearby_seed_tier,
 
required_nearby_seed_amount = core.map.seed_required_nearby_seed_amount,
 
consumed_wild_lifeforce_percentage = core.map.seed_consumed_wild_lifeforce_percentage,
 
consumed_vivid_lifeforce_percentage = core.map.seed_consumed_vivid_lifeforce_percentage,
 
consumed_primal_lifeforce_percentage = core.map.seed_consumed_primal_lifeforce_percentage,
 
granted_craft_option_ids = core.map.seed_granted_craft_option_ids,
 
},
 
}
 
 
core.cargo.harvest_plant_boosters = {
 
table = 'harvest_plant_boosters',
 
fields = {
 
radius = core.map.plant_booster_radius,
 
lifeforce = core.map.plant_booster_lifeforce,
 
additional_crafting_options = core.map.plant_booster_additional_crafting_options,
 
extra_chances = core.map.plant_booster_extra_chances,
 
},
 
}
 
 
core.cargo.heist_equipment = {
 
table = 'heist_equipment',
 
fields = {
 
required_job_id = core.map.heist_required_job_id,
 
required_job_level = core.map.heist_required_job_level,
 
},
 
}
 
 
core.cargo.quest_rewards = {
 
table = 'quest_rewards',
 
fields = {
 
quest = {
 
field = 'quest',
 
type = 'String',
 
},
 
quest_id = {
 
field = 'quest_id',
 
type = 'String',
 
},
 
-- still needed?
 
act = {
 
field = 'act',
 
type = 'Integer',
 
},
 
classes = {
 
field = 'classes',
 
type = 'List (,) of String',
 
},
 
class_ids = {
 
field = 'class_ids',
 
type = 'List (,) of String',
 
},
 
sockets = {
 
field = 'sockets',
 
type = 'Integer',
 
},
 
item_level = {
 
field = 'item_level',
 
type = 'Integer',
 
},
 
rarity = {
 
field = 'rarity',
 
type = 'String',
 
},
 
notes = {
 
field = 'notes',
 
type = 'Text',
 
},
 
},
 
}
 
 
core.cargo.vendor_rewards = {
 
table = 'vendor_rewards',
 
fields = {
 
quest = {
 
field = 'quest',
 
type = 'String',
 
},
 
quest_id = {
 
field = 'quest_id',
 
type = 'String',
 
},
 
act = {
 
field = 'act',
 
type = 'Integer',
 
},
 
npc = {
 
field = 'npc',
 
type = 'String',
 
},
 
classes = {
 
field = 'classes',
 
type = 'List (,) of String',
 
},
 
class_ids = {
 
field = 'class_ids',
 
type = 'List (,) of String',
 
},
 
}
 
}
 
 
-- TODO: Second pass for i18n item classes
 
-- base item is default, but will be validated later
 
-- Notes:
 
-- inventory_icon must always be before alternate_art_inventory_icons
 
-- drop_areas after tags
 
-- is_relic after rarity
 
core.default_args = {
 
'rarity_id', 'rarity', 'name', 'name_list', 'size_x', 'size_y',
 
'drop_rarities_ids', 'drop_rarities', 'drop_enabled', 'drop_level', 'drop_level_maximum', 'drop_leagues', 'drop_text', 'required_level', 'required_level_final',
 
'inventory_icon', 'alternate_art_inventory_icons', 'flavour_text', 'flavour_text_id',
 
'cannot_be_traded_or_modified', 'help_text', 'tags', 'metadata_id', 'influences', 'is_fractured', 'is_synthesised', 'is_veiled', 'is_replica', 'is_corrupted', 'is_relic', 'is_fated', 'purchase_costs', 'sell_prices_override', 'mods',
 
'drop_areas', 'drop_areas_html', 'drop_monsters',
 
 
'upgraded_from_disabled',
 
'suppress_improper_modifiers_category',
 
 
'is_prophecy', 'is_blight_item',
 
 
'class',
 
'is_drop_restricted',
 
}
 
-- frame_type is needed in stat_text
 
core.late_args = {'frame_type', 'implicit_stat_text', 'explicit_stat_text', 'stat_text'}
 
core.prophecy_args = {'prophecy_id', 'prediction_text', 'seal_cost', 'prophecy_objective', 'prophecy_reward'}
 
core.tables = {'items'}
 
core.class_groups = {
 
flasks = {
 
tables = {'flasks'},
 
keys = {['LifeFlask'] = true, ['ManaFlask'] = true, ['HybridFlask'] = true, ['UtilityFlask'] = true, ['UtilityFlaskCritical'] = true},
 
args = {'quality', 'flask_duration', 'charges_max', 'charges_per_use'},
 
},
 
weapons = {
 
tables = {'weapons'},
 
keys = {['Claw'] = true, ['Dagger'] = true, ['Wand'] = true, ['One Hand Sword'] = true, ['Thrusting One Hand Sword'] = true, ['One Hand Axe'] = true, ['One Hand Mace'] = true, ['Bow'] = true, ['Staff'] = true, ['Two Hand Sword'] = true, ['Two Hand Axe'] = true, ['Two Hand Mace'] = true, ['Sceptre'] = true, ['FishingRod'] = true, ['Rune Dagger'] = true, ['Warstaff'] = true},
 
args = {'quality', 'required_dexterity', 'required_intelligence', 'required_strength', 'critical_strike_chance', 'attack_speed', 'physical_damage_min', 'physical_damage_max', 'lightning_damage_min', 'lightning_damage_max', 'cold_damage_min', 'cold_damage_max', 'fire_damage_min', 'fire_damage_max', 'chaos_damage_min', 'chaos_damage_max', 'weapon_range'},
 
late_args = {'physical_damage_html', 'fire_damage_html', 'cold_damage_html', 'lightning_damage_html', 'chaos_damage_html', 'damage_avg', 'damage_html'},
 
},
 
gems = {
 
tables = {'skill_gems'},
 
keys = {['Active Skill Gem'] = true, ['Support Skill Gem'] = true},
 
args = {'dexterity_percent', 'strength_percent', 'intelligence_percent', 'primary_attribute', 'gem_tags'},
 
},
 
armor = {
 
tables = {'armours'},
 
keys = {['Gloves'] = true, ['Boots'] = true, ['Body Armour'] = true, ['Helmet'] = true, ['Shield'] = true},
 
args = {'quality', 'required_dexterity', 'required_intelligence', 'required_strength', 'armour', 'energy_shield', 'evasion', 'movement_speed'},
 
},
 
stackable = {
 
tables = {'stackables'},
 
keys = {['Currency'] = true, ['StackableCurrency'] = true, ['HideoutDoodad'] = true, ['Microtransaction'] = true, ['DivinationCard'] = true, ['DelveSocketableCurrency'] = true, ['DelveStackableSocketableCurrency'] = true, ['Incubator'] = true, ['HarvestSeed'] = true, ['HarvestPlantBooster'] = true},
 
args = {'stack_size', 'stack_size_currency_tab', 'description', 'cosmetic_type'},
 
},
 
heist_equipment = {
 
tables = {'heist_equipment'},
 
keys = {['HeistEquipmentWeapon'] = true, ['HeistEquipmentTool'] = true, ['HeistEquipmentUtility'] = true, ['HeistEquipmentReward'] = true},
 
args = {'heist_required_job_id', 'heist_required_job_level', 'heist_data'},
 
},
 
}
 
 
core.class_specifics = {
 
['Amulet'] = {
 
tables = {'amulets'},
 
args = {'is_talisman', 'talisman_tier'},
 
},
 
['LifeFlask'] = {
 
args = {'flask_life'},
 
},
 
['ManaFlask'] = {
 
args = {'flask_mana'},
 
},
 
['HybridFlask'] = {
 
args = {'flask_life', 'flask_mana'},
 
},
 
['UtilityFlask'] = {
 
tables = {'item_buffs'},
 
args = {'buff_id', 'buff_values', 'buff_stat_text', 'buff_icon'},
 
},
 
['UtilityFlaskCritical'] = {
 
tables = {'item_buffs'},
 
args = {'buff_id', 'buff_values', 'buff_stat_text', 'buff_icon'},
 
},
 
['Active Skill Gem'] = {
 
defaults = {
 
help_text = i18n.help_text_defaults.active_gem,
 
size_x = 1,
 
size_y = 1,
 
},
 
frame_type = 'gem',
 
},
 
['Support Skill Gem'] = {
 
args = {'support_gem_letter', 'support_gem_letter_html'},
 
defaults = {
 
help_text = i18n.help_text_defaults.support_gem,
 
size_x = 1,
 
size_y = 1,
 
},
 
frame_type = 'gem',
 
},
 
['Shield'] = {
 
tables = {'shields'},
 
args = {'block'},
 
},
 
['Map'] = {
 
tables = {'maps', 'atlas_maps'},
 
args = {
 
'quality',
 
 
'map_tier',
 
'map_guild_character',
 
'map_area_id',
 
'map_area_level',
 
'unique_map_area_id',
 
'unique_map_area_level',
 
'unique_map_guild_character',
 
'map_series',
 
 
'atlas_x',
 
'atlas_y',
 
'atlas_region_id',
 
'atlas_x0',
 
'atlas_x1',
 
'atlas_x2',
 
'atlas_x3',
 
'atlas_x4',
 
'atlas_y0',
 
'atlas_y1',
 
'atlas_y2',
 
'atlas_y3',
 
'atlas_y4',
 
'atlas_map_tier0',
 
'atlas_map_tier1',
 
'atlas_map_tier2',
 
'atlas_map_tier3',
 
'atlas_map_tier4',
 
'atlas_connections', -- pseudo to fill connections table
 
},
 
skip_stat_lines = i18n.stat_skip_patterns.maps,
 
},
 
['Currency'] = {
 
frame_type = 'currency',
 
},
 
['StackableCurrency'] = {
 
tables = {'essences', 'prophecies', 'blight_items'},
 
args = {'is_essence', 'essence_level_restriction', 'essence_level', 'essence_type', 'essence_category', 'blight_item_tier'},
 
frame_type = 'currency',
 
},
 
['Microtransaction'] = {
 
frame_type = 'currency',
 
},
 
['HideoutDoodad'] = {
 
tables = {'hideout_doodads'},
 
args = {'is_master_doodad', 'master', 'master_level_requirement', 'master_favour_cost', 'variation_count'},
 
frame_type = 'currency',
 
},
 
['Jewel'] = {
 
tables = {'jewels'},
 
late_args = {'item_limit', 'jewel_radius_html'},
 
defaults = {
 
help_text = i18n.help_text_defaults.jewel,
 
},
 
skip_stat_lines = i18n.stat_skip_patterns.jewels,
 
},
 
['AbyssJewel'] = {
 
tables = {'jewels'},
 
late_args = {'item_limit', 'jewel_radius_html'},
 
skip_stat_lines = i18n.stat_skip_patterns.jewels,
 
},
 
['QuestItem'] = {
 
args = {'description'},
 
frame_type = 'quest',
 
},
 
['DivinationCard'] = {
 
tables = {'divination_cards'},
 
args = {'card_art',},
 
frame_type = 'divicard',
 
},
 
['LabyrinthItem'] = {
 
frame_type = 'currency',
 
},
 
['LabyrinthTrinket'] = {
 
tables = {'item_buffs'},
 
args = {'description', 'buff_icon'},
 
frame_type = 'currency',
 
},
 
['PantheonSoul'] = {
 
defaults = {
 
cannot_be_traded_or_modified = true,
 
},
 
},
 
['IncursionItem'] = {
 
frame_type = 'currency',
 
},
 
['Incubator'] = {
 
tables = {'incubators'},
 
args = {'incubator_effect'},
 
frame_type = 'currency',
 
},
 
['HarvestSeed'] = {
 
tables = {'harvest_seeds'},
 
args = {'seed_effect', 'seed_type_id', 'seed_effect', 'seed_type', 'seed_type_html', 'seed_tier', 'seed_growth_cycles', 'seed_required_nearby_seed_tier', 'seed_required_nearby_seed_amount', 'seed_consumed_wild_lifeforce_percentage', 'seed_consumed_vivid_lifeforce_percentage', 'seed_consumed_primal_lifeforce_percentage', 'seed_granted_craft_option_ids'},
 
frame_type = 'currency',
 
},
 
['HarvestPlantBooster'] = {
 
tables = {'harvest_plant_boosters'},
 
args = {'plant_booster_radius', 'plant_booster_lifeforce', 'plant_booster_additional_crafting_options', 'plant_booster_extra_chances'},
 
frame_type = 'currency',
 
},
 
['HeistObjective'] = {
 
frame_type = 'currency',
 
},
 
}
 
 
-- add defaults from class specifics and class groups
 
core.item_classes = {}
 
core.item_classes_extend = {'tables', 'args', 'late_args'}
 
function core.build_item_classes(tpl_args, frame)
 
core.map.class.func(tpl_args, frame)
 
 
core.item_classes[tpl_args.class_id] = {
 
tables = {},
 
args = {},
 
late_args = {},
 
defaults = {},
 
}
 
 
for _, table_name in ipairs(core.tables) do
 
table.insert(core.item_classes[tpl_args.class_id].tables, table_name)
 
end
 
 
for _, row in pairs(core.class_groups) do
 
for class, _ in pairs(row.keys) do
 
if class == tpl_args.class_id then
 
for _, k in ipairs(core.item_classes_extend) do
 
if row[k] ~= nil then
 
for _, value in ipairs(row[k]) do
 
table.insert(core.item_classes[tpl_args.class_id][k], value)
 
end
 
end
 
end
 
break
 
 
end
 
end
 
end
 
end
end
+
return true
 
local class_specifics = core.class_specifics[tpl_args.class_id]
 
if class_specifics then
 
for _, k in ipairs(core.item_classes_extend) do
 
if class_specifics[k] ~= nil then
 
for _, value in ipairs(class_specifics[k]) do
 
table.insert(core.item_classes[tpl_args.class_id][k], value)
 
end
 
end
 
end
 
if class_specifics.defaults ~= nil then
 
for key, value in pairs(class_specifics.defaults) do
 
core.item_classes[tpl_args.class_id].defaults[key] = value
 
end
 
end
 
 
end
 
end
 
end
 
end
   
  +
function h.factory.display_raw_value(key)
-- GroupTable -> RowTable -> formatter function
 
  +
return function(tpl_args, frame)
--
 
  +
return tpl_args[key]
--
 
 
h.conditions = {}
 
h.conditions.factory = {}
 
 
function h.conditions.factory.arg (args)
 
-- Required:
 
-- arg: The argument to check against
 
-- One must be specified
 
-- value: check whether the argument equals this value
 
-- values: check whether the argument is in this list of values
 
-- values_assoc: check whether the argument is in this associative table
 
--
 
-- Optional:
 
-- negate: negates the check against the value, i.e. whether the value is not equal or not in the list/table.
 
if args.negate == nil then
 
args.negate = false
 
 
end
 
end
 
-- Inner type of function depending on whether to check a single value, a list of values or an associative list of values
 
local inner
 
if args.value ~= nil then
 
inner = function (tpl)
 
return tpl == args.value
 
end
 
elseif args.values ~= nil then
 
inner = function (tpl)
 
for _, value in ipairs(args.values) do
 
if tpl == value then
 
return true
 
end
 
end
 
return false
 
end
 
elseif args.values_assoc ~= nil then
 
inner = function(tpl)
 
return args.values_assoc[tpl] ~= nil
 
end
 
else
 
error(string.format('Missing inner comparision function. Args: %s', mw.dumpObject(args)))
 
end
 
 
-- Outer type of function depending on whether to check a single value or against a table
 
return function (tpl_args, frame)
 
local tpl_value = tpl_args[args.arg]
 
local rtr
 
if type(tpl_value) == 'table' then
 
rtr = false
 
for key, value in pairs(tpl_value) do
 
if type(key) == 'number' then
 
rtr = rtr or inner(value)
 
else
 
rtr = rtr or inner(key)
 
end
 
end
 
 
else
 
rtr = inner(tpl_value)
 
end
 
 
if args.negate then
 
rtr = not rtr
 
end
 
 
return rtr
 
end
 
 
end
 
end
   
function h.conditions.factory.league (args)
+
function h.factory.descriptor_value(args)
  +
-- Arguments:
return function (tpl_args, frame)
 
  +
-- key
for _, league in ipairs(tpl_args.drop_leagues or {}) do
 
  +
-- tbl
if league == args.league then
 
return true
+
args = args or {}
  +
return function (tpl_args, frame, value)
end
 
  +
args.tbl = args.tbl or tpl_args
  +
if args.tbl[args.key] then
  +
value = m_util.html.abbr(value, args.tbl[args.key])
 
end
 
end
return false
+
return value
 
end
 
end
 
end
 
end
   
  +
-- ----------------------------------------------------------------------------
h.conditions.normal = h.conditions.factory.arg{arg='rarity_id', value='normal'}
 
  +
-- Additional configuration
h.conditions.unique = h.conditions.factory.arg{arg='rarity_id', value='unique'}
 
  +
-- ----------------------------------------------------------------------------
   
  +
-- helper to loop over the range variables easier
-- Default for all entries, but can be disabled by specific ones.
 
  +
c.range_map = {
core.automatic_upgraded_from_defaults = {
 
  +
min = {
is_drop_restricted = h.conditions.factory.arg{arg='is_drop_restricted', value=false},
 
  +
var = '_range_minimum',
is_corrupted = h.conditions.factory.arg{arg='is_corrupted', value=false},
 
}
 
-- Order matters
 
-- Put most specific outcome at the topic and the least specific at the bottom
 
core.automatic_upgraded_from = {
 
--[[
 
{
 
defaults = {
 
arg_key = function (tpl_args, frame) end,
 
},
 
condition = {
 
function (tpl_args, frame) end,
 
},
 
text = '',
 
groups = {
 
{
 
name = '',
 
item_id = '',
 
amount = 0,
 
notes = '',
 
},
 
},
 
 
},
 
},
]]
+
max = {
  +
var = '_range_maximum',
--
 
-- Item base specific
 
--
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='base_item_id', value='Metadata/Items/Amulets/Amulet9'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.agate_amulet))
 
end,
 
groups = {
 
{
 
-- Передышка Лисы
 
item_id = "Metadata/Items/DivinationCards/DivinationCardLysahsRespite",
 
amount = 6,
 
},
 
},
 
 
},
 
},
{
+
avg = {
condition = {
+
var = '_range_average',
h.conditions.unique,
 
h.conditions.factory.arg{arg='base_item_id', value='Metadata/Items/Rings/Ring15'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_3, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.unset_ring))
 
end,
 
groups = {
 
{
 
-- Кающийся
 
item_id = "Metadata/Items/DivinationCards/DivinationCardThePenitent",
 
amount = 5,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='base_item_id', value='Metadata/Items/Rings/Ring4'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_3, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.gold_ring))
 
end,
 
groups = {
 
{
 
-- Проблеск надежды
 
item_id = "Metadata/Items/DivinationCards/DivinationCardGlimmerOfHope",
 
amount = 8,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='base_item_id', value='Metadata/Items/Rings/Ring8'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted_3, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.prismatic_ring))
 
end,
 
groups = {
 
{
 
-- Надежда
 
item_id = "Metadata/Items/DivinationCards/DivinationCardHope",
 
amount = 5,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='metadata_id', values={'Metadata/Items/Rings/Ring12', 'Metadata/Items/Rings/Ring13', 'Metadata/Items/Rings/Ring14'}},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_3, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.two_stone_ring))
 
end,
 
groups = {
 
{
 
-- Утраченная любовь Лантадора
 
item_id = "Metadata/Items/DivinationCards/DivinationCardLantadorsLostLove",
 
amount = 7,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='base_item_id', values={'Metadata/Items/Rings/Ring12', 'Metadata/Items/Rings/Ring13', 'Metadata/Items/Rings/Ring14'}},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_3, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.two_stone_ring))
 
end,
 
groups = {
 
{
 
-- Гетерохромия
 
item_id = "Metadata/Items/DivinationCards/DivinationCardHeterochromia",
 
amount = 2,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='base_item_id', value='Metadata/Items/Weapons/OneHandWeapons/OneHandMaces/Sceptre11'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.crystal_sceptre))
 
end,
 
groups = {
 
{
 
-- Свет и правда
 
item_id = "Metadata/Items/DivinationCards/DivinationCardLightAndTruth",
 
amount = 2,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='base_item_id', value='Metadata/Items/Flasks/FlaskUtility5'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.granite_flask))
 
end,
 
groups = {
 
{
 
-- Пьющий землю
 
item_id = "Metadata/Items/DivinationCards/DivinationCardEarthDrinker",
 
amount = 5,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='base_item_id', value='Metadata/Items/Armours/Helmets/HelmetStrDex10'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.nightmare_bascinet))
 
end,
 
groups = {
 
{
 
-- Гладиатор
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheGladiator",
 
amount = 5,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='base_item_id', value='Metadata/Items/Belts/Belt1'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.rustic_sash))
 
end,
 
groups = {
 
{
 
-- Противоборство
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheStandoff",
 
amount = 3,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_drop_restricted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='base_item_id', value='Metadata/Items/Jewels/JewelTimeless'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.timeless_jewel))
 
end,
 
groups = {
 
{
 
-- Безмятежные минуты
 
item_id = "Metadata/Items/DivinationCards/DivinationCardPeacefulMoments",
 
amount = 5,
 
},
 
},
 
},
 
--
 
-- Even more specific stuff
 
--
 
{
 
defaults = {
 
is_drop_restricted = false,
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='is_talisman', value=true},
 
h.conditions.factory.arg{arg='talisman_tier', value=1},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.tier_1_talisman))
 
end,
 
groups = {
 
{
 
-- Призыв Первых
 
item_id = "Metadata/Items/DivinationCards/DivinationCardCallToTheFirstOnes",
 
amount = 5,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_drop_restricted = false,
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.factory.arg{arg='is_talisman', value=true},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, i18n.upgraded_from_tooltips.talisman)
 
end,
 
groups = {
 
{
 
-- Первобытный инкубатор
 
item_id = "Metadata/Items/Currency/CurrencyIncubationTalismans",
 
amount = 1,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
function (tpl_args, frame)
 
return string.find(tpl_args.name, 'Атзири')
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Атзири')))
 
end,
 
groups = {
 
{
 
-- Поклонник
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheAdmirer",
 
amount = 9,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
function (tpl_args, frame)
 
return string.find(tpl_args.name, 'Доэдре')
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Доэдре')))
 
end,
 
groups = {
 
{
 
-- Безумие Доэдре
 
item_id = "Metadata/Items/DivinationCards/DivinationCardDoedresMadness",
 
amount = 9,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
function (tpl_args, frame)
 
return string.find(tpl_args.name, 'Шавронн')
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Шавронн')))
 
end,
 
groups = {
 
{
 
-- Эстет
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheAesthete",
 
amount = 8,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_drop_restricted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
function (tpl_args, frame)
 
return string.find(tpl_args.name, 'Ригвальда')
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Ригвальда')))
 
end,
 
groups = {
 
{
 
-- Волк
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheWolf",
 
amount = 5,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
function (tpl_args, frame)
 
return string.find(tpl_args.name, 'Львиного глаза')
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Львиного глаза')))
 
end,
 
groups = {
 
{
 
-- Лев
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheLion",
 
amount = 5,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_drop_restricted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
function (tpl_args, frame)
 
return string.find(tpl_args.name, 'Фаррул')
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Фаррул')))
 
end,
 
groups = {
 
{
 
-- Кошачий совет
 
item_id = "Metadata/Items/DivinationCards/DivinationCardCouncilOfCats",
 
amount = 4,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', value='Jewel'},
 
function (tpl_args, frame)
 
return string.find(tpl_args.name, 'Первородн')
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_primordial, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.jewel))
 
end,
 
groups = {
 
{
 
-- Первородный
 
item_id = "Metadata/Items/DivinationCards/DivinationCardThePrimordial",
 
amount = 5,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_drop_restricted = false,
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
function (tpl_args, frame)
 
return string.find(tpl_args.name, 'Знак предтечи')
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('unique', string.format('Знак предтечи')))
 
end,
 
groups = {
 
{
 
-- Поминовение
 
item_id = "Metadata/Items/DivinationCards/DivinationCardRemembrance",
 
amount = 8,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal, --Редкость
 
function (tpl_args, frame)
 
return string.find(tpl_args.name, 'Карта храма ваал')
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(m_util.html.poe_color('rare', string.format('Карта храма ваал')))
 
end,
 
groups = {
 
{
 
-- Пережитки прошлого
 
item_id = "Metadata/Items/DivinationCards/DivinationCardLingeringRemnants",
 
amount = 16,
 
},
 
},
 
},
 
--
 
-- League specific items
 
--
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.league{league='Немезида'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Немезиды')))
 
end,
 
groups = {
 
{
 
-- Валькирия
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheValkyrie",
 
amount = 8,
 
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.league{league='Немезида'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Немезиды')))
 
end,
 
groups = {
 
{
 
-- Неустрашимый
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheUndaunted",
 
amount = 5,
 
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.league{league='Иномирье'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Иномирья')))
 
end,
 
groups = {
 
{
 
-- Призыв
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheCalling",
 
amount = 6,
 
 
},
 
},
 
},
 
{
 
defaults = {
 
is_drop_restricted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.league{league='Разлом'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Разлома')))
 
end,
 
groups = {
 
{
 
-- Разлом
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheBreach",
 
amount = 4,
 
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.league{league='Спуск'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Спуска')))
 
end,
 
groups = {
 
{
 
-- Один в темноте
 
item_id = "Metadata/Items/DivinationCards/DivinationCardAloneInTheDarkness",
 
amount = 5,
 
 
},
 
},
 
},
 
{
 
defaults = {
 
is_drop_restricted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.league{league='Бестиарий'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Бестиария')))
 
end,
 
groups = {
 
{
 
-- Дар Первых
 
item_id = "Metadata/Items/DivinationCards/DivinationCardBoonOfTheFirstOnes",
 
amount = 6,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_drop_restricted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.league{league='Бездна'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('rare', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Бездны')))
 
end,
 
groups = {
 
{
 
-- Инкубатор Бездны
 
item_id = "Metadata/Items/Currency/CurrencyIncubationAbyss",
 
amount = 1,
 
 
},
 
},
 
},
 
{
 
defaults = {
 
is_drop_restricted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.league{league='Метаморф'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', string.format(i18n.upgraded_from_tooltips.f.x_item, 'Метаморфа')))
 
end,
 
groups = {
 
{
 
-- Преследующие тени
 
item_id = "Metadata/Items/DivinationCards/DivinationCardHauntingShadows",
 
amount = 4,
 
},
 
},
 
},
 
--
 
-- Subset of class
 
--
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='MapFragment'},
 
h.conditions.factory.arg{arg='tags', value='atziri1'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.sacrifice_fragment))
 
end,
 
groups = {
 
{
 
-- Её маска
 
item_id = "Metadata/Items/DivinationCards/DivinationCardHerMask",
 
amount = 4,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_drop_restricted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='MapFragment'},
 
h.conditions.factory.arg{arg='tags', value='atziri2'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.mortal_fragment))
 
end,
 
groups = {
 
{
 
-- Клятва Самбодхи
 
item_id = "Metadata/Items/DivinationCards/DivinationCardSambodhisVow",
 
amount = 3,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_drop_restricted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='MapFragment'},
 
function (tpl_args, frame)
 
return string.find(tpl_args.metadata_id, 'UberElderFragment')
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.uber_elder_fragment))
 
end,
 
groups = {
 
{
 
-- Аномальное увядание
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheEldritchDecay",
 
amount = 4,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='MapFragment'},
 
h.conditions.factory.arg{arg='tags', value='breachstone4'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.pure_breachstone))
 
end,
 
groups = {
 
{
 
-- Сделка
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheBargain",
 
amount = 5,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='MapFragment'},
 
h.conditions.factory.arg{arg='tags', value='breachstone'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.breachstone))
 
end,
 
groups = {
 
{
 
-- Скрытный
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheObscured",
 
amount = 7,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='StackableCurrency'},
 
h.conditions.factory.arg{arg='is_essence', value=true},
 
h.conditions.factory.arg{arg='essence_level', value=7},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_x_amount_2, m_util.html.poe_color('currency', i18n.upgraded_from_tooltips.deafening_essence), 3)
 
end,
 
groups = {
 
{
 
-- Какофония
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheCacophony",
 
amount = 8,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='StackableCurrency'},
 
h.conditions.factory.arg{arg='is_essence', value=true},
 
h.conditions.factory.arg{arg='essence_level', value=6},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_x_amount_2, m_util.html.poe_color('currency', i18n.upgraded_from_tooltips.shrieking_essence), 9)
 
end,
 
groups = {
 
{
 
-- Гармония душ
 
item_id = "Metadata/Items/DivinationCards/DivinationCardHarmonyOfSouls",
 
amount = 9,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='StackableCurrency'},
 
h.conditions.factory.arg{arg='is_essence', value=true},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_x_amount_2, m_util.html.poe_color('currency', i18n.upgraded_from_tooltips.essence), 3)
 
end,
 
groups = {
 
{
 
-- Три голоса
 
item_id = "Metadata/Items/DivinationCards/DivinationCardThreeVoices",
 
amount = 3,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='StackableCurrency'},
 
h.conditions.factory.arg{arg='is_essence', value=true},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_2, m_util.html.poe_color('currency', i18n.upgraded_from_tooltips.essence))
 
end,
 
groups = {
 
{
 
-- Шепчущий инкубатор
 
item_id = "Metadata/Items/Currency/CurrencyIncubationEssence",
 
amount = 1,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='StackableCurrency'},
 
function (tpl_args, frame)
 
return string.find(tpl_args.metadata_id, 'CurrencyDelve')
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_3, m_util.html.poe_color('currency', i18n.upgraded_from_tooltips.fossil))
 
end,
 
groups = {
 
{
 
-- Ископаемый инкубатор
 
item_id = "Metadata/Items/Currency/CurrencyIncubationFossils",
 
amount = 1,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Map'},
 
h.conditions.factory.arg{arg='map_tier', value=5},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_2, m_util.html.poe_color('normal', string.format(i18n.upgraded_from_tooltips.f.tier_x_map, 5)))
 
end,
 
groups = {
 
{
 
-- Восторг картографа
 
item_id = "Metadata/Items/DivinationCards/DivinationCardCartographersDelight",
 
amount = 3,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Map'},
 
h.conditions.factory.arg{arg='map_tier', value=14},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_2, m_util.html.poe_color('normal', string.format(i18n.upgraded_from_tooltips.f.tier_x_map, 14)))
 
end,
 
groups = {
 
{
 
-- Топограф
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheSurveyor",
 
amount = 4,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Map'},
 
h.conditions.factory.arg{arg='map_tier', value=15},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_2, m_util.html.poe_color('normal', string.format(i18n.upgraded_from_tooltips.f.tier_x_map, 15)))
 
end,
 
groups = {
 
{
 
-- Затерянные миры
 
item_id = "Metadata/Items/DivinationCards/DivinationCardLostWorlds",
 
amount = 8,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Map'},
 
h.conditions.factory.arg{arg='map_tier', value=15},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted_2, m_util.html.poe_color('rare', string.format(i18n.upgraded_from_tooltips.f.tier_x_map, 15)))
 
end,
 
groups = {
 
{
 
-- Испытание
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheTrial",
 
amount = 7,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Map'},
 
h.conditions.factory.arg{arg='map_tier', value=16},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_unidentified_corrupted_2, m_util.html.poe_color('rare', string.format(i18n.upgraded_from_tooltips.f.tier_x_map, 16)))
 
end,
 
groups = {
 
{
 
-- На произвол судьбы
 
item_id = "Metadata/Items/DivinationCards/DivinationCardLeftToFate",
 
amount = 4,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Active Skill Gem'},
 
h.conditions.factory.arg{arg='gem_tags', value=m_game.constants.item.gem_tags.golem.tag},
 
h.conditions.factory.arg{arg='max_level', value=20},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.level_x_y_gem, m_game.constants.item.gem_tags.golem.tag, 21)))
 
end,
 
groups = {
 
{
 
-- Ритуал стихий
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheRiteOfElements",
 
amount = 5,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Active Skill Gem'},
 
h.conditions.factory.arg{arg='gem_tags', value=m_game.constants.item.gem_tags.trap.tag},
 
h.conditions.factory.arg{arg='max_level', value=20},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.superior_level_x_y_gem_q_z, m_game.constants.item.gem_tags.trap.tag, 21, 23)))
 
end,
 
groups = {
 
{
 
-- Смертельные замыслы
 
item_id = "Metadata/Items/DivinationCards/DivinationCardDeathlyDesigns",
 
amount = 7,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_drop_restricted = false,
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Support Skill Gem'},
 
function (tpl_args, frame)
 
return string.find(tpl_args.metadata_id, 'Plus')
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.superior_level_x_support_plus_gem_q_y, 6, 23)))
 
end,
 
groups = {
 
{
 
-- Осквернённая добродетель
 
item_id = "Metadata/Items/DivinationCards/DivinationCardDesecratedVirtue",
 
amount = 9,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Active Skill Gem'},
 
h.conditions.factory.arg{arg='gem_tags', value=m_game.constants.item.gem_tags.chaos.tag},
 
h.conditions.factory.arg{arg='max_level', value=20},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.superior_level_x_y_gem_q_z, m_game.constants.item.gem_tags.chaos.tag, 21, 23)))
 
end,
 
groups = {
 
{
 
-- Колючее соцветие
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheBitterBlossom",
 
amount = 3,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Active Skill Gem'},
 
h.conditions.factory.arg{arg='gem_tags', value=m_game.constants.item.gem_tags.vaal.tag},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.superior_x_gem_q_y, m_game.constants.item.gem_tags.vaal.tag, 20)))
 
end,
 
groups = {
 
{
 
-- Изменчивая сила
 
item_id = "Metadata/Items/DivinationCards/DivinationCardVolatilePower",
 
amount = 9,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Active Skill Gem'},
 
h.conditions.factory.arg{arg='max_level', value=20},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.superior_level_x_skill_gem_q_y, 19, 19)))
 
end,
 
groups = {
 
{
 
-- Смертельная тоска
 
item_id = "Metadata/Items/DivinationCards/DivinationCardDyingAnguish",
 
amount = 8,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Active Skill Gem'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.superior_skill_gem)))
 
end,
 
groups = {
 
{
 
-- Инкубатор камнереза
 
item_id = "Metadata/Items/Currency/CurrencyIncubationGemLow",
 
amount = 1,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='MapFragment'},
 
h.conditions.factory.arg{arg='tags', value='gilded_scarab'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.gilded_scarab))
 
end,
 
groups = {
 
{
 
-- Большего всегда мало
 
item_id = "Metadata/Items/DivinationCards/DivinationCardMoreIsNeverEnough",
 
amount = 7,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='MapFragment'},
 
function (tpl_args, frame)
 
return string.find(tpl_args.metadata_id, 'Scarab')
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.scarab))
 
end,
 
groups = {
 
{
 
-- Доля Камерии
 
item_id = "Metadata/Items/DivinationCards/DivinationCardCameriasCut",
 
amount = 2,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='MapFragment'},
 
function (tpl_args, frame)
 
return string.find(tpl_args.metadata_id, 'Scarab')
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.scarab))
 
end,
 
groups = {
 
{
 
-- Дергающийся инкубатор
 
item_id = "Metadata/Items/Currency/CurrencyIncubationScarabs",
 
amount = 1,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='MapFragment'},
 
function (tpl_args, frame)
 
return string.find(tpl_args.metadata_id, 'MapFragments')
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.fragment))
 
end,
 
groups = {
 
{
 
-- Раздробленный инкубатор
 
item_id = "Metadata/Items/Currency/CurrencyIncubationFragments",
 
amount = 1,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='StackableCurrency'},
 
h.conditions.factory.arg{arg='tags', value='breachstone_splinter'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_x_amount, m_util.html.poe_color('currency', i18n.upgraded_from_tooltips.breachstone_splinter), 5)
 
end,
 
groups = {
 
{
 
-- Головоломка
 
item_id = "Metadata/Items/DivinationCards/DivinationCardThePuzzle",
 
amount = 5,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='StackableCurrency'},
 
h.conditions.factory.arg{arg='tags', value='quality_currency'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_x_amount_2, m_util.html.poe_color('currency', i18n.upgraded_from_tooltips.quality_currency), 20)
 
end,
 
groups = {
 
{
 
-- Мастер-ремесленник
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheMasterArtisan",
 
amount = 5,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='StackableCurrency'},
 
function (tpl_args, frame)
 
return string.find(tpl_args.metadata_id, 'CurrencyDelve')
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_x_amount_3, m_util.html.poe_color('currency', i18n.upgraded_from_tooltips.fossil), 5)
 
end,
 
groups = {
 
{
 
-- Верстак умельца
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheTinkerersTable",
 
amount = 5,
 
},
 
},
 
},
 
--
 
-- One class
 
--
 
{
 
defaults = {
 
is_drop_restricted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', value='UniqueFragment'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.harbinger_fragment))
 
end,
 
groups = {
 
{
 
-- Посланник
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheMessenger",
 
amount = 4,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', value='Body Armour'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.body_armour))
 
end,
 
groups = {
 
{
 
-- Тело
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheBody",
 
amount = 4,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', value='Shield'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.shield))
 
end,
 
groups = {
 
{
 
-- Наёмник
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheMercenary",
 
amount = 5,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', value='Claw'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted_4, m_util.html.poe_color('unique', i18n.tooltips.item_class_map['Claw']))
 
end,
 
groups = {
 
{
 
-- Росомаха
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheWolverine",
 
amount = 4,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', values={'Dagger', 'Rune Dagger'}},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.tooltips.item_class_map['Dagger']))
 
end,
 
groups = {
 
{
 
-- Услуга душегуба
 
item_id = "Metadata/Items/DivinationCards/DivinationCardAssassinsFavour",
 
amount = 9,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Sceptre'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_shaper, m_util.html.poe_color('magic', string.format('%s %s', i18n.tooltips.item_class_map['Sceptre'], frame:expandTemplate{title='Modifier link',args={id='LocalIncreasedAttackSpeed8'}})))
 
end,
 
groups = {
 
{
 
-- Владыка триумфа
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheLordOfCelebration",
 
amount = 4,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', value='Bow'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.tooltips.item_class_map['Bow']))
 
end,
 
groups = {
 
{
 
-- Решение охотника
 
item_id = "Metadata/Items/DivinationCards/DivinationCardHuntersResolve",
 
amount = 8,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Jewel'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('magic', string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='PercentIncreasedLifeJewel'}}, i18n.upgraded_from_tooltips.jewel)))
 
end,
 
groups = {
 
{
 
-- Осколок рока
 
item_id = "Metadata/Items/DivinationCards/DivinationCardShardOfFate",
 
amount = 4,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Jewel'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('magic', string.format('%s %s', i18n.upgraded_from_tooltips.jewel, frame:expandTemplate{title='Modifier link',args={id='CriticalStrikeMultiplierJewel'}})))
 
end,
 
groups = {
 
{
 
-- Гора
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheMountain",
 
amount = 6,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', value='Jewel'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.jewel))
 
end,
 
groups = {
 
{
 
-- Крикливая мощь
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheGarishPower",
 
amount = 4,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', value='Jewel'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.jewel))
 
end,
 
groups = {
 
{
 
-- Глаз дракона
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheEyeOfTheDragon",
 
amount = 10,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Amulet'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('magic', string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='IncreasedEnergyShieldPercent7'}}, i18n.upgraded_from_tooltips.amulet)))
 
end,
 
groups = {
 
{
 
-- Печать
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheSigil",
 
amount = 3,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Amulet'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.amulet))
 
end,
 
groups = {
 
{
 
-- Смотритель
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheWarden",
 
amount = 4,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Ring'},
 
function (tpl_args, frame)
 
return tpl_args.drop_level <= 83
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x_3, m_util.html.poe_color('magic', string.format('%s %s', i18n.upgraded_from_tooltips.ring, frame:expandTemplate{title='Modifier link',args={id='ChaosResist6'}})), 83)
 
end,
 
groups = {
 
{
 
-- Господин в чёрном
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheLordInBlack",
 
amount = 6,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Helmet'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_two_veiled, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.helmet))
 
end,
 
groups = {
 
{
 
-- Журналист
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheJournalist",
 
amount = 10,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Ring'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x_3, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.ring), 100)
 
end,
 
groups = {
 
{
 
-- Толстосум
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheOpulecent",
 
amount = 5,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', value='Ring'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_3, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.ring))
 
end,
 
groups = {
 
{
 
-- Высокомерие
 
item_id = "Metadata/Items/DivinationCards/DivinationCardHubris",
 
amount = 5,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', value='Ring'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted_3, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.ring))
 
end,
 
groups = {
 
{
 
-- Сделка вслепую
 
item_id = "Metadata/Items/DivinationCards/DivinationCardBlindVenture",
 
amount = 7,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', value='Belt'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.belt))
 
end,
 
groups = {
 
{
 
-- Горемыка
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheWretched",
 
amount = 6,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', value='Map'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted_2, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.map))
 
end,
 
groups = {
 
{
 
-- Вездесущая тьма
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheEncroachingDarkness",
 
amount = 8,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', value='Map'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_2, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.map))
 
end,
 
groups = {
 
{
 
-- Потусторонний инкубатор
 
item_id = "Metadata/Items/Currency/CurrencyIncubationUniqueMaps",
 
amount = 1,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', value='Wand'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('unique', i18n.tooltips.item_class_map['Wand']))
 
end,
 
groups = {
 
{
 
-- Предатель
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheTraitor",
 
amount = 4,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', values={'Staff', 'Warstaff'}},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.tooltips.item_class_map['Staff']))
 
end,
 
groups = {
 
{
 
-- Башня
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheTower",
 
amount = 6,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', values={'Staff', 'Warstaff'}},
 
h.conditions.factory.arg{arg='tags', value='small_staff', negate=true},
 
function (tpl_args, frame)
 
return tpl_args.drop_level <= 66
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_x_link_item_level_y, m_util.html.poe_color('normal', i18n.tooltips.item_class_map['Staff']), 5, 66)
 
end,
 
groups = {
 
{
 
-- Сила природы
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheFlorasGift",
 
amount = 5,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Staff'},
 
h.conditions.factory.arg{arg='tags', value='small_staff', negate=true},
 
function (tpl_args, frame)
 
return tpl_args.drop_level <= 55
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_x_link_item_level_y, m_util.html.poe_color('normal', i18n.tooltips.item_class_map['Staff']), 6, 55)
 
end,
 
groups = {
 
{
 
-- Тёмный маг
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheDarkMage",
 
amount = 6,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Body Armour'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_x_link_item_level_y, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.body_armour), 6, 100)
 
end,
 
groups = {
 
{
 
-- Одарённый франт
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheDapperProdigy",
 
amount = 6,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal, --Редкость
 
h.conditions.factory.arg{arg='class_id', value='Body Armour'}, --Поиск по классу предмета, конкретика на кольца, амулеты, пояса.
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_x_link_item_level_y_random_influenced, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.body_armour), 6, 100)
 
end,
 
groups = {
 
{
 
-- Облачённый в мечты
 
item_id = "Metadata/Items/DivinationCards/DivinationCardDrapedInDreams", --ID Предмета, с которого будет падать бижутерия запрошенная выше.
 
amount = 5, --Количество кароточек, для полной колоны гадальных карт.
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Body Armour'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_x_link, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.body_armour), 6)
 
end,
 
groups = {
 
{
 
-- Оковы
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheChainsThatBind",
 
amount = 11,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Body Armour'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_x_link, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.body_armour), 6)
 
end,
 
groups = {
 
{
 
-- Инкубатор геоманта
 
item_id = "Metadata/Items/Currency/CurrencyIncubationArmour6Linked",
 
amount = 1,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Support Skill Gem'},
 
h.conditions.factory.arg{arg='max_level', value=20},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.level_x_y_gem, m_game.constants.item.gem_tags.support.tag, 20)))
 
end,
 
groups = {
 
{
 
-- Дары царицы каменитов
 
item_id = "Metadata/Items/DivinationCards/DivinationCardGiftOfTheGemlingQueen",
 
amount = 9,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Support Skill Gem'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.superior_x_gem_q_y, m_game.constants.item.gem_tags.support.tag, 23)))
 
end,
 
groups = {
 
{
 
-- Подчинение Диаллы
 
item_id = "Metadata/Items/DivinationCards/DivinationCardDiallasSubjugation",
 
amount = 7,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_drop_restricted = false,
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Support Skill Gem'},
 
function (tpl_args, frame)
 
return string.find(tpl_args.metadata_id, 'Plus')
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.superior_level_x_support_plus_gem_q_y, 6, 20)))
 
end,
 
groups = {
 
{
 
-- Ловкач
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheCheater",
 
amount = 3,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Body Armour'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.body_armour), 100)
 
end,
 
groups = {
 
{
 
-- Неизбежный крах
 
item_id = "Metadata/Items/DivinationCards/DivinationCardDestinedToCrumble",
 
amount = 5,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Map'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_2, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.map))
 
end,
 
groups = {
 
{
 
-- Бескрайние владения
 
item_id = "Metadata/Items/DivinationCards/DivinationCardBoundlessRealms",
 
amount = 4,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Map'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted_2, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.map))
 
end,
 
groups = {
 
{
 
-- Исследователь
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheExplorer",
 
amount = 6,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', value='Gloves'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_4, m_util.html.poe_color('unique', m_game.constants.item.classes['Gloves'].full))
 
end,
 
groups = {
 
{
 
-- Рукавички
 
item_id = "Metadata/Items/DivinationCards/DivinationCardMitts",
 
amount = 5,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_drop_restricted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='DivinationCard'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_2, m_util.html.poe_color('divination', i18n.upgraded_from_tooltips.divination_card))
 
end,
 
groups = {
 
{
 
-- Игрок
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheGambler",
 
amount = 5,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_drop_restricted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='DivinationCard'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_2, m_util.html.poe_color('divination', i18n.upgraded_from_tooltips.divination_card))
 
end,
 
groups = {
 
{
 
-- Колода карт
 
item_id = "Metadata/Items/DivinationCards/DivinationCardDeck",
 
amount = 1,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_drop_restricted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='DivinationCard'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_2, m_util.html.poe_color('divination', i18n.upgraded_from_tooltips.divination_card))
 
end,
 
groups = {
 
{
 
-- Инкубатор предсказателя
 
item_id = "Metadata/Items/Currency/CurrencyIncubationDivination",
 
amount = 1,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', value='Helmet'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_eternal_labyrinth_enchantment, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.helmet))
 
end,
 
groups = {
 
{
 
-- Божественное правосудие
 
item_id = "Metadata/Items/DivinationCards/DivinationCardDivineJustice",
 
amount = 1,
 
},
 
},
 
},
 
--
 
-- Multiple classes
 
--
 
{
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', values={'One Hand Axe', 'Two Hand Axe'}},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.axe))
 
end,
 
groups = {
 
{
 
-- Воитель
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheBattleBorn",
 
amount = 5,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', value='Active Skill Gem'},
 
h.conditions.factory.arg{arg='gem_tags', value=m_game.constants.item.gem_tags.aura.tag},
 
h.conditions.factory.arg{arg='max_level', value=20},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.level_x_y_gem, m_game.constants.item.gem_tags.aura.tag, 21)))
 
end,
 
groups = {
 
{
 
-- Увядшая роза
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheWiltedRose",
 
amount = 7,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', values_assoc=core.class_groups.gems.keys},
 
h.conditions.factory.arg{arg='max_level', value=20},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.level_x_gem, 20)))
 
end,
 
groups = {
 
{
 
-- Лиса
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheFox",
 
amount = 6,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', values_assoc=core.class_groups.gems.keys},
 
h.conditions.factory.arg{arg='gem_tags', value=m_game.constants.item.gem_tags.minion.tag},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.superior_x_gem_q_y, m_game.constants.item.gem_tags.minion.tag, 20)))
 
end,
 
groups = {
 
{
 
-- Призыватель
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheSummoner",
 
amount = 6,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', values_assoc=core.class_groups.gems.keys},
 
-- since this is checking against an array, it will check if it contains the "Spell" value
 
h.conditions.factory.arg{arg='gem_tags', value=m_game.constants.item.gem_tags.spell.tag},
 
h.conditions.factory.arg{arg='max_level', value=20},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.level_x_y_gem, m_game.constants.item.gem_tags.spell.tag, 21)))
 
end,
 
groups = {
 
{
 
--Катаклизм
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheCataclysm",
 
amount = 13,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', values_assoc=core.class_groups.gems.keys},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.superior_gem_q_x, 20)))
 
end,
 
groups = {
 
{
 
-- Клятва камнерезчика
 
item_id = "Metadata/Items/DivinationCards/DivinationCardGemcuttersPromise",
 
amount = 3,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', values_assoc=core.class_groups.armor.keys},
 
h.conditions.factory.arg{arg='tags', value='int_armour'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('magic', string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='LocalIncreasedEnergyShieldPercentAndStunRecovery6'}}, i18n.upgraded_from_tooltips.armour)))
 
end,
 
groups = {
 
{
 
-- Инокулированный
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheInoculated",
 
amount = 4,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', values_assoc=core.class_groups.armor.keys},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('magic', string.format('%s %s', i18n.upgraded_from_tooltips.armour, i18n.upgraded_from_tooltips.life)))
 
end,
 
groups = {
 
{
 
-- Чёрный ворон
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheCarrionCrow",
 
amount = 4,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', values={'Ring', 'Amulet', 'Belt'}},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_shaper_item_level_x_2, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.jewellery), 100)
 
end,
 
groups = {
 
{
 
-- Идеал
 
item_id = "Metadata/Items/DivinationCards/DivinationCardPerfection",
 
amount = 5,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique, --Редкость
 
h.conditions.factory.arg{arg='class_id', values={'Ring', 'Amulet', 'Belt'}}, --Поиск по классу предмета, конкретика на кольца, амулеты, пояса.
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_2, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.jewellery)) --Описание, случайная(random_2 склонение.) уникальная(unique) бижутерия (jewellery).
 
end,
 
groups = {
 
{
 
-- Тайник (гадальная карта)
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheCache", --ID Предмета, с которого будет падать бижутерия запрошенная выше.
 
amount = 6, --Количество кароточек, для полной колоны гадальных карт.
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal, --Редкость
 
h.conditions.factory.arg{arg='class_id', values={'Ring', 'Amulet', 'Belt'}}, --Поиск по классу предмета, конкретика на кольца, амулеты, пояса.
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_two_influenced_x_2, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.jewellery), 86) --Описание, случайная(random_2 склонение.) уникальная(unique) бижутерия (jewellery).
 
end,
 
groups = {
 
{
 
-- Пробуждённые
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheAwakened", --ID Предмета, с которого будет падать бижутерия запрошенная выше.
 
amount = 6, --Количество кароточек, для полной колоны гадальных карт.
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', values={'Sceptre', 'Dagger', 'Wand', 'Rune Dagger'}},
 
h.conditions.factory.arg{arg='tags', value='attack_dagger', negate=true},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_two_influenced_x_3, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.one_hand_weapon), 100) --Описание, случайная(random_2 склонение.) уникальная(unique) бижутерия (jewellery).
 
end,
 
groups = {
 
{
 
-- Кузня Прометея
 
item_id = "Metadata/Items/DivinationCards/DivinationCardPrometheusArmoury", --ID Предмета, с которого будет падать бижутерия запрошенная выше.
 
amount = 6, --Количество кароточек, для полной колоны гадальных карт.
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', values={'Ring', 'Amulet', 'Belt'}},
 
function (tpl_args, frame)
 
return tpl_args.drop_level <= 79
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x_2, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.jewellery), 79)
 
end,
 
groups = {
 
{
 
-- Любовник
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheLover",
 
amount = 2,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', values={'Ring', 'Amulet'}},
 
function (tpl_args, frame)
 
return tpl_args.drop_level <= 85
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x_2, m_util.html.poe_color('magic', string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='ReduceGlobalFlatManaCostStrIntMasterVendor'}}, i18n.upgraded_from_tooltips.jewellery)), 85)
 
end,
 
groups = {
 
{
 
-- Благословение Господа
 
item_id = "Metadata/Items/DivinationCards/DivinationCardBlessingOfGod",
 
amount = 3,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', values={'Ring', 'Amulet'}},
 
function (tpl_args, frame)
 
return tpl_args.drop_level <= 76
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x_2, m_util.html.poe_color('magic', string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='AddedLightningDamage9'}}, i18n.upgraded_from_tooltips.jewellery)), 76)
 
end,
 
groups = {
 
{
 
-- Поражённый молнией
 
item_id = "Metadata/Items/DivinationCards/DivinationCardStruckByLightning",
 
amount = 3,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', values={'Ring', 'Amulet', 'Belt'}},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_shaper_hunter_item_level_x_2, m_util.html.poe_color('magic', string.format('%s %s', i18n.upgraded_from_tooltips.jewellery, frame:expandTemplate{title='Modifier link',args={id='GrantsCatAspectCrafted'}})), 100)
 
end,
 
groups = {
 
{
 
-- Знакомый зов
 
item_id = "Metadata/Items/DivinationCards/DivinationCardAFamiliarCall",
 
amount = 3,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', values={'Two Hand Sword', 'Two Hand Axe', 'Two Hand Mace', 'Staff', 'Bow', 'Warstaff'}},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x_3, m_util.html.poe_color('magic', string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='LocalIncreasedPhysicalDamagePercent8'}}, i18n.upgraded_from_tooltips.two_hand_weapon)), 100)
 
end,
 
groups = {
 
{
 
-- Безжалостное орудие
 
item_id = "Metadata/Items/DivinationCards/DivinationCardMercilessArmament",
 
amount = 4,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', values={'Thrusting One Hand Sword', 'One Hand Sword', 'One Hand Axe', 'One Hand Mace', 'Sceptre', 'Dagger', 'Claw', 'Wand', 'Rune Dagger'}},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x_3, m_util.html.poe_color('magic', string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='LocalIncreasedPhysicalDamagePercent8'}}, i18n.upgraded_from_tooltips.one_hand_weapon)), 100)
 
end,
 
groups = {
 
{
 
-- Шут
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheJester",
 
amount = 9,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', values={'Sceptre', 'Dagger', 'Wand', 'Rune Dagger'}},
 
h.conditions.factory.arg{arg='tags', value='attack_dagger', negate=true},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x_3, m_util.html.poe_color('magic', string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='SpellDamageOnWeapon8_'}}, i18n.upgraded_from_tooltips.one_hand_weapon)), 100)
 
end,
 
groups = {
 
{
 
-- Путь к власти
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheRoadToPower",
 
amount = 7,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', values={'Thrusting One Hand Sword', 'One Hand Sword', 'Two Hand Sword'}},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.sword))
 
end,
 
groups = {
 
{
 
-- Джентльмен
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheGentleman",
 
amount = 4,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', values_assoc=core.class_groups.weapons.keys},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_item_level_x_3, m_util.html.poe_color('magic',string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='LocalIncreasedPhysicalDamagePercent8'}}, i18n.upgraded_from_tooltips.weapon)), 100)
 
end,
 
groups = {
 
{
 
-- Тиран
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheTyrant",
 
amount = 9,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='class_id', values_assoc=core.class_groups.weapons.keys},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_3, m_util.html.poe_color('magic', string.format('%s %s', i18n.upgraded_from_tooltips.weapon, frame:expandTemplate{title='Modifier link',args={id='StrIntMasterItemGenerationCanHaveMultipleCraftedMods'}})))
 
end,
 
groups = {
 
{
 
-- Паутина
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheWeb",
 
amount = 8,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', values_assoc=core.class_groups.weapons.keys},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_corrupted_3, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.weapon))
 
end,
 
groups = {
 
{
 
-- Арсенал Атзири
 
item_id = "Metadata/Items/DivinationCards/DivinationCardAtzirisArsenal",
 
amount = 4,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.normal,
 
-- в частности исключите критические флаконы
 
h.conditions.factory.arg{arg='class_id', values_assoc={['LifeFlask'] = true, ['ManaFlask'] = true, ['HybridFlask'] = true, ['UtilityFlask'] = true}},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('magic', string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='FlaskChanceRechargeOnCrit1'}}, i18n.upgraded_from_tooltips.flask)))
 
end,
 
groups = {
 
{
 
-- Хирург
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheSurgeon",
 
amount = 4,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
function (tpl_args, frame)
 
return tpl_args.drop_leagues ~= nil and #tpl_args.drop_leagues ~= 0
 
end
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.league_specific_item))
 
end,
 
groups = {
 
{
 
-- Утерянная реликвия
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTimeLostRelic",
 
amount = 10,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
function (tpl_args, frame)
 
return tpl_args.drop_leagues ~= nil and #tpl_args.drop_leagues ~= 0
 
end
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.league_specific_item))
 
end,
 
groups = {
 
{
 
-- Судьбоносная встреча
 
item_id = "Metadata/Items/DivinationCards/DivinationCardFatefulMeeting",
 
amount = 9,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
function (tpl_args, frame)
 
return tpl_args.drop_leagues ~= nil and #tpl_args.drop_leagues ~= 0
 
end
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.league_specific_item))
 
end,
 
groups = {
 
{
 
-- Затерянный во времени инкубатор
 
item_id = "Metadata/Items/Currency/CurrencyIncubationUniqueLeague",
 
amount = 1,
 
},
 
},
 
},
 
--
 
-- Generic items
 
--
 
{
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='drop_rarities_ids', value='rare'},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_elder_item_level_x, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.item), 100)
 
end,
 
groups = {
 
{
 
-- Крепкое сердце
 
item_id = "Metadata/Items/DivinationCards/DivinationCardTheHaleHeart",
 
amount = 4,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_drop_restricted = false,
 
},
 
condition = {
 
h.conditions.normal,
 
h.conditions.factory.arg{arg='base_item_id', value='Metadata/Items/Currency/CurrencyItemisedProphecy'},
 
function (tpl_args, frame)
 
return string.find(tpl_args.prediction_text, 'пока у тебя есть')
 
end,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('prophecy', i18n.upgraded_from_tooltips.fated_item))
 
end,
 
groups = {
 
{
 
-- Пророчество Акила
 
item_id = "Metadata/Items/DivinationCards/DivinationCardAkilsProphecy",
 
amount = 3,
 
},
 
},
 
},
 
{
 
defaults = {
 
is_corrupted = false,
 
},
 
condition = {
 
h.conditions.unique,
 
h.conditions.factory.arg{arg='class_id', values_assoc={['LifeFlask'] = true, ['ManaFlask'] = true, ['HybridFlask'] = true, ['UtilityFlask'] = true, ['UtilityFlaskCritical'] = true, ['Map'] = true}, negate=true},
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random_two_implicit_corrupted, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.item))
 
end,
 
groups = {
 
{
 
-- Высокомерие ваал
 
item_id = "Metadata/Items/DivinationCards/DivinationCardArroganceOfTheVaal",
 
amount = 8,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.item))
 
end,
 
groups = {
 
{
 
-- Сюрприз
 
item_id = "Metadata/Items/DivinationCards/DivinationCardJackInTheBox",
 
amount = 4,
 
},
 
},
 
},
 
{
 
condition = {
 
h.conditions.unique,
 
},
 
text = function (tpl_args, frame)
 
return string.format(i18n.upgraded_from_tooltips.f.random, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.item))
 
end,
 
groups = {
 
{
 
-- Необычный инкубатор
 
item_id = "Metadata/Items/Currency/CurrencyIncubationUniques",
 
amount = 1,
 
},
 
},
 
 
},
 
},
-- TODO: The void?
 
 
}
 
}
   
Строка 7160: Строка 460:
 
-- Contents here are meant to resemble the ingame infobox of items
 
-- Contents here are meant to resemble the ingame infobox of items
 
--
 
--
  +
c.item_infobox_groups = {
core.item_display_groups = {
 
-- Tags, stats, level, etc
+
-- [n]:
-- group
+
-- class: Additional css class added to group tag
-- group[n].args -
+
-- heading: Group heading text (used for extras)
-- group[n].func -
+
-- lines:
  +
-- [n]:
-- group[n].inline - if set to false, don't add to html for the inline infobox, but still show this field on the item page
 
  +
-- show: Show line if this function returns true; Always show if boolean true. Default: Always show
  +
-- func: Function that returns line text
 
{
 
{
  +
-- Cosmetic item type
 
{
 
{
args = {'cosmetic_type'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'cosmetic_type'},
options = {
+
conditions = {processed = true},
[1] = {
+
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'cosmetic_type',
 
key = 'cosmetic_type',
 
fmt = '%s',
 
fmt = '%s',
Строка 7179: Строка 485:
 
},
 
},
 
},
 
},
  +
-- Weapon type
 
{
 
{
args = function(tpl_args, frame)
+
show = function (tpl_args, frame)
 
if tpl_args.class_id == nil then
 
if tpl_args.class_id == nil then
 
return false
 
return false
 
end
 
end
+
return cfg.class_groups.weapons.keys[tpl_args.class_id] ~= nil
return core.class_groups.weapons.keys[tpl_args.class_id] ~= nil
 
 
end,
 
end,
func = function(tpl_args, frame)
+
func = function (tpl_args, frame)
local v = i18n.tooltips.item_class_map[tpl_args.class_id]
+
local v = i18n.item_class_map[tpl_args.class_id]
 
return m_util.html.format_value(tpl_args, frame, {min=v, max=v}, {color = 'default'})
 
return m_util.html.format_value(tpl_args, frame, {min=v, max=v}, {color = 'default'})
 
end,
 
end,
 
},
 
},
  +
-- Hideout item type
 
{
 
{
args = {'gem_tags'},
+
show = function (tpl_args, frame)
func = function(tpl_args, frame)
+
return tpl_args.class_id == 'HideoutDoodad'
  +
end,
  +
func = function (tpl_args, frame)
  +
return i18n.item_class_map[tpl_args.class_id]
  +
end,
  +
},
  +
{
  +
show = h.factory.maybe_show_infobox_line{
  +
keys = {'gem_tags'},
  +
conditions = {processed = true},
  +
},
  +
func = function (tpl_args, frame)
 
local out = {}
 
local out = {}
 
for i, tag in ipairs(tpl_args.gem_tags) do
 
for i, tag in ipairs(tpl_args.gem_tags) do
 
out[#out+1] = string.format(i18n.gem_tag_category, tag, tag)
 
out[#out+1] = string.format(i18n.gem_tag_category, tag, tag)
 
end
 
end
 
 
return table.concat(out, ', ')
 
return table.concat(out, ', ')
 
end,
 
end,
 
},
 
},
 
{
 
{
  +
show = h.factory.maybe_show_infobox_line{
args = {'support_gem_letter_html'},
 
func = core.factory.display_value{
+
keys = {'support_gem_letter_html'},
options = {
+
conditions = {processed = true},
[1] = {
+
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'support_gem_letter_html',
 
key = 'support_gem_letter_html',
inline = i18n.tooltips.support_icon,
 
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.support_icon,
 
},
 
},
 
},
 
},
 
{
 
{
args = {'radius'},
+
show = function (tpl_args, frame)
  +
return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
func = core.factory.display_value{
 
options = {
+
end,
[1] = {
+
func = function (tpl_args, frame)
key = 'radius',
+
local value = {
inline = i18n.tooltips.radius,
+
base = 1,
func = core.factory.descriptor_value{key='radius_description'},
+
min = 1,
},
+
max = tpl_args.max_level,
[2] = {
+
}
key = 'radius_secondary',
+
local options = {
inline = ' / %s',
+
color = 'value',
  +
}
func = core.factory.descriptor_value{key='radius_secondary_description'},
 
},
+
return string.format(
[3] = {
+
i18n.tooltips.level,
key = 'radius_tertiary',
+
m_util.html.format_value(tpl_args, frame, value, options)
inline = ' / %s',
+
)
  +
end,
func = core.factory.descriptor_value{key='radius_tertiary_description'},
 
},
 
},
 
},
 
 
},
 
},
-- TODO: gem level here. Maybe put max level here?
 
 
{
 
{
args = nil,
+
show = function (tpl_args, frame)
func = core.factory.display_value{
+
return tpl_args.skill_costs
type='gem',
+
end,
options = {
+
func = function (tpl_args, frame)
[1] = {
+
local parts = {}
key = 'mana_cost',
+
if not tpl_args.skill_costs.has_spending_cost then
hide_default = 100,
+
-- Try falling back to deprecated parameters
fmt = function (tpl_args, frame)
+
if not tpl_args.has_reservation_mana_cost then
if tpl_args.has_percentage_mana_cost then
+
parts[1] = {
return '%i%%'
+
key = 'mana_cost',
else
+
fmt = '%i',
return '%i'
+
color = false,
end
+
inline = string.format('%%s %s', m_game.constants.skill.cost_types.mana.long_upper),
end,
+
inline_color = 'value',
inline = function (tpl_args, frame)
+
}
if tpl_args.has_reservation_mana_cost then
+
end
return i18n.tooltips.mana_reserved
+
else
else
+
for i=1, #tpl_args.skill_costs do
return i18n.tooltips.mana_cost
+
if not tpl_args.skill_costs[i].is_reservation then -- Only get spending costs
end
+
local cost_type = tpl_args.skill_costs[i].type
end,
+
parts[#parts+1] = {
},
+
key = {'costs', i, 'amount'},
},
+
fmt = '%i',
},
+
color = false,
  +
inline = string.format(
  +
'%%s%s %s',
  +
string.find(cost_type, 'percent', 1, true) and '%%' or '',
  +
m_game.constants.skill.cost_types[cost_type].long_upper
  +
),
  +
inline_color = 'value',
  +
}
  +
end
  +
end
  +
end
  +
return core.factory.infobox_line{
  +
type = 'gem',
  +
parts = parts,
  +
sep = ', ',
  +
fmt = i18n.tooltips.cost,
  +
}(tpl_args, frame)
  +
end,
 
},
 
},
 
{
 
{
args = nil,
+
show = function (tpl_args, frame)
func = core.factory.display_value{
+
return tpl_args.skill_costs
type='gem',
+
end,
options = {
+
func = function (tpl_args, frame)
[1] = {
+
if not tpl_args.skill_costs then
  +
return
  +
end
  +
local parts = {}
  +
if not tpl_args.skill_costs.has_reservation_cost then
  +
-- Try falling back to deprecated parameters
  +
if tpl_args.has_reservation_mana_cost then
  +
parts[1] = {
  +
key = 'mana_cost',
  +
fmt = '%i',
  +
color = false,
  +
inline = string.format(
  +
'%%s%s %s',
  +
tpl_args.has_percentage_mana_cost and '%%' or '',
  +
m_game.constants.skill.cost_types.mana.long_upper
  +
),
  +
inline_color = 'value',
  +
}
  +
end
  +
else
  +
for i=1, #tpl_args.skill_costs do
  +
if tpl_args.skill_costs[i].is_reservation then -- Only get reservation costs
  +
local cost_type = tpl_args.skill_costs[i].type
  +
parts[#parts+1] = {
  +
key = {'costs', i, 'amount'},
  +
fmt = '%i',
  +
color = false,
  +
inline = string.format(
  +
'%%s%s %s',
  +
string.find(cost_type, 'percent', 1, true) and '%%' or '',
  +
m_game.constants.skill.cost_types[cost_type].long_upper
  +
),
  +
inline_color = 'value',
  +
}
  +
end
  +
end
  +
end
  +
return core.factory.infobox_line{
  +
type = 'gem',
  +
parts = parts,
  +
sep = ', ',
  +
fmt = i18n.tooltips.reservation,
  +
}(tpl_args, frame)
  +
end,
  +
},
  +
{
  +
show = true, -- TODO: Show only if has mana_multiplier
  +
func = core.factory.infobox_line{
  +
type = 'gem',
  +
parts = {
  +
{
 
key = 'mana_multiplier',
 
key = 'mana_multiplier',
 
hide_default = 100,
 
hide_default = 100,
fmt = '%i%%',
+
fmt = '%i',
inline = i18n.tooltips.mana_multiplier,
+
color = false,
  +
inline = '%s%%',
  +
inline_color = 'value',
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.mana_multiplier,
 
},
 
},
 
},
 
},
-- TODO: i18n
 
 
{
 
{
args = nil,
+
show = true, -- TODO: Show only if has cooldown
func = core.factory.display_value{
+
func = core.factory.infobox_line{
type='gem',
+
type = 'gem',
options = {
+
parts = {
[1] = {
+
{
key = 'vaal_souls_requirement',
+
key = 'cooldown',
 
hide_default = 0,
 
hide_default = 0,
fmt = '%i (N) / ',
+
fmt = '%.2f ' .. m_game.units.seconds.short_lower,
inline = i18n.tooltips.vaal_souls_per_use,
 
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.cooldown_time,
 
},
 
},
 
},
 
},
 
{
 
{
  +
-- TODO: Combine with cooldown. Multi-use non-vaal skills display uses together with cooldown time. E.g., Cooldown Time: 8.00 sec (3 uses)
args = nil,
 
func = core.factory.display_value{
+
show = true,
type='gem',
+
func = core.factory.infobox_line{
options = {
+
type = 'gem',
[1] = {
+
parts = {
key = 'vaal_stored_uses',
+
{
  +
key = 'stored_uses',
 
hide_default = 0,
 
hide_default = 0,
 
fmt = '%i',
 
fmt = '%i',
inline = i18n.tooltips.stored_uses,
 
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.stored_uses,
 
},
 
},
 
},
 
},
 
{
 
{
args = nil,
+
show = true, -- TODO: Show only if has vaal_souls_requirement
func = core.factory.display_value{
+
func = core.factory.infobox_line{
type='gem',
+
type = 'gem',
options = {
+
parts = {
[1] = {
+
{
key = 'stored_uses',
+
key = 'vaal_souls_requirement',
 
hide_default = 0,
 
hide_default = 0,
 
fmt = '%i',
 
fmt = '%i',
inline = i18n.tooltips.stored_uses,
 
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.vaal_souls_per_use,
 
},
 
},
 
},
 
},
 
{
 
{
args = nil,
+
show = true, -- TODO: Show only if has vaal_stored_uses
func = core.factory.display_value{
+
func = core.factory.infobox_line{
type='gem',
+
type = 'gem',
options = {
+
parts = {
[1] = {
+
{
key = 'vaal_soul_gain_prevention_time',
+
key = 'vaal_stored_uses',
 
hide_default = 0,
 
hide_default = 0,
-- Technically it rounds to nearest, but it is given in milliseconds in the data,
+
fmt = '%i',
fmt = '%.3f сек.',
 
inline = i18n.tooltips.vaal_soul_gain_prevention_time,
 
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.stored_uses, -- TODO: Singular or plural based on number
 
},
 
},
 
},
 
},
 
{
 
{
  +
show = true, -- TODO: Show only if has vaal_soul_gain_prevention_time
args = nil,
 
func = core.factory.display_value{
+
func = core.factory.infobox_line{
type='gem',
+
type = 'gem',
options = {
+
parts = {
[1] = {
+
{
key = 'cooldown',
+
key = 'vaal_soul_gain_prevention_time',
 
hide_default = 0,
 
hide_default = 0,
fmt = '%.2f сек.',
+
-- Technically it rounds to nearest, but it is given in milliseconds in the data,
inline = i18n.tooltips.cooldown_time,
+
fmt = '%i ' .. m_game.units.seconds.short_lower,
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.vaal_soul_gain_prevention_time,
 
},
 
},
 
},
 
},
 
{
 
{
args = {'cast_time'},
+
show = function (tpl_args, frame)
  +
return tpl_args.cast_time and tpl_args.gem_tags and (m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.spell.tag) or m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.warcry.tag))
func = core.factory.display_value{
 
options = {
+
end,
[1] = {
+
func = function (tpl_args, frame)
key = 'cast_time',
+
return core.factory.infobox_line{
hide_default = 0,
+
parts = {
fmt = '%.2f сек.',
+
{
inline = i18n.tooltips.cast_time,
+
key = 'cast_time',
  +
fmt = function (tpl_args, frame, value)
  +
if value.min == 0 then
  +
return i18n.tooltips.instant_cast_time
  +
end
  +
return '%.2f ' .. m_game.units.seconds.short_lower
  +
end,
  +
},
 
},
 
},
  +
fmt = m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.spell.tag) and i18n.tooltips.cast_time or i18n.tooltips.use_time,
},
 
},
+
}(tpl_args, frame)
  +
end,
 
},
 
},
 
{
 
{
args = nil,
+
show = true, -- TODO: Show only if has critical_strike_chance
func = core.factory.display_value{
+
func = core.factory.infobox_line{
type='gem',
+
type = 'gem',
options = {
+
parts = {
[1] = {
+
{
 
key = 'critical_strike_chance',
 
key = 'critical_strike_chance',
 
hide_default = 0,
 
hide_default = 0,
 
fmt = '%.2f%%',
 
fmt = '%.2f%%',
inline = i18n.tooltips.critical_strike_chance,
 
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.critical_strike_chance,
 
},
 
},
 
},
 
},
 
{
 
{
args = nil,
+
show = true, -- TODO: Show only if has attack_speed_multiplier
func = core.factory.display_value{
+
func = core.factory.infobox_line{
type='gem',
+
type = 'gem',
options = {
+
parts = {
[1] = {
+
{
 
key = 'attack_speed_multiplier',
 
key = 'attack_speed_multiplier',
 
hide_default = 100,
 
hide_default = 100,
fmt = i18n.tooltips.attack_speed_multiplier_fmt,
+
fmt = '%i',
inline = i18n.tooltips.attack_speed_multiplier,
+
color = false,
  +
inline = '%s%% ' .. i18n.tooltips.of_base_stat,
  +
inline_color = 'value',
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.attack_speed_multiplier,
 
},
 
},
 
},
 
},
 
{
 
{
args = nil,
+
show = true, -- TODO: Show only if has damage_multiplier
func = core.factory.display_value{
+
func = core.factory.infobox_line{
type='gem',
+
type = 'gem',
options = {
+
parts = {
[1] = {
+
{
  +
key = 'damage_multiplier',
  +
hide_default = 100,
  +
fmt = '%i',
  +
color = false,
  +
inline = '%s%% ' .. i18n.tooltips.of_base_stat,
  +
inline_color = 'value',
  +
},
  +
},
  +
fmt = i18n.tooltips.damage_multiplier,
  +
},
  +
},
  +
{
  +
show = true, -- TODO: Show only if has damage_effectiveness
  +
func = core.factory.infobox_line{
  +
type = 'gem',
  +
parts = {
  +
{
 
key = 'damage_effectiveness',
 
key = 'damage_effectiveness',
 
hide_default = 100,
 
hide_default = 100,
fmt = '%i%%',
+
fmt = '%i',
inline = i18n.tooltips.damage_effectiveness,
+
color = false,
  +
inline = '%s%%',
  +
inline_color = 'value',
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.damage_effectiveness,
 
},
 
},
 
},
 
},
 
{
 
{
args = {'projectile_speed'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'projectile_speed'},
options = {
+
},
[1] = {
+
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'projectile_speed',
 
key = 'projectile_speed',
inline = i18n.tooltips.projectile_speed,
 
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.projectile_speed,
  +
},
  +
},
  +
{
  +
show = h.factory.maybe_show_infobox_line{
  +
keys = {'radius'},
  +
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
  +
key = 'radius',
  +
func = h.factory.descriptor_value{key='radius_description'},
  +
},
  +
{
  +
key = 'radius_secondary',
  +
func = h.factory.descriptor_value{key='radius_secondary_description'},
  +
},
  +
{
  +
key = 'radius_tertiary',
  +
func = h.factory.descriptor_value{key='radius_tertiary_description'},
  +
},
  +
},
  +
sep = ' / ',
  +
fmt = i18n.tooltips.radius,
 
},
 
},
 
},
 
},
 
-- Quality is before item stats, but after gem stuff and item class
 
-- Quality is before item stats, but after gem stuff and item class
 
{
 
{
args = {'quality'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'quality'},
options = {
+
conditions = {processed = true},
[1] = {
+
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'quality',
 
key = 'quality',
 
fmt = '+%i%%',
 
fmt = '+%i%%',
 
color = 'mod',
 
color = 'mod',
inline = i18n.tooltips.quality,
 
 
hide_default = 0,
 
hide_default = 0,
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.quality,
 
},
 
},
 
},
 
},
 
-- Weapon only
 
-- Weapon only
 
{
 
{
args = {'physical_damage_html'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'physical_damage_html'},
options = {
+
conditions = {processed = true},
[1] = {
+
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'physical_damage_html',
 
key = 'physical_damage_html',
 
fmt = '%s',
 
fmt = '%s',
inline = i18n.tooltips.physical_damage,
 
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.physical_damage,
 
},
 
},
 
},
 
},
 
{
 
{
args = nil,
+
show = true, -- Elemental Damage
func = function(tpl_args, frame)
+
func = function (tpl_args, frame)
local text = ''
+
local keys = {'fire_damage_html', 'cold_damage_html', 'lightning_damage_html'}
  +
local elements = {}
for _, dtype in ipairs({'fire_damage_html', 'cold_damage_html', 'lightning_damage_html'}) do
 
local value = tpl_args[dtype]
+
for _, key in ipairs(keys) do
if value ~= nil then
+
if tpl_args[key] then
text = text .. ' ' .. value
+
elements[#elements+1] = tpl_args[key]
 
end
 
end
 
end
 
end
  +
local text = table.concat(elements, ', ') -- returns empty string if elements is empty
 
 
if text ~= '' then
 
if text ~= '' then
 
return string.format(i18n.tooltips.elemental_damage, text)
 
return string.format(i18n.tooltips.elemental_damage, text)
else
 
return
 
 
end
 
end
  +
return
 
end,
 
end,
 
},
 
},
 
{
 
{
args = {'chaos_damage_html'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'chaos_damage_html'},
options = {
+
conditions = {processed = true},
[1] = {
+
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'chaos_damage_html',
 
key = 'chaos_damage_html',
 
fmt = '%s',
 
fmt = '%s',
inline = i18n.tooltips.chaos_damage,
+
color = false, -- html already has color
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.chaos_damage,
 
},
 
},
 
},
 
},
 
{
 
{
  +
show = h.factory.maybe_show_infobox_line{
args = {'critical_strike_chance_html'},
 
  +
keys = {'critical_strike_chance_html'},
func = core.factory.display_value{
 
options = {
+
},
[1] = {
+
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'critical_strike_chance_html',
 
key = 'critical_strike_chance_html',
 
fmt = '%s',
 
fmt = '%s',
inline = i18n.tooltips.critical_strike_chance,
 
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.critical_strike_chance,
 
},
 
},
 
},
 
},
 
{
 
{
args = {'attack_speed_html'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'attack_speed_html'},
options = {
+
},
[1] = {
+
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'attack_speed_html',
 
key = 'attack_speed_html',
 
fmt = '%s',
 
fmt = '%s',
inline = i18n.tooltips.attacks_per_second,
 
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.attacks_per_second,
 
},
 
},
 
},
 
},
 
{
 
{
args = {'weapon_range_html'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'weapon_range_html'},
options = {
+
},
[1] = {
+
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'weapon_range_html',
 
key = 'weapon_range_html',
 
fmt = '%s',
 
fmt = '%s',
inline = i18n.tooltips.weapon_range,
 
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.weapon_range,
 
},
 
},
 
},
 
},
 
-- Map only
 
-- Map only
 
{
 
{
args = {'map_area_level'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'map_area_level'},
options = {
+
conditions = {processed = true},
[1] = {
+
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'map_area_level',
 
key = 'map_area_level',
 
fmt = '%i',
 
fmt = '%i',
inline = i18n.tooltips.map_level,
 
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.map_level,
 
},
 
},
 
},
 
},
 
{
 
{
args = {'map_tier'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'map_tier'},
options = {
+
conditions = {processed = true},
[1] = {
+
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'map_tier',
 
key = 'map_tier',
 
fmt = '%i',
 
fmt = '%i',
inline = i18n.tooltips.map_tier,
 
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.map_tier,
 
},
 
},
 
},
 
},
 
{
 
{
args = function(tpl_args, frame)
+
show = function (tpl_args, frame)
 
return tpl_args.map_guild_character ~= nil and tpl_args.rarity_id == 'normal'
 
return tpl_args.map_guild_character ~= nil and tpl_args.rarity_id == 'normal'
 
end,
 
end,
func = core.factory.display_value{
+
func = core.factory.infobox_line{
options = {
+
parts = {
[1] = {
+
{
 
key = 'map_guild_character',
 
key = 'map_guild_character',
 
fmt = '%s',
 
fmt = '%s',
inline = i18n.tooltips.map_guild_character,
 
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.map_guild_character,
 
},
 
},
 
},
 
},
 
{
 
{
args = function(tpl_args, frame)
+
show = function (tpl_args, frame)
 
return tpl_args.unique_map_guild_character ~= nil and tpl_args.rarity_id == 'unique'
 
return tpl_args.unique_map_guild_character ~= nil and tpl_args.rarity_id == 'unique'
 
end,
 
end,
func = core.factory.display_value{
+
func = core.factory.infobox_line{
options = {
+
parts = {
[1] = {
+
{
 
key = 'unique_map_guild_character',
 
key = 'unique_map_guild_character',
 
fmt = '%s',
 
fmt = '%s',
inline = i18n.tooltips.map_guild_character,
 
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.map_guild_character,
 
},
 
},
 
},
 
},
 
{
 
{
args = nil,
+
show = true,
func = core.factory.display_value{
+
func = core.factory.infobox_line{
 
type = 'stat',
 
type = 'stat',
options = {
+
parts = {
[1] = {
+
{
 
key = 'map_item_drop_quantity_+%',
 
key = 'map_item_drop_quantity_+%',
 
fmt = '+%i%%',
 
fmt = '+%i%%',
 
color = 'mod',
 
color = 'mod',
inline = i18n.tooltips.item_quantity,
 
 
hide_default = 0,
 
hide_default = 0,
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.item_quantity,
 
},
 
},
 
},
 
},
 
{
 
{
args = nil,
+
show = true,
func = core.factory.display_value{
+
func = core.factory.infobox_line{
 
type = 'stat',
 
type = 'stat',
options = {
+
parts = {
[1] = {
+
{
 
key = 'map_item_drop_rarity_+%',
 
key = 'map_item_drop_rarity_+%',
 
fmt = '+%i%%',
 
fmt = '+%i%%',
 
color = 'mod',
 
color = 'mod',
inline = i18n.tooltips.item_rarity,
 
 
hide_default = 0,
 
hide_default = 0,
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.item_rarity,
 
},
 
},
 
},
 
},
 
{
 
{
args = nil,
+
show = true,
func = core.factory.display_value{
+
func = core.factory.infobox_line{
 
type = 'stat',
 
type = 'stat',
options = {
+
parts = {
[1] = {
+
{
 
key = 'map_pack_size_+%',
 
key = 'map_pack_size_+%',
 
fmt = '+%i%%',
 
fmt = '+%i%%',
 
color = 'mod',
 
color = 'mod',
inline = i18n.tooltips.monster_pack_size,
 
 
hide_default = 0,
 
hide_default = 0,
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.monster_pack_size,
 
},
 
},
 
},
 
},
 
-- Jewel Only
 
-- Jewel Only
 
{
 
{
args = nil,
+
show = true,
func = core.factory.display_value{
+
func = core.factory.infobox_line{
options = {
+
parts = {
[1] = {
+
{
 
key = 'item_limit',
 
key = 'item_limit',
 
fmt = '%i',
 
fmt = '%i',
inline = i18n.tooltips.limited_to,
 
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.limited_to,
 
},
 
},
 
},
 
},
 
{
 
{
args = {'jewel_radius_html'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'jewel_radius_html'},
options = {
+
conditions = {processed = true},
[1] = {
+
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'jewel_radius_html',
 
key = 'jewel_radius_html',
 
fmt = '%s',
 
fmt = '%s',
inline = i18n.tooltips.radius,
+
color = false, -- html already has color
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.radius,
 
},
 
},
 
},
 
},
 
-- Flask only
 
-- Flask only
 
{
 
{
  +
show = h.factory.maybe_show_infobox_line{
args = {'flask_mana_html', 'flask_duration_html'},
 
  +
keys = {'flask_mana_html', 'flask_duration_html'},
  +
},
 
--func = core.factory.display_flask('flask_mana'),
 
--func = core.factory.display_flask('flask_mana'),
func = core.factory.display_value{
+
func = core.factory.infobox_line{
inline = i18n.tooltips.flask_mana_recovery,
+
parts = {
options = {
+
{
[1] = {
 
 
key = 'flask_mana_html',
 
key = 'flask_mana_html',
 
fmt = '%s',
 
fmt = '%s',
 
},
 
},
[2] = {
+
{
 
key = 'flask_duration_html',
 
key = 'flask_duration_html',
 
fmt = '%s',
 
fmt = '%s',
 
},
 
},
}
+
},
  +
fmt = i18n.tooltips.flask_mana_recovery,
 
},
 
},
 
},
 
},
 
{
 
{
  +
show = h.factory.maybe_show_infobox_line{
args = {'flask_life_html', 'flask_duration_html'},
 
  +
keys = {'flask_life_html', 'flask_duration_html'},
func = core.factory.display_value{
 
inline = i18n.tooltips.flask_life_recovery,
+
},
options = {
+
func = core.factory.infobox_line{
[1] = {
+
parts = {
  +
{
 
key = 'flask_life_html',
 
key = 'flask_life_html',
 
fmt = '%s',
 
fmt = '%s',
 
},
 
},
[2] = {
+
{
 
key = 'flask_duration_html',
 
key = 'flask_duration_html',
 
fmt = '%s',
 
fmt = '%s',
 
},
 
},
}
+
},
  +
fmt = i18n.tooltips.flask_life_recovery,
 
},
 
},
 
},
 
},
 
{
 
{
 
-- don't display for mana/life flasks
 
-- don't display for mana/life flasks
args = function(tpl_args, frame)
+
show = function (tpl_args, frame)
 
for _, k in ipairs({'flask_life_html', 'flask_mana_html'}) do
 
for _, k in ipairs({'flask_life_html', 'flask_mana_html'}) do
 
if tpl_args[k] ~= nil then
 
if tpl_args[k] ~= nil then
Строка 7674: Строка 1145:
 
end
 
end
 
end
 
end
 
 
return tpl_args['flask_duration_html'] ~= nil
 
return tpl_args['flask_duration_html'] ~= nil
 
end,
 
end,
func = core.factory.display_value{
+
func = core.factory.infobox_line{
inline = i18n.tooltips.flask_duration,
+
parts = {
options = {
+
{
[1] = {
 
 
key = 'flask_duration_html',
 
key = 'flask_duration_html',
 
fmt = '%s',
 
fmt = '%s',
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.flask_duration,
 
},
 
},
 
},
 
},
 
{
 
{
  +
show = h.factory.maybe_show_infobox_line{
args = {'charges_per_use_html', 'charges_max_html'},
 
  +
keys = {'charges_per_use_html', 'charges_max_html'},
func = core.factory.display_value{
 
inline = i18n.tooltips.flask_charges_per_use,
+
},
options = {
+
func = core.factory.infobox_line{
[1] = {
+
parts = {
  +
{
 
key = 'charges_per_use_html',
 
key = 'charges_per_use_html',
 
fmt = '%s',
 
fmt = '%s',
 
},
 
},
[2] = {
+
{
 
key = 'charges_max_html',
 
key = 'charges_max_html',
 
fmt = '%s',
 
fmt = '%s',
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.flask_charges_per_use,
 
},
 
},
 
},
 
},
 
{
 
{
args = {'buff_stat_text'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'buff_stat_text'},
options = {
+
conditions = {processed = true},
[1] = {
+
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'buff_stat_text',
 
key = 'buff_stat_text',
 
color = 'mod',
 
color = 'mod',
Строка 7714: Строка 1189:
 
},
 
},
 
},
 
},
-- armor
+
-- Armor only
 
{
 
{
args = {'block_html'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'block_html'},
options = {
+
},
[1] = {
+
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'block_html',
 
key = 'block_html',
inline = i18n.tooltips.chance_to_block,
 
 
fmt = '%s',
 
fmt = '%s',
 
hide_default = 0,
 
hide_default = 0,
Строка 7727: Строка 1203:
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.chance_to_block,
 
},
 
},
 
},
 
},
 
{
 
{
args = {'armour_html'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'armour_html'},
options = {
+
},
[1] = {
+
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'armour_html',
 
key = 'armour_html',
inline = i18n.tooltips.armour,
 
 
fmt = '%s',
 
fmt = '%s',
 
hide_default = 0,
 
hide_default = 0,
Строка 7741: Строка 1219:
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.armour,
 
},
 
},
 
},
 
},
 
{
 
{
args = {'evasion_html'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'evasion_html'},
options = {
+
},
[1] = {
+
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'evasion_html',
 
key = 'evasion_html',
inline = i18n.tooltips.evasion,
 
 
fmt = '%s',
 
fmt = '%s',
 
hide_default = 0,
 
hide_default = 0,
Строка 7755: Строка 1235:
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.evasion,
 
},
 
},
 
},
 
},
 
{
 
{
args = {'energy_shield_html'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'energy_shield_html'},
options = {
+
},
[1] = {
+
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'energy_shield_html',
 
key = 'energy_shield_html',
inline = i18n.tooltips.energy_shield,
 
 
fmt = '%s',
 
fmt = '%s',
 
hide_default = 0,
 
hide_default = 0,
Строка 7769: Строка 1251:
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.energy_shield,
 
},
 
},
 
},
 
},
 
{
 
{
args = {'movement_speed'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'ward_html'},
options = {
+
},
[1] = {
+
func = core.factory.infobox_line{
  +
parts = {
  +
{
  +
key = 'ward_html',
  +
fmt = '%s',
  +
hide_default = 0,
  +
hide_default_key = 'ward',
  +
},
  +
},
  +
fmt = i18n.tooltips.ward,
  +
},
  +
},
  +
{
  +
show = h.factory.maybe_show_infobox_line{
  +
keys = {'movement_speed'},
  +
conditions = {processed = true},
  +
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'movement_speed',
 
key = 'movement_speed',
inline = i18n.tooltips.movement_speed,
 
 
fmt = '%s%%',
 
fmt = '%s%%',
 
hide_default = 0,
 
hide_default = 0,
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.movement_speed,
 
},
 
},
 
},
 
},
 
-- Amulet only
 
-- Amulet only
 
{
 
{
args = {'talisman_tier'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'talisman_tier'},
options = {
+
conditions = {processed = true},
[1] = {
+
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'talisman_tier',
 
key = 'talisman_tier',
 
fmt = '%i',
 
fmt = '%i',
inline = i18n.tooltips.talisman_tier,
 
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.talisman_tier,
 
},
 
},
 
},
 
},
 
-- Misc
 
-- Misc
 
{
 
{
args = {'stack_size'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'stack_size'},
options = {
+
conditions = {processed = true},
[1] = {
+
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'stack_size',
 
key = 'stack_size',
hide_default = 1,
 
 
fmt = '%i',
 
fmt = '%i',
inline = i18n.tooltips.stack_size,
+
hide_default = 1,
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.stack_size,
 
},
 
},
 
},
 
},
 
-- Essence stuff
 
-- Essence stuff
 
{
 
{
args = {'essence_level'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'essence_level'},
options = {
+
conditions = {processed = true},
[1] = {
+
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'essence_level',
 
key = 'essence_level',
 
fmt = '%i',
 
fmt = '%i',
inline = i18n.tooltips.essence_level,
 
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.essence_level,
 
},
 
},
 
},
 
},
 
-- Blight items
 
-- Blight items
 
{
 
{
args = {'blight_item_tier'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'blight_item_tier'},
inline = i18n.tooltips.blight_item_tier,
+
conditions = {processed = true},
options = {
+
},
[1] = {
+
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'blight_item_tier',
 
key = 'blight_item_tier',
 
fmt = '%i',
 
fmt = '%i',
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.blight_item_tier,
 
},
 
},
 
},
 
},
-- Harvest seeds (upper section)
+
-- Harvest seeds (upper section)
 
{
 
{
args = {'seed_tier'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'seed_tier'},
inline = i18n.tooltips.seed_tier,
+
conditions = {processed = true},
options = {
+
},
[1] = {
+
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'seed_tier',
 
key = 'seed_tier',
 
fmt = '%i',
 
fmt = '%i',
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.seed_tier,
 
},
 
},
 
},
 
},
 
{
 
{
args = {'seed_tier'},
+
show = h.factory.maybe_show_infobox_line{
  +
keys = {'seed_tier'},
  +
conditions = {processed = true},
  +
},
 
func = function (tpl_args, value)
 
func = function (tpl_args, value)
 
return i18n.tooltips.seed_monster
 
return i18n.tooltips.seed_monster
Строка 7857: Строка 1377:
 
},
 
},
 
{
 
{
args = {'seed_type_html'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'seed_type_html'},
inline = i18n.tooltips.seed_lifeforce_gained,
+
conditions = {processed = true},
options = {
+
},
[1] = {
+
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'seed_type_html',
 
key = 'seed_type_html',
 
fmt = '%s',
 
fmt = '%s',
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.seed_lifeforce_gained,
 
},
 
},
 
},
 
},
 
{
 
{
args = {'seed_growth_cycles'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'seed_growth_cycles'},
inline = i18n.tooltips.seed_growth_cycles,
+
conditions = {processed = true},
options = {
+
},
[1] = {
+
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'seed_growth_cycles',
 
key = 'seed_growth_cycles',
 
fmt = '%s',
 
fmt = '%s',
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.seed_growth_cycles,
 
},
 
},
 
},
 
},
-- Harvest plant boosters
+
-- Heist
-- TODO: Remaining enhancements
 
 
{
 
{
args = {'plant_booster_radius'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'heist_required_npcs'},
options = {
 
[1] = {
 
key = 'plant_booster_radius',
 
fmt = '%s',
 
inline = i18n.tooltips.radius,
 
},
 
},
 
 
},
 
},
  +
func = core.factory.infobox_line{
},
 
{
+
parts = {
args = {'heist_required_npcs'},
+
{
func = core.factory.display_value{
 
inline = i18n.tooltips.heist_required_npc,
 
options = {
 
[1] = {
 
 
key = 'heist_required_npcs',
 
key = 'heist_required_npcs',
 
fmt = '%s',
 
fmt = '%s',
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.heist_required_npc,
 
},
 
},
 
},
 
},
Строка 7909: Строка 1424:
 
-- Requirements
 
-- Requirements
 
{
 
{
-- TODO: i18n Master name?
 
{
 
args = {'master', 'master_level_requirement'},
 
func = function(tpl_args, frame)
 
-- masters have been validated before
 
local data
 
for i, rowdata in ipairs(m_game.constants.masters) do
 
if tpl_args.master == rowdata.full then
 
data = rowdata
 
break
 
end
 
end
 
 
return m_util.html.poe_color('default', i18n.tooltips.requires, string.format('[[%s|%s %s]]', data.full, data.short_upper, tpl_args.master_level_requirement))
 
end
 
},
 
 
-- Instead of item level, show drop level if any
 
-- Instead of item level, show drop level if any
 
{
 
{
args = nil,
+
show = true, -- Requires...
func = function(tpl_args, frame)
+
func = function (tpl_args, frame)
local opt = {
+
local parts = {
[1] = {
+
{
 
key = 'required_level_final_html',
 
key = 'required_level_final_html',
 
hide_default = 1,
 
hide_default = 1,
Строка 7938: Строка 1437:
 
},
 
},
 
}
 
}
 
 
for _, attr in ipairs(m_game.constants.attribute_order) do
 
for _, attr in ipairs(m_game.constants.attribute_order) do
opt[#opt+1] = {
+
parts[#parts+1] = {
 
key = string.format('required_%s_html', attr),
 
key = string.format('required_%s_html', attr),
hide_default = 0,
+
hide = function (tpl_args, frame, value)
hide_default_key = string.format('required_%s', attr),
+
local min = m_game.constants.characters.minimum_attributes[m_game.constants.attributes[attr].arg]
  +
return value.min <= min and value.max <= min
  +
end,
  +
hide_key = string.format('required_%s', attr),
 
inline = ', %s ' .. m_game.constants.attributes[attr].short_upper,
 
inline = ', %s ' .. m_game.constants.attributes[attr].short_upper,
 
inline_color = false,
 
inline_color = false,
 
}
 
}
 
end
 
end
  +
local requirements = core.factory.infobox_line{parts = parts}(tpl_args, frame)
 
local requirements = core.factory.display_value{options = opt}(tpl_args, frame)
+
if requirements == nil then -- return early
 
-- return early
 
if requirements == nil then
 
 
return
 
return
 
end
 
end
 
 
requirements = string.gsub(requirements, '^, ', '')
 
requirements = string.gsub(requirements, '^, ', '')
+
return string.format(i18n.tooltips.requires, requirements)
return m_util.html.poe_color('default', string.format(i18n.tooltips.requires, requirements))
 
 
end,
 
end,
 
},
 
},
 
{
 
{
  +
show = h.factory.maybe_show_infobox_line{
args = {'heist_required_job', 'heist_required_job_level'},
 
  +
keys = {'heist_required_job', 'heist_required_job_level'},
func = core.factory.display_value{
 
inline = i18n.tooltips.heist_required_job,
+
},
options = {
+
func = core.factory.infobox_line{
[1] = {
+
parts = {
key = 'heist_required_job',
+
{
  +
key = 'heist_required_job_level',
 
fmt = '%s',
 
fmt = '%s',
 
},
 
},
[2] = {
+
{
key = 'heist_required_job_level',
+
key = 'heist_required_job',
 
fmt = '%s',
 
fmt = '%s',
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.heist_required_job,
 
},
 
},
 
},
 
},
Строка 7980: Строка 1478:
 
-- Gem description
 
-- Gem description
 
{
 
{
css_class = 'tc -gemdesc',
+
class = 'tc -gemdesc',
 
{
 
{
args = {'gem_description'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value_only('gem_description'),
+
keys = {'gem_description'},
  +
},
  +
func = h.factory.display_raw_value('gem_description'),
 
},
 
},
 
},
 
},
 
-- Gem Quality Stats
 
-- Gem Quality Stats
 
{
 
{
css_class = 'tc -mod',
+
class = 'tc -mod',
 
{
 
{
args = {'skill_quality'},
+
show = h.factory.maybe_show_infobox_line{
func = function(tpl_args, frame)
+
keys = {'skill_quality'},
  +
},
  +
func = function (tpl_args, frame)
 
local span = mw.html.create('span')
 
local span = mw.html.create('span')
 
span
 
span
Строка 8034: Строка 1536:
 
-- Gem Implicit Stats
 
-- Gem Implicit Stats
 
{
 
{
css_class = 'tc -mod',
+
class = 'tc -mod',
 
{
 
{
args = function(tpl_args, frame)
+
show = function (tpl_args, frame)
return core.class_groups.gems.keys[tpl_args.class_id] and tpl_args.stat_text
+
return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.stat_text
 
end,
 
end,
func = function(tpl_args, frame)
+
func = function (tpl_args, frame)
lines = {}
+
local lines = {}
 
lines[#lines+1] = tpl_args.stat_text
 
lines[#lines+1] = tpl_args.stat_text
 
for _, tag in ipairs(tpl_args.gem_tags) do
 
for _, tag in ipairs(tpl_args.gem_tags) do
if tag == 'Ваал' then
+
if tag == m_game.constants.item.gem_tags.vaal.tag then
 
lines[#lines+1] = i18n.tooltips.corrupted
 
lines[#lines+1] = i18n.tooltips.corrupted
 
break
 
break
Строка 8054: Строка 1556:
 
-- Implicit Stats
 
-- Implicit Stats
 
{
 
{
css_class = 'tc -mod',
+
class = 'tc -mod',
func = function(tpl_args, frame, container_type)
+
func = function (tpl_args, frame, container_type)
 
if tpl_args.implicit_stat_text then
 
if tpl_args.implicit_stat_text then
return {core.display.strip_random_stats(tpl_args, frame, tpl_args.implicit_stat_text, container_type)}
+
return {h.strip_random_stats(tpl_args, frame, tpl_args.implicit_stat_text, container_type)}
 
else
 
else
 
return {}
 
return {}
Строка 8065: Строка 1567:
 
-- Stats
 
-- Stats
 
{
 
{
css_class = 'tc -mod',
+
class = 'tc -mod',
func = function(tpl_args, frame, container_type)
+
func = function (tpl_args, frame, container_type)
 
if tpl_args.explicit_stat_text then
 
if tpl_args.explicit_stat_text then
return {core.display.strip_random_stats(tpl_args, frame, tpl_args.explicit_stat_text, container_type)}
+
return {h.strip_random_stats(tpl_args, frame, tpl_args.explicit_stat_text, container_type)}
 
else
 
else
 
return {}
 
return {}
Строка 8077: Строка 1579:
 
--[[{
 
--[[{
 
{
 
{
args = {'experience'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'experience'},
key = 'experience',
+
},
options = {
+
func = core.factory.infobox_line{
[1] = {
+
parts = {
  +
{
  +
key = 'experience',
 
fmt = '%i',
 
fmt = '%i',
 
},
 
},
Строка 8090: Строка 1594:
 
-- Harvest seeds (lower section)
 
-- Harvest seeds (lower section)
 
{
 
{
css_class = 'tc -mod',
+
class = 'tc -mod',
 
{
 
{
  +
show = h.factory.maybe_show_infobox_line{
args = {'seed_consumed_wild_lifeforce_percentage'},
 
  +
keys = {'seed_consumed_wild_lifeforce_percentage'},
  +
conditions = {processed = true},
  +
},
 
func = function (tpl_args, frame)
 
func = function (tpl_args, frame)
 
if tpl_args.seed_consumed_wild_lifeforce_percentage > 0 then
 
if tpl_args.seed_consumed_wild_lifeforce_percentage > 0 then
Строка 8100: Строка 1607:
 
},
 
},
 
{
 
{
  +
show = h.factory.maybe_show_infobox_line{
args = {'seed_consumed_vivid_lifeforce_percentage'},
 
  +
keys = {'seed_consumed_vivid_lifeforce_percentage'},
  +
conditions = {processed = true},
  +
},
 
func = function (tpl_args, frame)
 
func = function (tpl_args, frame)
 
if tpl_args.seed_consumed_vivid_lifeforce_percentage > 0 then
 
if tpl_args.seed_consumed_vivid_lifeforce_percentage > 0 then
Строка 8108: Строка 1618:
 
},
 
},
 
{
 
{
  +
show = h.factory.maybe_show_infobox_line{
args = {'seed_consumed_primal_lifeforce_percentage'},
 
  +
keys = {'seed_consumed_primal_lifeforce_percentage'},
  +
conditions = {processed = true},
  +
},
 
func = function (tpl_args, frame)
 
func = function (tpl_args, frame)
 
if tpl_args.seed_consumed_primal_lifeforce_percentage > 0 then
 
if tpl_args.seed_consumed_primal_lifeforce_percentage > 0 then
Строка 8116: Строка 1629:
 
},
 
},
 
{
 
{
  +
show = h.factory.maybe_show_infobox_line{
args = {'seed_required_nearby_seed_tier', 'seed_type_html', 'seed_required_nearby_seed_amount'},
 
  +
keys = {'seed_required_nearby_seed_tier', 'seed_type_html', 'seed_required_nearby_seed_amount'},
func = core.factory.display_value{
 
inline = i18n.tooltips.seed_required_seeds,
+
conditions = {processed = true},
color = 'mod',
+
},
options = {
+
func = core.factory.infobox_line{
[1] = {
+
parts = {
  +
{
 
key = 'seed_required_nearby_seed_amount',
 
key = 'seed_required_nearby_seed_amount',
 
fmt = '%s',
 
fmt = '%s',
 
},
 
},
[2] = {
+
{
 
key = 'seed_type_html',
 
key = 'seed_type_html',
 
fmt = '%s',
 
fmt = '%s',
 
},
 
},
[3] = {
+
{
 
key = 'seed_required_nearby_seed_tier',
 
key = 'seed_required_nearby_seed_tier',
 
fmt = '%s',
 
fmt = '%s',
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.seed_required_seeds,
  +
color = 'mod',
 
},
 
},
 
},
 
},
 
},
 
},
 
{
 
{
css_class = 'tc -crafted',
+
class = 'tc -crafted',
 
{
 
{
args = {'seed_effect'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value_only('seed_effect'),
+
keys = {'seed_effect'},
  +
conditions = {processed = true},
  +
},
  +
func = h.factory.display_raw_value('seed_effect'),
 
},
 
},
 
},
 
},
 
-- Description (currency, doodads)
 
-- Description (currency, doodads)
 
{
 
{
css_class = 'tc -mod',
+
class = 'tc -mod',
 
{
 
{
args = {'description'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value_only('description'),
+
keys = {'description'},
  +
conditions = {processed = true},
  +
},
  +
func = h.factory.display_raw_value('description'),
 
},
 
},
 
--[[{
 
--[[{
  +
show = h.factory.maybe_show_infobox_line{
args = {'plant_booster_additional_crafting_options'},
 
  +
keys = {'plant_booster_additional_crafting_options'},
func = core.factory.display_value{
 
inline = i18n.tooltips.plant_booster_additional_crafting_options,
+
conditions = {processed = true},
options = {
+
},
[1] = {
+
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'plant_booster_additional_crafting_options',
 
key = 'plant_booster_additional_crafting_options',
 
fmt = '%s',
 
fmt = '%s',
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.plant_booster_additional_crafting_options,
 
},
 
},
 
},
 
},
 
{
 
{
  +
show = h.factory.maybe_show_infobox_line{
args = {'plant_booster_extra_chances'},
 
  +
keys = {'plant_booster_extra_chances'},
func = core.factory.display_value{
 
inline = i18n.tooltips.plant_booster_extra_chances,
+
conditions = {processed = true},
options = {
+
},
[1] = {
+
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'plant_booster_extra_chances',
 
key = 'plant_booster_extra_chances',
 
fmt = '%s%%',
 
fmt = '%s%%',
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.plant_booster_extra_chances,
 
},
 
},
 
},
 
},
 
{
 
{
  +
show = h.factory.maybe_show_infobox_line{
args = {'plant_booster_lifeforce'},
 
func = core.factory.display_value{
+
keys = {'plant_booster_lifeforce'},
inline = i18n.tooltips.plant_booster_lifeforce,
+
conditions = {processed = true},
options = {
+
},
[1] = {
+
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'plant_booster_lifeforce',
 
key = 'plant_booster_lifeforce',
 
fmt = '%s%%',
 
fmt = '%s%%',
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.plant_booster_lifeforce,
 
},
 
},
 
},]]
 
},]]
 
},
 
},
 
{
 
{
css_class = 'tc -crafted',
+
class = 'tc -crafted',
 
{
 
{
args = {'incubator_effect'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value_only('incubator_effect'),
+
keys = {'incubator_effect'},
  +
conditions = {processed = true},
  +
},
  +
func = h.factory.display_raw_value('incubator_effect'),
 
},
 
},
 
},
 
},
 
-- Variations (for doodads)
 
-- Variations (for doodads)
 
{
 
{
css_class = 'tc -mod',
+
class = 'tc -mod',
 
{
 
{
args = {'variation_count'},
+
show = h.factory.maybe_show_infobox_line{
func = function(tpl_args, frame)
+
keys = {'variation_count'},
  +
conditions = {processed = true},
  +
},
  +
func = function (tpl_args, frame)
 
local txt
 
local txt
 
if tpl_args.variation_count == 1 then
 
if tpl_args.variation_count == 1 then
Строка 8207: Строка 1744:
 
txt = i18n.tooltips.variation_plural
 
txt = i18n.tooltips.variation_plural
 
end
 
end
return string.format('%s %i', txt, tpl_args.variation_count)
+
return string.format('%i %s', tpl_args.variation_count, txt)
 
end,
 
end,
 
},
 
},
Строка 8213: Строка 1750:
 
-- Flavour Text
 
-- Flavour Text
 
{
 
{
css_class = 'tc -flavour',
+
class = 'tc -flavour',
 
{
 
{
args = {'flavour_text'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value_only('flavour_text'),
+
keys = {'flavour_text'},
  +
conditions = {processed = true},
  +
},
  +
func = h.factory.display_raw_value('flavour_text'),
 
},
 
},
 
},
 
},
 
-- Prophecy text
 
-- Prophecy text
 
{
 
{
css_class = 'tc -value',
+
class = 'tc -value',
 
{
 
{
args = {'prediction_text'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value_only('prediction_text'),
+
keys = {'prediction_text'},
  +
conditions = {processed = true},
  +
},
  +
func = h.factory.display_raw_value('prediction_text'),
 
},
 
},
 
},
 
},
 
-- Can not be traded or modified
 
-- Can not be traded or modified
 
{
 
{
css_class = 'tc -canttradeormodify',
+
class = 'tc -canttradeormodify',
 
{
 
{
  +
show = h.factory.maybe_show_infobox_line{
args = {'cannot_be_traded_or_modified'},
 
func = function(tpl_args, frame)
+
keys = {'cannot_be_traded_or_modified'},
  +
conditions = {processed = true},
  +
},
  +
func = function (tpl_args, frame)
 
if tpl_args.cannot_be_traded_or_modified == true then
 
if tpl_args.cannot_be_traded_or_modified == true then
 
return i18n.tooltips.cannot_be_traded_or_modified
 
return i18n.tooltips.cannot_be_traded_or_modified
Строка 8241: Строка 1787:
 
-- Help text
 
-- Help text
 
{
 
{
css_class = 'tc -help',
+
class = 'tc -help',
 
{
 
{
args = {'help_text'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value_only('help_text'),
+
keys = {'help_text'},
--inline = false,
+
conditions = {processed = true},
},
 
},
 
-- Cost (i.e. vendor costs)
 
{
 
--css_class = '',
 
{
 
args = {'master_favour_cost'},
 
func = core.factory.display_value{
 
options = {
 
[1] = {
 
key = 'master_favour_cost',
 
inline = i18n.tooltips.favour_cost,
 
color = 'currency',
 
},
 
},
 
},
 
},
 
{
 
args = {'seal_cost'},
 
func = core.factory.display_value{
 
options = {
 
[1] = {
 
key = 'seal_cost',
 
fmt = '%dx ',
 
color = 'currency',
 
inline = function (tpl_args, frame)
 
return i18n.tooltips.seal_cost .. f_item_link{metadata_id='Metadata/Items/Currency/CurrencySilverCoin', html=''}
 
end,
 
},
 
},
 
 
},
 
},
  +
func = h.factory.display_raw_value('help_text'),
 
},
 
},
 
},
 
},
Строка 8284: Строка 1801:
 
-- This is meant to show additional information about the item in a separate infobox
 
-- This is meant to show additional information about the item in a separate infobox
 
--
 
--
core.extra_display_groups = {
+
c.extra_display_groups = {
 
{
 
{
header = i18n.tooltips.extra_info,
+
heading = i18n.tooltips.extra_info,
css_class = '',
+
class = '',
 
{
 
{
args = {'atlas_connections'},
+
show = h.factory.maybe_show_infobox_line{
func = function(tpl_args, frame)
+
keys = {'atlas_connections'},
  +
conditions = {processed = true},
  +
},
  +
func = function (tpl_args, frame)
 
local fields = {
 
local fields = {
 
[false] = {
 
[false] = {
Строка 8397: Строка 1917:
 
},
 
},
 
},
 
},
-- Drop info
+
-- Acquisition
 
{
 
{
header = i18n.tooltips.drop_restrictions,
+
heading = i18n.tooltips.acquisition,
css_class = '',
 
 
{
 
{
args = {'drop_enabled'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'drop_level'},
options = {
+
conditions = {processed = true},
[1] = {
+
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
 
key = 'drop_level',
 
key = 'drop_level',
 
fmt = '%i',
 
fmt = '%i',
inline = i18n.tooltips.level,
+
 
},
 
},
[2] = {
+
{
 
key = 'drop_level_maximum',
 
key = 'drop_level_maximum',
hide_default = 100,
 
 
fmt = '%i',
 
fmt = '%i',
inline = ' / %s',
+
hide_default = 100,
 
},
 
},
 
},
 
},
  +
sep = ' / ',
  +
fmt = i18n.tooltips.area_level,
 
},
 
},
 
},
 
},
 
{
 
{
args = {'drop_leagues'},
+
show = function (tpl_args, frame)
func = function(tpl_args, frame)
+
if tpl_args.drop_enabled == false then
  +
return true
return string.format(i18n.tooltips.league_restriction, m_util.html.poe_color('value', table.concat(tpl_args.drop_leagues, ', ')))
 
end
 
},
 
{
 
args = {'drop_areas_html'},
 
func = core.factory.display_value_only('drop_areas_html'),
 
},
 
{
 
args = {'drop_text'},
 
func = core.factory.display_value_only('drop_text'),
 
},
 
{
 
args = function(tpl_args, frame)
 
if tpl_args.drop_enabled == true then
 
return false
 
 
end
 
end
return true
+
return false
 
end,
 
end,
func = function(tpl_args, frame)
+
func = function (tpl_args, frame)
 
local span = mw.html.create('span')
 
local span = mw.html.create('span')
 
span
 
span
Строка 8448: Строка 1957:
 
return tostring(span)
 
return tostring(span)
 
end,
 
end,
  +
},
  +
{
  +
show = function (tpl_args, frame)
  +
if tpl_args.is_drop_restricted == true and tpl_args.drop_enabled ~= false then
  +
return true
  +
end
  +
return false
  +
end,
  +
func = function (tpl_args, frame)
  +
local span = mw.html.create('span')
  +
span
  +
:attr('class', 'infobox-restricted-drop')
  +
:wikitext(i18n.tooltips.drop_restricted)
  +
:done()
  +
return tostring(span)
  +
end,
  +
},
  +
{
  +
show = h.factory.maybe_show_infobox_line{
  +
keys = {'drop_leagues'},
  +
conditions = {processed = true},
  +
},
  +
func = function (tpl_args, frame)
  +
return string.format(i18n.tooltips.league_restriction, m_util.html.poe_color('value', table.concat(tpl_args.drop_leagues, ', ')))
  +
end
  +
},
  +
{
  +
show = h.factory.maybe_show_infobox_line{
  +
keys = {'drop_areas_html'},
  +
conditions = {processed = true},
  +
},
  +
func = h.factory.display_raw_value('drop_areas_html'),
  +
},
  +
{
  +
show = h.factory.maybe_show_infobox_line{
  +
keys = {'drop_text'},
  +
conditions = {processed = true},
  +
},
  +
func = h.factory.display_raw_value('drop_text'),
  +
},
  +
{
  +
show = h.factory.maybe_show_infobox_line{
  +
keys = {'master', 'master_level_requirement'},
  +
conditions = {processed = true},
  +
},
  +
func = function (tpl_args, frame)
  +
local master
  +
for _, v in ipairs(m_game.constants.masters) do
  +
if tpl_args.master == v.full then
  +
master = v
  +
break
  +
end
  +
end
  +
local text = string.format('[[%s|%s]] ', master.full, master.short_upper) .. string.format(i18n.tooltips.master_level, tpl_args.master_level_requirement)
  +
return string.format(i18n.tooltips.master, m_util.html.poe_color('value', text))
  +
end
  +
},
  +
{
  +
show = h.factory.maybe_show_infobox_line{
  +
keys = {'master', 'master_favour_cost'},
  +
conditions = {processed = true},
  +
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
  +
key = 'master_favour_cost',
  +
color = 'currency',
  +
hide_default = 0,
  +
},
  +
},
  +
fmt = i18n.tooltips.favour_cost,
  +
},
  +
},
  +
{
  +
show = h.factory.maybe_show_infobox_line{
  +
keys = {'seal_cost'},
  +
conditions = {processed = true},
  +
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
  +
key = 'seal_cost',
  +
fmt = function (tpl_args, frame, value)
  +
return string.format('%s %s', i18n.fmt.item_count, h.item_link{metadata_id='Metadata/Items/Currency/CurrencySilverCoin', html=''})
  +
end,
  +
color = 'currency',
  +
},
  +
},
  +
fmt = i18n.tooltips.seal_cost,
  +
},
 
},
 
},
 
},
 
},
 
{
 
{
  +
-- Vendor prices
header = i18n.tooltips.purchase_costs,
 
  +
heading = i18n.tooltips.purchase_costs,
 
{
 
{
args = function(tpl_args, frame)
+
show = function (tpl_args, frame)
 
for rarity, data in pairs(tpl_args.purchase_costs) do
 
for rarity, data in pairs(tpl_args.purchase_costs) do
 
if #data > 0 then
 
if #data > 0 then
Строка 8461: Строка 2061:
 
return false
 
return false
 
end,
 
end,
func = function(tpl_args, frame)
+
func = function (tpl_args, frame)
 
local tbl = mw.html.create('table')
 
local tbl = mw.html.create('table')
 
tbl
 
tbl
Строка 8486: Строка 2086:
 
},
 
},
 
{
 
{
header = i18n.tooltips.sell_price,
+
-- Vendor offer
  +
heading = i18n.tooltips.sell_price,
 
{
 
{
args = {'sell_price_order'},
+
show = h.factory.maybe_show_infobox_line{
func = function(tpl_args, frame)
+
keys = {'sell_price_order'},
  +
},
  +
func = function (tpl_args, frame)
 
local out = {}
 
local out = {}
for _, item_name in ipairs(tpl_args.sell_price_order) do
+
if #tpl_args.sell_price_order > 0 then
out[#out+1] = string.format('%dx [[%s]]', tpl_args.sell_prices[item_name], item_name)
+
for _, item_name in ipairs(tpl_args.sell_price_order) do
  +
out[#out+1] = string.format('%dx [[%s]]', tpl_args.sell_prices[item_name], item_name)
  +
end
 
end
 
end
 
 
return table.concat(out, '<br />')
 
return table.concat(out, '<br />')
 
end,
 
end,
Строка 8501: Строка 2105:
 
-- Damage per second
 
-- Damage per second
 
{
 
{
header = i18n.tooltips.damage_per_second,
+
heading = i18n.tooltips.damage_per_second,
-- Autoinsert here from dps map
 
},
 
{
 
header = i18n.tooltips.misc,
 
 
{
 
{
args = {'class'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'physical_dps_html'},
options = {
+
},
[1] = {
+
func = core.factory.infobox_line{
key = 'class',
+
parts = {
  +
{
  +
key = 'physical_dps_html',
 
fmt = '%s',
 
fmt = '%s',
inline = i18n.tooltips.item_class,
+
color = false, -- the html already contains the colour
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.physical_dps,
 
},
 
},
 
},
 
},
 
{
 
{
args = {'metadata_id'},
+
show = h.factory.maybe_show_infobox_line{
func = core.factory.display_value{
+
keys = {'fire_dps_html'},
options = {
+
},
[1] = {
+
func = core.factory.infobox_line{
key = 'metadata_id',
+
parts = {
  +
{
  +
key = 'fire_dps_html',
 
fmt = '%s',
 
fmt = '%s',
inline = i18n.tooltips.metadata_id,
+
color = false, -- the html already contains the colour
truncate = true,
 
 
},
 
},
 
},
 
},
  +
fmt = i18n.tooltips.fire_dps,
  +
},
  +
},
  +
{
  +
show = h.factory.maybe_show_infobox_line{
  +
keys = {'cold_dps_html'},
  +
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
  +
key = 'cold_dps_html',
  +
fmt = '%s',
  +
color = false, -- the html already contains the colour
  +
},
  +
},
  +
fmt = i18n.tooltips.cold_dps,
  +
},
  +
},
  +
{
  +
show = h.factory.maybe_show_infobox_line{
  +
keys = {'lightning_dps_html'},
  +
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
  +
key = 'lightning_dps_html',
  +
fmt = '%s',
  +
color = false, -- the html already contains the colour
  +
},
  +
},
  +
fmt = i18n.tooltips.lightning_dps,
  +
},
  +
},
  +
{
  +
show = h.factory.maybe_show_infobox_line{
  +
keys = {'chaos_dps_html'},
  +
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
  +
key = 'chaos_dps_html',
  +
fmt = '%s',
  +
color = false, -- the html already contains the colour
  +
},
  +
},
  +
fmt = i18n.tooltips.chaos_dps,
  +
},
  +
},
  +
{
  +
show = h.factory.maybe_show_infobox_line{
  +
keys = {'elemental_dps_html'},
  +
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
  +
key = 'elemental_dps_html',
  +
fmt = '%s',
  +
color = false, -- the html already contains the colour
  +
},
  +
},
  +
fmt = i18n.tooltips.elemental_dps,
  +
},
  +
},
  +
{
  +
show = h.factory.maybe_show_infobox_line{
  +
keys = {'poison_dps_html'},
  +
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
  +
key = 'poison_dps_html',
  +
fmt = '%s',
  +
color = false, -- the html already contains the colour
  +
},
  +
},
  +
fmt = i18n.tooltips.poison_dps,
  +
},
  +
},
  +
{
  +
show = h.factory.maybe_show_infobox_line{
  +
keys = {'dps_html'},
  +
},
  +
func = core.factory.infobox_line{
  +
parts = {
  +
{
  +
key = 'dps_html',
  +
fmt = '%s',
  +
color = false, -- the html already contains the colour
  +
},
  +
},
  +
fmt = i18n.tooltips.dps,
 
},
 
},
 
},
 
},
 
},
 
},
  +
{
}
 
  +
heading = i18n.tooltips.metadata,
 
  +
{
for i, data in ipairs(core.dps_map) do
 
  +
show = h.factory.maybe_show_infobox_line{
table.insert(core.extra_display_groups[4], {
 
args = {data.name .. '_html'},
+
keys = {'class'},
  +
conditions = {processed = true},
func = core.factory.display_value{
 
options = {
+
},
[1] = {
+
func = core.factory.infobox_line{
key = data.name .. '_html',
+
parts = {
inline = data.label_infobox .. ': %s',
+
{
fmt = '%s',
+
key = 'class',
-- the html already contains the colour
+
fmt = '%s',
no_color = true,
+
},
 
},
 
},
  +
fmt = i18n.tooltips.item_class,
 
},
 
},
 
},
 
},
})
+
{
  +
show = h.factory.maybe_show_infobox_line{
if i == 5 then
 
  +
keys = {'metadata_id'},
table.insert(core.extra_display_groups[4], {
 
args = function (tpl_args, frame)
+
conditions = {processed = true},
  +
},
return tpl_args.elemental_dps_html ~= nil or tpl_args.poison_dps_html ~= nil
 
end,
 
 
func = function (tpl_args, frame)
 
func = function (tpl_args, frame)
return ''
+
return core.factory.infobox_line{
  +
parts = {
  +
{
  +
key = 'metadata_id',
  +
fmt = '%s',
  +
inline = m_util.html.abbr('%s', tpl_args.metadata_id),
  +
},
  +
},
  +
fmt = tostring(
  +
mw.html.create('span')
  +
:addClass('u-truncate-line')
  +
:wikitext(i18n.tooltips.metadata_id)
  +
),
  +
}(tpl_args, frame)
 
end,
 
end,
})
+
},
  +
},
elseif i == 7 then
 
  +
}
table.insert(core.extra_display_groups[4], {
 
args = {'dps_html'},
 
func = function (tpl_args, frame)
 
return ''
 
end,
 
})
 
end
 
end
 
   
 
-- ----------------------------------------------------------------------------
 
-- ----------------------------------------------------------------------------
-- Tables
+
-- Subroutines
 
-- ----------------------------------------------------------------------------
 
-- ----------------------------------------------------------------------------
   
  +
local s = {}
function cargo_declare(data)
 
  +
return function(frame)
 
  +
-- Subroutines for p.item. These exist to declutter the main function. Each one of these is only called once.
local tpl_args = getArgs(frame, {
 
  +
parentFirst = true
 
  +
function s.get_item_config(tpl_args, frame)
})
 
  +
-- Returns primary item configuration, based on item class
frame = m_util.misc.get_frame(frame)
 
  +
  +
local config = {
  +
tables = {}, -- Table names that data may be stored to
  +
args = {}, -- Args to process early
  +
late_args = {}, -- Args to process late
  +
defaults = {}, -- Defaults based on item class
  +
}
  +
for _, v in ipairs(cfg.tables) do
  +
table.insert(config.tables, v)
  +
end
  +
for _, v in ipairs(cfg.default_args) do
  +
table.insert(config.args, v)
  +
end
  +
for _, v in ipairs(cfg.late_args) do
  +
table.insert(config.late_args, v)
  +
end
  +
  +
-- Process class_id
  +
h.process_arguments(tpl_args, frame, {'class_id'})
  +
  +
local extend_keys = {'tables', 'args', 'late_args'} -- We will do defaults separately to preserve order of args
  +
for _, row in pairs(cfg.class_groups) do
  +
if row.keys[tpl_args.class_id] then
  +
for _, k in ipairs(extend_keys) do
  +
if row[k] then
  +
for _, v in ipairs(row[k]) do
  +
table.insert(config[k], v)
  +
end
  +
end
  +
end
  +
if row['defaults'] then
  +
for k, v in pairs(row['defaults']) do
  +
config['defaults'][k] = v
  +
end
  +
end
  +
break
  +
end
  +
end
  +
local class_specifics = cfg.class_specifics[tpl_args.class_id]
  +
if class_specifics then
  +
for _, k in ipairs(extend_keys) do
  +
if class_specifics[k] then
  +
for _, v in ipairs(class_specifics[k]) do
  +
table.insert(config[k], v)
  +
end
  +
end
  +
end
  +
if class_specifics['defaults'] then
  +
for k, v in pairs(class_specifics['defaults']) do
  +
config['defaults'][k] = v
  +
end
  +
end
  +
end
  +
return config
  +
end
  +
  +
function s.process_quest_rewards(tpl_args, frame)
  +
local rid = 1
  +
local continue
  +
tpl_args.quest_rewards = {}
  +
tpl_args.vendor_rewards = {}
  +
repeat
  +
continue = true
  +
local prefix = string.format('quest_reward%s_', rid)
 
 
local dcl_args = {}
+
local input_args = {
dcl_args._table = data.table
+
shared = {
  +
['type'] = true,
for k, field_data in pairs(data.fields) do
 
if field_data.field then
+
['quest'] = false,
dcl_args[field_data.field] = field_data.type
+
['quest_id'] = false,
for _, stat_data in pairs(core.stat_map) do
+
['act'] = true,
if stat_data.field == k then
+
['class_ids'] = false,
for _, range_fields in ipairs(h.range_fields) do
+
},
  +
vendor = {
-- if the type is nil, use the parent type
 
-- so this is set integer/float values correctly
+
['npc'] = true,
  +
},
dcl_args[stat_data.field .. range_fields.field] = range_fields.type or field_data.type
 
end
+
quest = {
  +
['sockets'] = false,
  +
['item_level'] = false,
  +
['rarity_id'] = false,
  +
['notes'] = false,
  +
},
  +
}
  +
  +
local rdata = {}
  +
  +
for key, is_required in pairs(input_args.shared) do
  +
rdata[key] = tpl_args[prefix .. key]
  +
if is_required then
  +
if rdata[key] == nil then
  +
continue = false
  +
break
  +
end
  +
end
  +
end
  +
  +
if rdata.quest == nil or rdata.quest_id == nil then
  +
continue = false
  +
end
  +
  +
if continue and rdata.type == 'vendor' or rdata.type == 'quest' then
  +
for key, is_required in pairs(input_args[rdata.type]) do
  +
rdata[key] = tpl_args[prefix .. key]
  +
if is_required then
  +
if rdata[key] == nil then
  +
continue = false
 
break
 
break
 
end
 
end
 
end
 
end
 
end
 
end
  +
else
  +
continue = false
 
end
 
end
 
 
if dcl_args._table == 'weapons' then
+
if continue then
for _, dps_data in ipairs(core.dps_map) do
+
rdata.classes = {}
  +
if rdata.class_ids ~= nil then
for _, range_fields in ipairs(h.range_fields) do
 
  +
rdata.class_ids = m_util.string.split(rdata.class_ids, ',%s*')
-- since there is no parent, the default is float
 
  +
for index, class_id in ipairs(rdata.class_ids) do
dcl_args[dps_data.field .. range_fields.field] = range_fields.type or 'Float'
 
  +
local class = m_game.constants.characters[class_id]
  +
if class == nil then
  +
error(string.format('Class id %s is invalid', class_id))
  +
else
  +
rdata.class_ids[index] = class.str_id
  +
rdata.classes[index] = class.name
  +
end
 
end
 
end
 
end
 
end
  +
  +
  +
if rdata.item_level then
  +
rdata.item_level = m_util.cast.number(rdata.item_level)
  +
end
  +
  +
if rdata.rarity_id then
  +
if m_game.constants.rarities[rdata.rarity_id] == nil then
  +
error(string.format(i18n.errors.invalid_rarity_id, tostring(rdata.rarity_id)))
  +
end
  +
end
  +
  +
rdata._table = rdata.type .. '_rewards'
  +
rdata.type = nil
  +
  +
tpl_args[rdata._table] = rdata
  +
  +
m_cargo.store(frame, rdata)
  +
  +
-- TODO: Verify quests and quest ids?
 
end
 
end
if tpl_args.debug then
+
mw.logObject(dcl_args)
+
rid = rid + 1
end
+
until continue == false
return m_cargo.declare(frame, dcl_args)
 
end
 
 
end
 
end
   
  +
function s.process_base_item(tpl_args, frame)
p.table_items = cargo_declare(core.cargo.items)
 
  +
local where
p.table_item_sell_prices = cargo_declare(core.cargo.item_sell_prices)
 
  +
if tpl_args.base_item_id ~= nil then
p.table_item_purchase_costs = cargo_declare(core.cargo.item_purchase_costs)
 
  +
where = string.format('items.metadata_id="%s"', tpl_args.base_item_id)
p.table_item_mods = cargo_declare(core.cargo.item_mods)
 
  +
elseif tpl_args.base_item_page ~= nil then
p.table_item_stats = cargo_declare(core.cargo.item_stats)
 
  +
where = string.format('items._pageName="%s"' , tpl_args.base_item_page)
p.table_item_buffs = cargo_declare(core.cargo.item_buffs)
 
  +
elseif tpl_args.base_item ~= nil then
p.table_upgraded_from_sets = cargo_declare(core.cargo.upgraded_from_sets)
 
  +
where = string.format('items.name="%s"' , tpl_args.base_item)
p.table_upgraded_from_groups = cargo_declare(core.cargo.upgraded_from_groups)
 
  +
elseif tpl_args.rarity_id ~= 'normal' then
p.table_amulets = cargo_declare(core.cargo.amulets)
 
  +
error(i18n.errors.missing_base_item)
p.table_flasks = cargo_declare(core.cargo.flasks)
 
  +
else
p.table_weapons = cargo_declare(core.cargo.weapons)
 
  +
return
p.table_armours = cargo_declare(core.cargo.armours)
 
  +
end
p.table_shields = cargo_declare(core.cargo.shields)
 
p.table_skill_gems = cargo_declare(core.cargo.skill_gems)
 
p.table_maps = cargo_declare(core.cargo.maps)
 
p.table_atlas_maps = cargo_declare(core.cargo.atlas_maps)
 
p.table_atlas_connections = cargo_declare(core.cargo.atlas_connections)
 
p.table_stackables = cargo_declare(core.cargo.stackables)
 
p.table_essences = cargo_declare(core.cargo.essences)
 
p.table_blight_items = cargo_declare(core.cargo.blight_items)
 
p.table_hideout_doodads = cargo_declare(core.cargo.hideout_doodads)
 
p.table_prophecies = cargo_declare(core.cargo.prophecies)
 
p.table_divination_cards = cargo_declare(core.cargo.divination_cards)
 
p.table_jewels = cargo_declare(core.cargo.jewels)
 
p.table_incubators = cargo_declare(core.cargo.incubators)
 
p.table_harvest_seeds = cargo_declare(core.cargo.harvest_seeds)
 
p.table_harvest_plant_boosters = cargo_declare(core.cargo.harvest_plant_boosters)
 
p.table_heist_equipment = cargo_declare(core.cargo.heist_equipment)
 
p.table_quest_rewards = cargo_declare(core.cargo.quest_rewards)
 
p.table_vendor_rewards = cargo_declare(core.cargo.vendor_rewards)
 
 
-- ----------------------------------------------------------------------------
 
-- Page views
 
-- ----------------------------------------------------------------------------
 
 
--
 
-- Template:Item
 
--
 
 
function p.itembox (frame)
 
--
 
-- Args/Frame
 
--
 
local t = os.clock()
 
 
 
  +
if where ~= nil and tpl_args.rarity_id == 'normal' and not tpl_args._flags.is_prophecy then
local tpl_args = getArgs(frame, {
 
  +
error(i18n.errors.missing_rarity)
parentFirst = true
 
})
+
end
frame = m_util.misc.get_frame(frame)
 
 
 
  +
where = string.format('%s AND items.class_id="%s" AND items.rarity_id="normal"', where, tpl_args.class_id)
--
 
-- Shared args
 
--
 
 
 
tpl_args._flags = {}
+
local join = {}
  +
tpl_args._base_item_args = {}
 
tpl_args._mods = {}
+
for _, table_name in ipairs(tpl_args._item_config.tables) do
for _, k in ipairs({'', '_random'}) do
+
if table_name ~= 'items' then
  +
join[#join+1] = string.format('items._pageID=%s._pageID', table_name)
for _, prefix in ipairs({'', '_implicit', '_explicit'}) do
 
tpl_args[k .. prefix .. '_stats'] = {}
 
 
end
 
end
 
end
 
end
tpl_args._subobjects = {}
 
tpl_args._properties = {}
 
tpl_args._errors = {}
 
 
 
  +
local fields = {
core.process_arguments(tpl_args, frame, {array={'class_id'}})
 
  +
'items._pageName',
core.build_item_classes(tpl_args, frame)
 
  +
'items.name',
core.build_cargo_data(tpl_args, frame)
 
  +
'items.metadata_id',
  +
}
 
 
  +
for _, k in ipairs(tpl_args._base_item_args) do
-- Using general purpose function to handle release and removal versions
 
  +
local data = core.map[k]
m_util.args.version(tpl_args, {frame=frame, set_properties=true})
 
  +
if data.field ~= nil then
  +
fields[#fields+1] = string.format('%s.%s', data.table, data.field)
  +
end
  +
end
 
 
  +
local result = m_cargo.query(
-- Must validate some argument early. It is required for future things
 
  +
tpl_args._item_config.tables,
core.process_arguments(tpl_args, frame, {array=core.default_args})
 
  +
fields,
core.process_arguments(tpl_args, frame, {array=core.item_classes[tpl_args.class_id].args})
 
  +
{
  +
where=where,
  +
join=table.concat(join, ','),
  +
groupBy='items._pageID',
  +
}
  +
)
 
 
-- Base Item
+
if #result > 1 then
  +
error(i18n.errors.duplicate_base_items)
 
  +
-- TODO be more explicit in the error?
core.process_base_item(tpl_args, frame)
 
  +
elseif #result == 0 then
  +
error(i18n.errors.base_item_not_found)
  +
end
 
 
  +
result = result[1]
-- Prophecy special snowflake
 
  +
if tpl_args._flags.is_prophecy then
 
  +
tpl_args.base_item_data = result
err = core.process_arguments(tpl_args, frame, {array=core.prophecy_args})
 
  +
h.process_arguments(tpl_args, frame, {'base_item', 'base_item_page', 'base_item_id'})
if err then
 
  +
return err
 
  +
--Copy values..
  +
for _, k in ipairs(tpl_args._base_item_args) do
  +
local data = core.map[k]
  +
if data.field ~= nil and data.func_fetch == nil then
  +
local value = result[string.format('%s.%s', data.table, data.field)]
  +
if value ~= nil then
  +
local default = type(data.default) == 'function' and data.default(tpl_args, frame) or data.default
  +
-- Inherit value from base item if derived item value is not equal to the default value.
  +
-- This verbose comparison is needed since two empty tables are not considered equal to one another.
  +
if tpl_args[k] == data.default or (type(tpl_args[k]) == 'table' and #tpl_args[k] == 0 and type(data.default) == 'table' and #data.default == 0) then
  +
tpl_args[k] = value
  +
if data.func ~= nil then
  +
tpl_args[k] = data.func(tpl_args, frame, tpl_args[k])
  +
end
  +
if data.func_copy ~= nil then
  +
data.func_copy(tpl_args, frame, tpl_args[k])
  +
end
  +
elseif tpl_args.debug then
  +
mw.log(string.format(i18n.debug.field_value_mismatch, k, tostring(tpl_args[k])))
  +
end
  +
elseif tpl_args.debug then
  +
mw.log(string.format(i18n.debug.base_item_field_not_found, data.table, data.field))
  +
end
  +
elseif data.func_fetch ~= nil then
  +
data.func_fetch(tpl_args, frame)
 
end
 
end
 
tpl_args.inventory_icon = string.format(i18n.inventory_icon, 'Пророчество')
 
 
end
 
end
  +
end
 
-- Mods
 
   
  +
function s.process_mods(tpl_args, frame)
 
for _, k in ipairs({'implicit', 'explicit'}) do
 
for _, k in ipairs({'implicit', 'explicit'}) do
 
local success = true
 
local success = true
 
local i = 1
 
local i = 1
 
while success do
 
while success do
success = core.validate_mod(tpl_args, frame, {key=k, i=i})
+
success = h.validate_mod(tpl_args, frame, {key=k, i=i})
 
i = i + 1
 
i = i + 1
 
end
 
end
 
end
 
end
  +
 
  +
-- If the item does not have its own implicit mods, fall back to the implicit mods on the base item.
core.process_smw_mods(tpl_args, frame)
 
  +
local implicit_mods = tpl_args._defined_implicit_mods
  +
if #implicit_mods == 0 then
  +
implicit_mods = tpl_args._base_implicit_mods
  +
end
  +
for _, v in ipairs(implicit_mods) do
  +
table.insert(tpl_args._mods, v)
  +
end
  +
if #tpl_args._mods > 0 then
  +
local mods = {}
  +
local mod_ids = {}
  +
local non_random_mod_ids = {}
  +
for _, mod_data in ipairs(tpl_args._mods) do
  +
if mod_data.result == nil then
  +
mods[mod_data.id] = mod_data
  +
mod_ids[#mod_ids+1] = mod_data.id
  +
if not mod_data.is_random then
  +
table.insert(non_random_mod_ids, mod_data.id)
  +
end
  +
end
  +
tpl_args._subobjects[#tpl_args._subobjects+1] = {
  +
_table = 'item_mods',
  +
id = mod_data.id,
  +
text = mod_data.stat_text,
  +
is_implicit = mod_data.is_implicit,
  +
is_random = mod_data.is_random,
  +
}
  +
end
 
 
  +
local results = m_cargo.array_query{
  +
tables={'mods'},
  +
fields={'mods._pageName', 'mods.id', 'mods.required_level', 'mods.stat_text'},
  +
id_field='mods.id',
  +
id_array=mod_ids,
  +
}
  +
  +
for _, data in ipairs(results) do
  +
local mod_data = mods[data['mods.id']]
  +
mod_data.result = data
  +
  +
if mod_data.is_random == false then
  +
-- update item level requirement
  +
local keys = {'required_level_final'}
  +
-- only update base item requirement if this is an implicit
  +
if mod_data.key == 'implicit' then
  +
keys[#keys+1] = 'required_level'
  +
end
  +
  +
for _, key in ipairs(keys) do
  +
local req = math.floor(tonumber(data['mods.required_level']) * cfg.item_required_level_modifier_contribution)
  +
if req > tpl_args[key] then
  +
tpl_args[key] = req
  +
end
  +
end
  +
end
  +
end
  +
  +
-- fetch stats
  +
results = m_cargo.query(
  +
{'mods', 'mod_stats'},
  +
{'mods.id', 'mod_stats.id', 'mod_stats.min', 'mod_stats.max'},
  +
{
  +
join='mods._pageID=mod_stats._pageID',
  +
where=string.format('mod_stats.id IS NOT NULL AND mods.id IN ("%s")', table.concat(mod_ids, '", "')),
  +
}
  +
)
  +
for _, data in ipairs(results) do
  +
-- Stat subobject
  +
local mod_data = mods[data['mods.id']]
  +
if mod_data.result.stats == nil then
  +
mod_data.result.stats = {data, }
  +
else
  +
mod_data.result.stats[#mod_data.result.stats+1] = data
  +
end
  +
  +
local id = data['mod_stats.id']
  +
local value = {
  +
min = tonumber(data['mod_stats.min']),
  +
max = tonumber(data['mod_stats.max']),
  +
}
  +
value.avg = (value.min+value.max)/2
  +
  +
local prefix = ''
  +
if mod_data.is_random then
  +
prefix = '_random'
  +
end
  +
core.stats_update(tpl_args, id, value, mod_data.result['mods.id'], prefix .. '_stats')
  +
if mod_data.is_implicit then
  +
core.stats_update(tpl_args, id, value, mod_data.result['mods.id'], prefix .. '_implicit_stats')
  +
else
  +
core.stats_update(tpl_args, id, value, mod_data.result['mods.id'], prefix .. '_explicit_stats')
  +
end
  +
end
  +
  +
if tpl_args.is_sellable == true and tpl_args._flags.sell_prices_override ~= true then
  +
-- fetch sell prices
  +
results = m_cargo.query(
  +
{'mods', 'mod_sell_prices'},
  +
{'mods.id', 'mod_sell_prices.amount', 'mod_sell_prices.name'},
  +
{
  +
join='mods._pageID=mod_sell_prices._pageID',
  +
-- must be non random mods to avoid accumulating sell prices of randomized modifiers
  +
where=string.format('mod_sell_prices.amount IS NOT NULL AND mods.id IN ("%s")', table.concat(non_random_mod_ids, '", "')),
  +
}
  +
)
  +
  +
for _, data in ipairs(results) do
  +
local mod_data = mods[data['mods.id']]
  +
if not mod_data.is_implicit then
  +
local values = {
  +
name = data['mod_sell_prices.name'],
  +
amount = tonumber(data['mod_sell_prices.amount']),
  +
}
  +
-- sell_prices is defined in core.map.sell_prices_override
  +
tpl_args.sell_prices[values.name] = (tpl_args.sell_prices[values.name] or 0) + values.amount
  +
end
  +
end
  +
end
  +
end
  +
if tpl_args.is_sellable == true and tpl_args._flags.sell_prices_override ~= true then
  +
local missing_sell_price = true
  +
for _, _ in pairs(tpl_args.sell_prices) do
  +
missing_sell_price = false
  +
break
  +
end
  +
  +
if missing_sell_price then
  +
tpl_args.sell_prices[i18n.tooltips.default_vendor_offer] = 1
  +
end
  +
  +
-- Set sell price on page
  +
for name, amount in pairs(tpl_args.sell_prices) do
  +
-- sell_price_order is defined in core.map.sell_prices_override
  +
tpl_args.sell_price_order[#tpl_args.sell_price_order+1] = name
  +
tpl_args._subobjects[#tpl_args._subobjects+1] = {
  +
_table = 'item_sell_prices',
  +
amount = amount,
  +
name = name,
  +
}
  +
end
  +
table.sort(tpl_args.sell_price_order)
  +
end
  +
end
  +
  +
function s.process_stats(tpl_args, frame)
 
-- Add stats - this is for when mods are not set, but we still need stats to calcuate new armour values etc
 
-- Add stats - this is for when mods are not set, but we still need stats to calcuate new armour values etc
 
m_util.args.stats(tpl_args, {prefix='extra_'})
 
m_util.args.stats(tpl_args, {prefix='extra_'})
Строка 8724: Строка 2688:
 
stat.avg = stat.value
 
stat.avg = stat.value
 
end
 
end
h.stats_update(tpl_args, stat.id, stat, nil, '_stats')
+
core.stats_update(tpl_args, stat.id, stat, nil, '_stats')
h.stats_update(tpl_args, stat.id, stat, nil, '_explicit_stats')
+
core.stats_update(tpl_args, stat.id, stat, nil, '_explicit_stats')
 
end
 
end
   
Строка 8752: Строка 2716:
 
 
 
-- Handle extra stats (for gems)
 
-- Handle extra stats (for gems)
  +
if cfg.class_groups.gems.keys[tpl_args.class_id] then
 
if core.class_groups.gems.keys[tpl_args.class_id] then
+
h.skill(tpl_args, frame)
m_skill.skill(frame, tpl_args)
 
 
end
 
end
 
 
Строка 8766: Строка 2729:
 
for k, data in pairs(core.stat_map) do
 
for k, data in pairs(core.stat_map) do
 
local value = tpl_args[k]
 
local value = tpl_args[k]
 
 
if value ~= nil and skip[k] == nil then
 
if value ~= nil and skip[k] == nil then
 
value = {min=value, max=value, base=value}
 
value = {min=value, max=value, base=value}
Строка 8833: Строка 2795:
 
-- don't add the properties unless we need to
 
-- don't add the properties unless we need to
 
if (data.default ~= nil and (value.min ~= data.default or value.max ~= data.default)) or data.default == nil then
 
if (data.default ~= nil and (value.min ~= data.default or value.max ~= data.default)) or data.default == nil then
for short_key, range_data in pairs(h.range_map) do
+
for short_key, range_data in pairs(c.range_map) do
 
tpl_args[data.field .. range_data.var] = value[short_key]
 
tpl_args[data.field .. range_data.var] = value[short_key]
 
end
 
end
Строка 8841: Строка 2803:
 
end
 
end
 
 
for short_key, range_data in pairs(h.range_map) do
+
for short_key, range_data in pairs(c.range_map) do
 
tpl_args[k .. range_data.var] = value[short_key]
 
tpl_args[k .. range_data.var] = value[short_key]
 
end
 
end
 
end
 
end
 
end
 
end
  +
end
   
  +
function s.process_weapon_dps(tpl_args, frame)
-- calculate and handle weapon dps
 
  +
for key, data in pairs(core.dps_map) do
if core.class_groups.weapons.keys[tpl_args.class_id] then
 
for _, data in ipairs(core.dps_map) do
+
local damage = {
local damage = {
+
min = {},
min = {},
+
max = {},
max = {},
+
}
}
+
for var_type, value in pairs(damage) do
  +
-- covers the min/max/avg range
 
for var_type, value in pairs(damage) do
+
for short_key, range_data in pairs(c.range_map) do
-- covers the min/max/avg range
+
value[short_key] = 0
for short_key, range_data in pairs(h.range_map) do
+
for _, damage_key in ipairs(data.damage_args) do
value[short_key] = 0
+
value[short_key] = value[short_key] + (tpl_args[string.format('%s_%s%s', damage_key, var_type, range_data.var)] or 0)
for _, damage_key in ipairs(data.damage_args) do
 
value[short_key] = value[short_key] + (tpl_args[string.format('%s_%s%s', damage_key, var_type, range_data.var)] or 0)
 
end
 
 
end
 
end
end
 
 
local value = {}
 
for short_key, range_data in pairs(h.range_map) do
 
local result = (damage.min[short_key] + damage.max[short_key]) / 2 * tpl_args[string.format('attack_speed%s', range_data.var)]
 
value[short_key] = result
 
tpl_args[string.format('%s%s', data.field, range_data.var)] = result
 
end
 
 
if value.avg > 0 then
 
h.handle_range_args(tpl_args, frame, data.name, data.field, value, data.html_fmt_options or {})
 
 
end
 
end
  +
end
  +
local value = {}
  +
for short_key, range_data in pairs(c.range_map) do
  +
local result = (damage.min[short_key] + damage.max[short_key]) / 2 * tpl_args[string.format('attack_speed%s', range_data.var)]
  +
value[short_key] = result
  +
tpl_args[string.format('%s%s', data.field, range_data.var)] = result
  +
end
  +
if value.avg > 0 then
  +
h.handle_range_args(tpl_args, frame, key, data.field, value, data.html_fmt_options or {})
 
end
 
end
 
end
 
end
  +
end
 
  +
-- late processing
 
core.process_arguments(tpl_args, frame, {array=core.late_args})
+
function s.get_categories(tpl_args, frame)
core.process_arguments(tpl_args, frame, {array=core.item_classes[tpl_args.class_id].late_args})
 
 
-- Handle upgrade from restrictions/info
 
core.process_upgraded_from(tpl_args, frame)
 
 
 
-- Quest reward info
 
core.process_quest_rewards(tpl_args, frame)
 
 
-- ------------------------------------------------------------------------
 
-- Infobox handling
 
-- ------------------------------------------------------------------------
 
-- Store the infobox so it can be accessed with ease on other pages
 
tpl_args.html = tostring(core.display.make_main_container(tpl_args, frame, 'inline'))
 
local container = core.display.make_main_container(tpl_args, frame, 'infobox')
 
 
if tpl_args.inventory_icon ~= nil and tpl_args.class_id ~= 'DivinationCard' then
 
container:wikitext(string.format('[[%s|%sx%spx]]', tpl_args.inventory_icon, c.image_size_full*tpl_args.size_x, c.image_size_full*tpl_args.size_y))
 
end
 
 
--
 
-- Secondary infobox
 
--
 
 
tpl_args.extra_infobox = mw.html.create('span')
 
:attr( 'class', 'item-box -' .. tpl_args.frame_type)
 
 
core.display.add_to_container_from_map(tpl_args, frame, tpl_args.extra_infobox, core.extra_display_groups)
 
 
--
 
-- Output
 
--
 
 
local infobox = mw.html.create('span')
 
infobox
 
:attr('class', 'infobox-page-container')
 
:node(container)
 
:node(tpl_args.extra_infobox)
 
 
-- skill_screenshot is set in skill module
 
if tpl_args.skill_screenshot then
 
infobox:wikitext(string.format('<br>[[%s|300px]]', tpl_args.skill_screenshot))
 
end
 
 
local out = tostring(infobox)
 
tpl_args.html_extra = out
 
 
-- ------------------------------------------------------------------------
 
-- Category handling
 
-- ------------------------------------------------------------------------
 
 
 
local cats = {}
 
local cats = {}
 
if tpl_args.rarity_id == 'unique' then
 
if tpl_args.rarity_id == 'unique' then
Строка 8943: Строка 2850:
 
cats[#cats+1] = i18n.categories.essences
 
cats[#cats+1] = i18n.categories.essences
 
elseif tpl_args.class_id == 'Map' then
 
elseif tpl_args.class_id == 'Map' then
cats[#cats+1] = string.format('%s (%s)', tpl_args.class, tpl_args.map_series)
+
cats[#cats+1] = string.format('%s %s', tpl_args.map_series, tpl_args.class)
 
else
 
else
 
cats[#cats+1] = tpl_args.class
 
cats[#cats+1] = tpl_args.class
 
end
 
end
 
 
if tpl_args.rarity_id ~= 'normal' or tpl_args.base_item == 'Пророчество' or tpl_args.base_item_id == 'Metadata/Items/Currency/CurrencyItemisedProphecy' then
+
if tpl_args.rarity_id ~= 'normal' or tpl_args.base_item_id == 'Metadata/Items/Currency/CurrencyItemisedProphecy' then
 
cats[#cats+1] = i18n.categories.derived_items
 
cats[#cats+1] = i18n.categories.derived_items
 
else
 
else
Строка 8956: Строка 2863:
 
for _, attr in ipairs(m_game.constants.attribute_order) do
 
for _, attr in ipairs(m_game.constants.attribute_order) do
 
if tpl_args[attr .. '_percent'] then
 
if tpl_args[attr .. '_percent'] then
cats[#cats+1] = string.format('%s %s', tpl_args.class, m_game.constants.attributes[attr].long_lower_2)
+
cats[#cats+1] = string.format('%s %s', m_game.constants.attributes[attr].long_upper, tpl_args.class)
 
end
 
end
 
end
 
end
Строка 8968: Строка 2875:
 
cats[#cats+1] = string.format(affix, tag)
 
cats[#cats+1] = string.format(affix, tag)
 
end
 
end
  +
end
  +
  +
if #tpl_args._defined_implicit_mods > 0 and tpl_args.rarity_id ~= 'normal' then
  +
cats[#cats+1] = i18n.categories.implicit_modifier_override
 
end
 
end
 
 
Строка 8973: Строка 2884:
 
cats[#cats+1] = i18n.categories.alternate_artwork
 
cats[#cats+1] = i18n.categories.alternate_artwork
 
end
 
end
 
-- TODO: add maintenance categories
 
 
 
 
if tpl_args.release_version == nil then
 
if tpl_args.release_version == nil then
Строка 8990: Строка 2899:
 
end
 
end
 
end
 
end
  +
  +
if tpl_args._flags.has_deprecated_skill_parameters then
  +
cats[#cats+1] = i18n.categories.deprecated_skill_parameters
  +
end
  +
return cats
  +
end
  +
  +
-- ----------------------------------------------------------------------------
  +
-- Exported functions
  +
-- ----------------------------------------------------------------------------
  +
  +
local p = {}
  +
  +
--
  +
-- Template:Item
  +
--
  +
function p.item(frame)
  +
local t = os.clock() -- Start time (for logging)
 
 
  +
local tpl_args = getArgs(frame, {
out = out .. m_util.misc.add_category(cats, {ingore_blacklist=tpl_args.debug})
 
  +
parentFirst = true
  +
})
  +
frame = m_util.misc.get_frame(frame)
  +
  +
tpl_args._flags = {}
  +
tpl_args._base_item_args = {}
  +
tpl_args._base_implicit_mods = {}
  +
tpl_args._defined_implicit_mods = {}
  +
tpl_args._mods = {}
  +
for _, k in ipairs({'', '_random'}) do
  +
for _, prefix in ipairs({'', '_implicit', '_explicit'}) do
  +
tpl_args[k .. prefix .. '_stats'] = {}
  +
end
  +
end
  +
tpl_args._subobjects = {}
  +
tpl_args._properties = {}
  +
tpl_args._errors = {}
  +
  +
-- Item configuration
  +
tpl_args._item_config = s.get_item_config(tpl_args, frame)
  +
  +
-- Add table names to core.map and append range fields.
  +
h.append_schema(tpl_args, frame, tpl_args._item_config.tables)
  +
  +
-- Using general purpose function to handle release and removal versions
  +
m_util.args.version(tpl_args, {frame=frame, set_properties=true})
  +
  +
-- Must validate some argument early. It is required for future things
  +
h.process_arguments(tpl_args, frame, tpl_args._item_config.args)
  +
  +
-- Base item
  +
s.process_base_item(tpl_args, frame)
  +
  +
-- Prophecies are considered currency items, but they have their own schema
  +
if tpl_args._flags.is_prophecy then
  +
h.process_arguments(tpl_args, frame, cfg.prophecy_args)
  +
end
  +
  +
-- Mods
  +
s.process_mods(tpl_args, frame)
  +
  +
-- Stats
  +
s.process_stats(tpl_args, frame)
  +
  +
-- Calculate and handle weapon dps
  +
if cfg.class_groups.weapons.keys[tpl_args.class_id] then
  +
s.process_weapon_dps(tpl_args, frame)
  +
end
  +
  +
-- Late argument processing
  +
h.process_arguments(tpl_args, frame, tpl_args._item_config.late_args)
  +
  +
-- Handle upgrade from restrictions/info
  +
h.process_upgraded_from(tpl_args, frame)
  +
  +
-- Quest reward info
  +
s.process_quest_rewards(tpl_args, frame)
  +
  +
-- ------------------------------------------------------------------------
  +
-- Infobox handling
  +
-- ------------------------------------------------------------------------
  +
-- Store the infobox so it can be accessed with ease on other pages
  +
tpl_args.html = tostring(h.make_main_container(tpl_args, frame, 'inline'))
  +
local container = h.make_main_container(tpl_args, frame, 'infobox')
  +
  +
if tpl_args.inventory_icon ~= nil and tpl_args.class_id ~= 'DivinationCard' then
  +
container:tag('span')
  +
:addClass('images')
  +
:wikitext(string.format(
  +
'[[%s|%sx%spx]]',
  +
tpl_args.inventory_icon,
  +
cfg.image_size_full * tpl_args.size_x,
  +
cfg.image_size_full * tpl_args.size_y
  +
))
  +
end
  +
  +
--
  +
-- Secondary infobox
  +
--
  +
  +
tpl_args.extra_infobox = mw.html.create('span')
  +
:attr( 'class', 'item-box -' .. tpl_args.frame_type)
  +
  +
h.add_to_container_from_map(tpl_args, frame, tpl_args.extra_infobox, c.extra_display_groups)
  +
  +
--
  +
-- Output
  +
--
  +
  +
local infobox = mw.html.create('span')
  +
infobox
  +
:attr('class', 'infobox-page-container')
  +
:node(container)
  +
:node(tpl_args.extra_infobox)
  +
  +
-- skill_screenshot is set in skill module
  +
if tpl_args.skill_screenshot then
  +
infobox:wikitext(string.format('<br>[[%s|300px]]', tpl_args.skill_screenshot))
  +
end
  +
  +
local out = tostring(infobox)
  +
tpl_args.html_extra = out
  +
  +
local cats = s.get_categories(tpl_args, frame)
  +
  +
out = out .. m_util.misc.add_category(cats, {ignore_blacklist=tpl_args.debug})
 
 
 
--
 
--
Строка 9007: Строка 3040:
   
 
if query_id then
 
if query_id then
out = out .. m_area.query_area_info{cats=yes, where=string.format('areas.id="%s"', query_id)}
+
out = out .. h.query_area_info{cats=true, where=string.format('areas.id="%s"', query_id)}
 
end
 
end
 
 
Строка 9014: Строка 3047:
 
-- ------------------------------------------------------------------------
 
-- ------------------------------------------------------------------------
 
-- Map argument values for cargo storage
 
-- Map argument values for cargo storage
for _, table_name in ipairs(core.item_classes[tpl_args.class_id].tables) do
+
for _, table_name in ipairs(tpl_args._item_config.tables) do
 
tpl_args._subobjects[table_name] = {
 
tpl_args._subobjects[table_name] = {
 
_table = table_name,
 
_table = table_name,
Строка 9026: Строка 3059:
 
v = tonumber(string.format("%.0f", v))
 
v = tonumber(string.format("%.0f", v))
 
if v ~= tpl_args[k] then
 
if v ~= tpl_args[k] then
mw.logObject(string.format('Float value "%s" for integer field "%s.%s"', tpl_args[k], data.table, data.field))
+
mw.log(string.format('Float value "%s" for integer field "%s.%s"', tpl_args[k], data.table, data.field))
 
end
 
end
 
end
 
end
 
tpl_args._subobjects[data.table][data.field] = v
 
tpl_args._subobjects[data.table][data.field] = v
elseif data.table == nil and data.field ~= nil then
 
error(string.format('Missing table for field "%s", key "%s", \nvalue:\n "%s" \ndata:\n%s', data.field, k, mw.dumpObject(v), mw.dumpObject(data)))
 
 
elseif data.table ~= nil and data.field == nil then
 
elseif data.table ~= nil and data.field == nil then
 
error(string.format('Missing field for table "%s", key "%s", \nvalue:\n "%s" \ndata:\n%s', data.table, k, mw.dumpObject(v), mw.dumpObject(data)))
 
error(string.format('Missing field for table "%s", key "%s", \nvalue:\n "%s" \ndata:\n%s', data.table, k, mw.dumpObject(v), mw.dumpObject(data)))
  +
elseif data.table == nil and data.field ~= nil then
  +
mw.log(string.format('Possibly redundant argument "%s", value:\n "%s"', k, mw.dumpObject(v)))
 
end
 
end
 
end
 
end
 
end
 
end
 
 
-- Don't actually save data in testing mode
+
-- Don't store cargo data in testing mode
 
if not tpl_args.test then
 
if not tpl_args.test then
 
local attach = {}
 
local attach = {}
Строка 9067: Строка 3100:
 
-- Show additional error messages in console to help fixing them
 
-- Show additional error messages in console to help fixing them
 
if #tpl_args._errors > 0 then
 
if #tpl_args._errors > 0 then
mw.logObject(table.concat(tpl_args._errors, '\n'))
+
mw.log(table.concat(tpl_args._errors, '\n'))
 
end
 
end
 
 
  +
if tpl_args.debug then
  +
mw.log(os.clock() - t)
  +
mw.log('Start logging tpl_args.')
  +
mw.logObject(tpl_args)
  +
mw.log('Stop logging tpl_args.')
  +
mw.log('Start logging core.map.')
  +
mw.logObject(core.map)
  +
mw.log('Stop logging core.map.')
  +
end
 
if tpl_args.test then
 
if tpl_args.test then
 
tpl_args.out = out
 
tpl_args.out = out
 
return tpl_args
 
return tpl_args
else
 
mw.logObject(os.clock() - t)
 
return out
 
 
end
 
end
  +
return out
 
end
 
end
   
  +
p.itembox = p.item -- Apparently this is still used somewhere???
p.item = p.itembox
 
   
  +
--
 
  +
-- Template:Itembox
function p.query_itembox (frame)
 
  +
--
  +
function p.query_itembox(frame)
 
--[[
 
--[[
 
Queries for an item box.
 
Queries for an item box.
Строка 9088: Строка 3130:
 
Examples
 
Examples
 
--------
 
--------
=p.query_itembox{page='Карта пляжа (Предательство)'}
+
=p.query_itembox{page='Beach Map (Betrayal)'}
 
]]
 
]]
 
 
Строка 9106: Строка 3148:
 
 
 
if #results == 0 then
 
if #results == 0 then
error('Никаких результатов не найдено')
+
error(i18n.errors.no_results_found)
 
end
 
end
 
 
Строка 9116: Строка 3158:
 
return table.concat(out, '')
 
return table.concat(out, '')
 
end
 
end
 
-- ----------------------------------------------------------------------------
 
-- Result formatting templates for SMW queries
 
-- ----------------------------------------------------------------------------
 
 
--
 
-- Template:
 
--
 
 
function p.simple_item_list(frame)
 
-- Args
 
local tpl_args = getArgs(frame, {
 
parentFirst = true
 
})
 
frame = m_util.misc.get_frame(frame)
 
 
local query = {}
 
for key, value in pairs(tpl_args) do
 
if string.sub(key, 0, 2) == 'q_' then
 
query[string.sub(key, 3)] = value
 
end
 
end
 
 
local fields = {
 
'items._pageName',
 
'items.name',
 
}
 
 
if tpl_args.no_icon == nil then
 
fields[#fields+1] = 'items.inventory_icon'
 
end
 
 
if tpl_args.no_html == nil then
 
fields[#fields+1] = 'items.html'
 
end
 
 
local tables = m_util.string.split(tpl_args.q_tables or '', ',%s*')
 
table.insert(tables, 'items')
 
 
query.groupBy = query.groupBy or 'items._pageID'
 
 
local results = m_cargo.query(
 
tables,
 
fields,
 
query
 
)
 
 
local out = {}
 
for _, row in ipairs(results) do
 
local link = f_item_link{page=row['items._pageName'], name=row['items.name'], inventory_icon=row['items.inventory_icon'] or '', html=row['items.html'] or '', skip_query=true}
 
if tpl_args.format == nil then
 
out[#out+1] = string.format('* %s', link)
 
elseif tpl_args.format == 'none' then
 
out[#out+1] = link
 
elseif tpl_args.format == 'li' then
 
out[#out+1] = string.format('<li>%s</li>', link)
 
else
 
error(string.format(i18n.errors.generic_argument_parameter, 'format', tpl_args.format))
 
end
 
end
 
 
if tpl_args.format == nil then
 
return table.concat(out, '\n')
 
elseif tpl_args.format == 'none' then
 
return table.concat(out, '\n')
 
elseif tpl_args.format == 'li' then
 
return table.concat(out)
 
end
 
end
 
 
-- ----------------------------------------------------------------------------
 
-- Misc. Item templates
 
-- ----------------------------------------------------------------------------
 
 
--
 
-- Template:Item class
 
--
 
 
function p.item_class (frame)
 
-- Get args
 
local tpl_args = getArgs(frame, {
 
parentFirst = true
 
})
 
frame = m_util.misc.get_frame(frame)
 
 
if not doInfoCard then
 
doInfoCard = require('Module:Infocard')._main
 
end
 
 
local err = true
 
for _, row in pairs(m_game.constants.item.classes) do
 
if row['full'] == tpl_args.name then
 
err = false
 
break
 
end
 
end
 
 
if err then
 
error(string.format(i18n.errors.invalid_class, tostring(tpl_args.name)))
 
end
 
 
if tpl_args.name_list ~= nil then
 
tpl_args.name_list = m_util.string.split(tpl_args.name_list, ',%s*')
 
else
 
tpl_args.name_list = {}
 
end
 
 
--
 
 
local ul = mw.html.create('ul')
 
for _, item in ipairs(tpl_args.name_list) do
 
ul
 
:tag('li')
 
:wikitext(item)
 
:done()
 
end
 
 
 
-- Output Infocard
 
 
local tplargs = {
 
['header'] = tpl_args.name,
 
['subheader'] = i18n.item_class_infobox.page .. i18n.item_class_infobox.info,
 
[1] = i18n.item_class_infobox.also_referred_to_as .. tostring(ul),
 
}
 
 
-- cats
 
 
local cats = {
 
'Классы предметов',
 
tpl_args.name,
 
}
 
 
-- Done
 
 
return doInfoCard(tplargs) .. m_util.misc.add_category(cats, {ingore_blacklist=tpl_args.debug})
 
end
 
 
-- ----------------------------------------------------------------------------
 
-- Debug stuff
 
-- ----------------------------------------------------------------------------
 
 
function p.debug_print_tables (frame)
 
frame = m_util.misc.get_frame(frame)
 
for key, data in pairs(core.cargo) do
 
mw.logObject(data.table)
 
end
 
end
 
 
function p.debug_attach_test (frame)
 
frame = m_util.misc.get_frame(frame)
 
for key, data in pairs(core.cargo) do
 
m_cargo.attach(frame, {_table=data.table})
 
end
 
end
 
 
function p.debug_validate_auto_upgraded_from (frame)
 
frame = m_util.misc.get_frame(frame)
 
 
local q = {}
 
local chk = {}
 
for _, data in ipairs(core.automatic_upgraded_from) do
 
for _, group in ipairs(data.groups) do
 
q[#q+1] = group.item_id
 
chk[group.item_id] = {
 
amount=group.amount,
 
text=data.text({}, frame),
 
}
 
end
 
end
 
 
local results = m_cargo.array_query{
 
tables={'items', 'stackables'},
 
fields={'items.name', 'items.class_id', 'items.description', 'stackables.stack_size'},
 
id_field='items.metadata_id',
 
id_array=q,
 
query={
 
join='items._pageName=stackables._pageName',
 
},
 
}
 
 
for _, row in ipairs(results) do
 
if row['items.class_id'] == 'DivinationCard' and chk[row['items.metadata_id']].amount ~= tonumber(row['stackables.stack_size']) then
 
mw.logObject(string.format('Amount mismatch %s, expected %s', row['items.metadata_id'], row['stackables.stack_size']))
 
end
 
end
 
 
tbl = mw.html.create('table')
 
tbl:attr('class', 'wikitable sortable')
 
for _, row in ipairs(results) do
 
tbl
 
:tag('tr')
 
:tag('td')
 
:wikitext(row['items.name'])
 
:done()
 
:tag('td')
 
:wikitext(chk[row['items.metadata_id']].text)
 
:done()
 
:tag('td')
 
:wikitext(row['items.description'])
 
:done()
 
:done()
 
end
 
 
return tostring(tbl)
 
end
 
 
p.h = h
 
 
-- ----------------------------------------------------------------------------
 
-- Return
 
-- ----------------------------------------------------------------------------
 
   
 
return p
 
return p

Текущая версия от 15:27, 6 сентября 2023

Template info icon Документация модуля[просмотр] [править] [история] [очистить]

Предоставляет функциональные возможности для различных шаблонов, связанных с предметами.

Описание

This module is responsible for creating item boxes, various item lists, item links and other item-related tasks. In the process a lot of the input data is verified and also added as semantic property to pages; as such, any templates deriving from this module should not be used on user pages other then for temporary testing purposes.

This template is also backed by an export script in PyPoE which can be used to export item data from the game files which then can be used on the wiki. Use the export when possible,

Шаблоны Item

Модуль:Item2

Все шаблоны, определенные в Модуль:Item2:

Модуль:Item table

Все шаблоны, определенные в Модуль:Item table:

Модуль:Item link

Все шаблоны, определенные в Модуль:Item link:

Модуль:Item acquisition

-------------------------------------------------------------------------------
-- 
--                                Module:Item2
-- 
-- This module implements Template:Item and Template:Itembox
-------------------------------------------------------------------------------

-- ----------------------------------------------------------------------------
-- TODO
-- ----------------------------------------------------------------------------
-- Items
-- -----
-- Check if abyss jewels actually have radius modifiers
-- 
-- Aggregate ids from skill id from modifiers
-- 
--
-- unique items:
--  3D art
--  supporter attribution
--
-- Maps: 
--  Area level can be retrieved eventually
--
-- Essence: 
--  type column
--  monster modifier info
--
-- random modifier
-- -> sell price must consider random mods
--
-- ----------
-- Item class
-- ----------
--
-- remove the ul if name_list is not provided

require('Module:No globals')
local getArgs = require('Module:Arguments').getArgs
local m_util = require('Module:Util')
local m_cargo = require('Module:Cargo')

local m_game = mw.loadData('Module:Game')

-- Should we use the sandbox version of our submodules?
local use_sandbox = m_util.misc.maybe_sandbox('Item2')

-- Lazy loading
local f_skill -- require('Module:Skill')._skill
local f_item_link -- require('Module:Item link').item_link
local f_query_area_info -- require('Module:Area').query_area_info
local f_process_upgraded_from -- require('Module:Item2/upgrade').process_upgraded_from
local f_append_schema -- require('Module:Item2/cargo').append_schema

-- The cfg table contains all localisable strings and configuration, to make it
-- easier to port this module to another wiki.
local cfg = use_sandbox and mw.loadData('Module:Item2/config/sandbox') or mw.loadData('Module:Item2/config')

local i18n = cfg.i18n

local core = use_sandbox and require('Module:Item2/core/sandbox') or require('Module:Item2/core')

-- Declare early to avoid errors
local c = {}

-- ----------------------------------------------------------------------------
-- Helper functions
-- ----------------------------------------------------------------------------

local h = {}

-- Lazy loading for Module:Skill
function h.skill(tpl_args, frame)
    if not f_skill then
        f_skill = use_sandbox and require('Module:Skill/sandbox')._skill or require('Module:Skill')._skill
    end
    return f_skill(tpl_args, frame)
end

-- Lazy loading for Module:Item link
function h.item_link(args)
    if not f_item_link then
        f_item_link = require('Module:Item link').item_link
    end
    return f_item_link(args)
end

-- Lazy loading for Module:Item link
function h.query_area_info(args)
    if not f_query_area_info then
        f_query_area_info = require('Module:Area').query_area_info
    end
    return f_query_area_info(args)
end

-- Lazy loading for Module:Item2/cargo
function h.append_schema(tpl_args, frame, tables)
    if not f_append_schema then
        f_append_schema = use_sandbox and require('Module:Item2/cargo/sandbox').append_schema or require('Module:Item2/cargo').append_schema
    end
    return f_append_schema(tpl_args, frame, tables)
end

-- Lazy loading for Module:Item2/upgrade
function h.process_upgraded_from(tpl_args, frame)
    if not f_process_upgraded_from then
        f_process_upgraded_from = use_sandbox and require('Module:Item2/upgrade/sandbox').process_upgraded_from or require('Module:Item2/upgrade').process_upgraded_from
    end
    return f_process_upgraded_from(tpl_args, frame)
end

function h.validate_mod(tpl_args, frame, args)
    -- args:
    --  key   - implict or explicit
    --  i
    --  value
    local prefix = args.key .. args.i
    local value = tpl_args[prefix]
    local is_implicit = args.key == 'implicit'
    local out = {
        result=nil,
        -- commited to cargo at a later point
        id=nil,
        stat_text=nil,
        is_implicit=is_implicit,
        is_random=nil,
    }
    
    local mods_table = is_implicit and tpl_args._defined_implicit_mods or tpl_args._mods
    if value ~= nil then
        out.id = value
        out.stat_text = tpl_args[prefix .. '_text']
        out.is_random = false
        table.insert(mods_table, out)
        
        return true
    elseif tpl_args[prefix .. '_random_list'] then
        tpl_args._flags.random_mods = true
        value = m_util.string.split(tpl_args[prefix ..  '_random_list'], ',%s*')
        for _, mod_id in ipairs(value) do
            table.insert(mods_table, {
                result = nil,
                id = mod_id,
                stat_text = tpl_args[prefix .. '_text'] or string.format(i18n.tooltips.random_mod, args.i),
                is_implicit = is_implicit,
                is_random = true,
            })
        end
        
        return true
    elseif tpl_args[prefix .. '_text'] then
        value = tpl_args[prefix .. '_text']
        tpl_args._flags.text_modifier = true
        out.result = value
        out.stat_text = value
        out.is_random = false
        table.insert(mods_table, out)
        
        return true
    end
    
    return false
end

function h.handle_range_args(tpl_args, frame, argument_key, field, value, fmt_options)
    fmt_options = mw.clone(fmt_options)
    fmt_options.return_color = true
    local html, colour = m_util.html.format_value(tpl_args, frame, value, fmt_options)
    tpl_args[argument_key .. '_html'] = html
    tpl_args[field .. '_html'] = html
    tpl_args[field .. '_range_colour'] = colour
    
    fmt_options = mw.clone(fmt_options)
    fmt_options.no_color = true
    tpl_args[field .. '_range_text'] = m_util.html.format_value(tpl_args, frame, value, fmt_options)
end

h.stat = {}
function h.stat.add(value, stat_cached) 
    value.min = value.min + stat_cached.min
    value.max = value.max + stat_cached.max
end

function h.stat.more(value, stat_cached)
    value.min = value.min * (1 + stat_cached.min / 100)
    value.max = value.max * (1 + stat_cached.max / 100)
end

function h.stat.more_inverse(value, stat_cached)
    value.min = value.min / (1 + stat_cached.min / 100)
    value.max = value.max / (1 + stat_cached.max / 100)
end

--
-- Processing
--

function h.process_arguments(tpl_args, frame, params)
    tpl_args._processed_args = tpl_args._processed_args or {}
    for _, k in ipairs(params) do
        local data = core.map[k]
        if data == nil then
            if tpl_args.debug then
                error(string.format(i18n.debug.invalid_argument_key, k))
            end
        else
            if data.inherit ~= false then
                table.insert(tpl_args._base_item_args, k)
            end
            if data.func ~= nil then
                tpl_args[k] = data.func(tpl_args, frame, tpl_args[k])
            end
            if tpl_args[k] == nil then
                if tpl_args.class_id and tpl_args._item_config.defaults ~= nil and tpl_args._item_config.defaults[k] ~= nil then
                    -- Item defaults
                    tpl_args[k] = tpl_args._item_config.defaults[k]
                elseif data.default ~= nil then
                    -- Generic defaults
                    if type(data.default) == 'function' then
                        tpl_args[k] = data.default(tpl_args, frame)
                    else
                        tpl_args[k] = data.default
                    end
                end
            end
            tpl_args._processed_args[k] = true
        end
    end
end

--
-- Display
--

function h.strip_random_stats(tpl_args, frame, stat_text, container_type)
    if tpl_args._flags.random_mods and container_type == 'inline' then
        repeat
            local text = string.match(stat_text, '<th class="mw%-customtoggle%-31">(.+)</th>')
            if text ~= nil then
                stat_text = string.gsub(stat_text, '<table class="random%-modifier%-stats.+</table>', text, 1)
            end
        until text == nil
    end
    return stat_text
end

function h.add_to_container_from_map(tpl_args, frame, container, mapping, container_type)
    local statcont = mw.html.create('span')
    statcont
        :attr('class', 'item-stats')
        :done()
    local count = 0 -- Number of groups in container
    for _, group in ipairs(mapping) do
        local lines = {}
        if group.func == nil then
            for _, line in ipairs(group) do
                local show = true
                if container_type == 'inline' and line.inline == false then -- TODO: This is not used currently. Need to address what is hidden in inline view.
                    show = false
                elseif line.show == false then
                    show = false
                elseif type(line.show) == 'function' then
                    show = line.show(tpl_args, frame, container_type)
                end
                if show then
                    lines[#lines+1] = line.func(tpl_args, frame, container_type)
                end
            end
        else
            lines = group.func(tpl_args, frame, container_type)
        end
        if #lines > 0 then
            count = count + 1
            local heading = ''
            if group.heading == nil then
            elseif type(group.heading) == 'function' then
                heading = group.heading()
            else
                heading = string.format('<em class="header">%s</em><br>', group.heading)
            end
            statcont
                :tag('span')
                :attr('class', 'group ' .. (group.class or ''))
                :wikitext(heading .. table.concat(lines, '<br>'))
                :done()
        end
    end

     -- Add groups to container
    if count > 0 then
        container:node(statcont)
    end
end

function h.make_main_container(tpl_args, frame, container_type)
    local container = mw.html.create('span')
        :attr('class', 'item-box -' .. tpl_args.frame_type)
    
    if tpl_args.class_id == 'DivinationCard' then
        container
            :tag('span')
                :attr('class', 'divicard-wrapper')
                :tag('span')
                    :attr('class', 'divicard-art')
                    :wikitext( '[[' .. tpl_args.card_art .. '|link=|alt=]]' )
                    :done()
                :tag('span')
                    :attr('class', 'divicard-frame')
                    :wikitext( '[[File:Divination card frame.png|link=|alt=]]' )
                    :done()
                :tag('span')
                    :attr('class', 'divicard-header')
                    :wikitext(tpl_args.name)
                    :done()
                :tag('span')
                    :attr('class', 'divicard-stack')
                    :wikitext(tpl_args.stack_size)
                    :done()
                :tag('span')
                    :attr('class', 'divicard-reward')
                    :tag('span')
                        :wikitext(tpl_args.description)
                        :done()
                    :done()
                :tag('span')
                    :attr('class', 'divicard-flavour text-color -flavour')
                    :tag('span')
                        :wikitext(tpl_args.flavour_text)
                        :done()
                    :done()
                :done()
        --TODO Extras?
    else
        local header_css
        local line_type
        if tpl_args.base_item and tpl_args.rarity_id ~= 'normal' then
            line_type = 'double'
        else
            line_type = 'single'
        end
        
        local name_line = tpl_args.name
        if tpl_args.base_item and not tpl_args._flags.is_prophecy then
            name_line = name_line .. '<br>' .. tpl_args.base_item
        end

        -- Symbols - These are displayed in the item box header to indicate certain flags and/or item influences
        local symbols
        local influences = tpl_args.influences or {}
        if tpl_args.is_replica then
            symbols = {'replica', 'replica'}
            if #influences > 0 then
                symbols[2] = influences[1]
            end
        elseif #influences > 0 then
            symbols = {influences[1], influences[1]}
            if #influences > 1 then
                symbols[2] = influences[2]
            end
        elseif tpl_args.is_fractured then
            symbols = {'fractured', 'fractured'}
        elseif tpl_args.is_synthesised then
            symbols = {'synthesised', 'synthesised'}
        elseif tpl_args.is_veiled then
            symbols = {'veiled', 'veiled'}
        end
        
        container
            :tag('span')
                :attr( 'class', 'header -' .. line_type )
                :tag('span')
                    :attr( 'class', 'symbol' .. (symbols and ' -' .. symbols[1] or '') )
                    :done()
                :wikitext(name_line)
                :tag('span')
                    :attr( 'class', 'symbol' .. (symbols and ' -' .. symbols[2] or '') )
                    :done()
            :done()
            
        h.add_to_container_from_map(tpl_args, frame, container, c.item_infobox_groups, container_type)
    end
    
    if tpl_args.skill_icon ~= nil then
        container:wikitext(string.format('[[%s]]', tpl_args.skill_icon))
    end
    
    return container
end

-- 
-- Factory
-- 

h.factory = {}

function h.factory.maybe_show_infobox_line(args)
    -- Verifies that a list of keys are present in tpl_args and that the item 
    -- should use those keys. Returns true if all conditions are met, otherwise 
    -- returns false.
    return function (tpl_args)
        local keys = args.keys or {}
        local conditions = args.conditions or {}
        if #keys == 0 then
            return false
        end
        for _, k in ipairs(keys) do
            if tpl_args[k] == nil then
                return false
            end
            local t = type(tpl_args[k])
            if (t == 'table' or t == 'string') and #tpl_args[k] == 0 then
                return false
            end
            if conditions.processed == true and tpl_args._processed_args[k] == nil then
                return false
            end
        end
        return true
    end
end

function h.factory.display_raw_value(key)
    return function(tpl_args, frame)
        return tpl_args[key]
    end
end

function h.factory.descriptor_value(args)
    -- Arguments:
    --  key
    --  tbl
    args = args or {}
    return function (tpl_args, frame, value)
        args.tbl = args.tbl or tpl_args
        if args.tbl[args.key] then
            value = m_util.html.abbr(value, args.tbl[args.key])
        end
        return value
    end
end

-- ----------------------------------------------------------------------------
-- Additional configuration
-- ----------------------------------------------------------------------------

-- helper to loop over the range variables easier
c.range_map = {
    min = {
        var = '_range_minimum',
    },
    max = {
        var = '_range_maximum',
    },
    avg = {
        var = '_range_average',
    },
}

--
-- Contents here are meant to resemble the ingame infobox of items
--
c.item_infobox_groups = {
    -- [n]: 
    --  class: Additional css class added to group tag
    --  heading: Group heading text (used for extras)
    --  lines: 
    --   [n]: 
    --    show: Show line if this function returns true; Always show if boolean true. Default: Always show
    --    func: Function that returns line text
    {
        -- Cosmetic item type
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'cosmetic_type'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'cosmetic_type',
                        fmt = '%s',
                        color = 'default'
                    },
                },
            },
        },
        -- Weapon type
        {
            show = function (tpl_args, frame)
                if tpl_args.class_id == nil then 
                    return false 
                end
                return cfg.class_groups.weapons.keys[tpl_args.class_id] ~= nil
            end,
            func = function (tpl_args, frame)
                local v = i18n.item_class_map[tpl_args.class_id]
                return m_util.html.format_value(tpl_args, frame, {min=v, max=v}, {color = 'default'})
            end,
        },
        -- Hideout item type
        {
            show = function (tpl_args, frame)
                return tpl_args.class_id == 'HideoutDoodad'
            end,
            func = function (tpl_args, frame)
                return i18n.item_class_map[tpl_args.class_id]
            end,
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'gem_tags'},
                conditions = {processed = true},
            },
            func = function (tpl_args, frame)
                local out = {}
                for i, tag in ipairs(tpl_args.gem_tags) do
                    out[#out+1] = string.format(i18n.gem_tag_category, tag, tag)
                end
                return table.concat(out, ', ')
            end,
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'support_gem_letter_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'support_gem_letter_html',
                    },
                },
                fmt = i18n.tooltips.support_icon,
            },
        },
        {
            show = function (tpl_args, frame)
                return tpl_args.skill_levels and cfg.class_groups.gems.keys[tpl_args.class_id]
            end,
            func = function (tpl_args, frame)
                local value = {
                    base = 1,
                    min = 1,
                    max = tpl_args.max_level,
                }
                local options = {
                    color = 'value',
                }
                return string.format(
                    i18n.tooltips.level,
                    m_util.html.format_value(tpl_args, frame, value, options)
                )
            end,
        },
        {
            show = function (tpl_args, frame)
                return tpl_args.skill_costs
            end,
            func = function (tpl_args, frame)
                local parts = {}
                if not tpl_args.skill_costs.has_spending_cost then
                    -- Try falling back to deprecated parameters
                    if not tpl_args.has_reservation_mana_cost then
                        parts[1] = {
                            key = 'mana_cost',
                            fmt = '%i',
                            color = false,
                            inline = string.format('%%s %s', m_game.constants.skill.cost_types.mana.long_upper),
                            inline_color = 'value',
                        }
                    end
                else
                    for i=1, #tpl_args.skill_costs do
                        if not tpl_args.skill_costs[i].is_reservation then -- Only get spending costs
                            local cost_type = tpl_args.skill_costs[i].type
                            parts[#parts+1] = {
                                key = {'costs', i, 'amount'},
                                fmt = '%i',
                                color = false,
                                inline = string.format(
                                    '%%s%s %s',
                                    string.find(cost_type, 'percent', 1, true) and '%%' or '',
                                    m_game.constants.skill.cost_types[cost_type].long_upper
                                ),
                                inline_color = 'value',
                            }
                        end
                    end
                end
                return core.factory.infobox_line{
                    type = 'gem',
                    parts = parts,
                    sep = ', ',
                    fmt = i18n.tooltips.cost,
                }(tpl_args, frame)
            end,
        },
        {
            show = function (tpl_args, frame)
                return tpl_args.skill_costs
            end,
            func = function (tpl_args, frame)
                if not tpl_args.skill_costs then
                    return
                end
                local parts = {}
                if not tpl_args.skill_costs.has_reservation_cost then
                    -- Try falling back to deprecated parameters
                    if tpl_args.has_reservation_mana_cost then
                        parts[1] = {
                            key = 'mana_cost',
                            fmt = '%i',
                            color = false,
                            inline = string.format(
                                '%%s%s %s',
                                tpl_args.has_percentage_mana_cost and '%%' or '',
                                m_game.constants.skill.cost_types.mana.long_upper
                            ),
                            inline_color = 'value',
                        }
                    end
                else
                    for i=1, #tpl_args.skill_costs do
                        if tpl_args.skill_costs[i].is_reservation then -- Only get reservation costs
                            local cost_type = tpl_args.skill_costs[i].type
                            parts[#parts+1] = {
                                key = {'costs', i, 'amount'},
                                fmt = '%i',
                                color = false,
                                inline = string.format(
                                    '%%s%s %s',
                                    string.find(cost_type, 'percent', 1, true) and '%%' or '',
                                    m_game.constants.skill.cost_types[cost_type].long_upper
                                ),
                                inline_color = 'value',
                            }
                        end
                    end
                end
                return core.factory.infobox_line{
                    type = 'gem',
                    parts = parts,
                    sep = ', ',
                    fmt = i18n.tooltips.reservation,
                }(tpl_args, frame)
            end,
        },
        {
            show = true, -- TODO: Show only if has mana_multiplier
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'mana_multiplier',
                        hide_default = 100,
                        fmt = '%i',
                        color = false,
                        inline = '%s%%',
                        inline_color = 'value',
                    },
                },
                fmt = i18n.tooltips.mana_multiplier,
            },
        },
        {
            show = true, -- TODO: Show only if has cooldown
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'cooldown', 
                        hide_default = 0,
                        fmt = '%.2f ' .. m_game.units.seconds.short_lower,
                    },
                },
                fmt = i18n.tooltips.cooldown_time,
            },
        },
        {
            -- TODO: Combine with cooldown. Multi-use non-vaal skills display uses together with cooldown time. E.g., Cooldown Time: 8.00 sec (3 uses)
            show = true,
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'stored_uses',
                        hide_default = 0,
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.stored_uses,
            },
        },
        {
            show = true, -- TODO: Show only if has vaal_souls_requirement
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'vaal_souls_requirement',
                        hide_default = 0,
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.vaal_souls_per_use,
            },
        },
        {
            show = true, -- TODO: Show only if has vaal_stored_uses
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'vaal_stored_uses',
                        hide_default = 0,
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.stored_uses, -- TODO: Singular or plural based on number
            },
        },
        {
            show = true, -- TODO: Show only if has vaal_soul_gain_prevention_time
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'vaal_soul_gain_prevention_time',
                        hide_default = 0,
                        -- Technically it rounds to nearest, but it is given in milliseconds in the data, 
                        fmt = '%i ' .. m_game.units.seconds.short_lower,
                    },
                },
                fmt = i18n.tooltips.vaal_soul_gain_prevention_time,
            },
        },
        {
            show = function (tpl_args, frame)
                return tpl_args.cast_time and tpl_args.gem_tags and (m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.spell.tag) or m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.warcry.tag))
            end,
            func = function (tpl_args, frame)
                return core.factory.infobox_line{
                    parts = {
                        {
                            key = 'cast_time',
                            fmt = function (tpl_args, frame, value)
                                if value.min == 0 then
                                    return i18n.tooltips.instant_cast_time
                                end
                                return '%.2f ' .. m_game.units.seconds.short_lower
                            end,
                        },
                    },
                    fmt = m_util.table.contains(tpl_args.gem_tags, m_game.constants.item.gem_tags.spell.tag) and i18n.tooltips.cast_time or i18n.tooltips.use_time,
                }(tpl_args, frame)
            end,
        },
        {
            show = true, -- TODO: Show only if has critical_strike_chance
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'critical_strike_chance',
                        hide_default = 0,
                        fmt = '%.2f%%',
                    },
                },
                fmt = i18n.tooltips.critical_strike_chance,
            },
        },
        {
            show = true, -- TODO: Show only if has attack_speed_multiplier
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'attack_speed_multiplier',
                        hide_default = 100,
                        fmt = '%i',
                        color = false,
                        inline = '%s%% ' .. i18n.tooltips.of_base_stat,
                        inline_color = 'value',
                    },
                },
                fmt = i18n.tooltips.attack_speed_multiplier,
            },
        },
        {
            show = true, -- TODO: Show only if has damage_multiplier
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'damage_multiplier',
                        hide_default = 100,
                        fmt = '%i',
                        color = false,
                        inline = '%s%% ' .. i18n.tooltips.of_base_stat,
                        inline_color = 'value',
                    },
                },
                fmt = i18n.tooltips.damage_multiplier,
            },
        },
        {
            show = true, -- TODO: Show only if has damage_effectiveness
            func = core.factory.infobox_line{
                type = 'gem',
                parts = {
                    {
                        key = 'damage_effectiveness',
                        hide_default = 100,
                        fmt = '%i',
                        color = false,
                        inline = '%s%%',
                        inline_color = 'value',
                    },
                },
                fmt = i18n.tooltips.damage_effectiveness,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'projectile_speed'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'projectile_speed',
                    },
                },
                fmt = i18n.tooltips.projectile_speed,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'radius'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'radius',
                        func = h.factory.descriptor_value{key='radius_description'},
                    },
                    {
                        key = 'radius_secondary',
                        func = h.factory.descriptor_value{key='radius_secondary_description'},
                    },
                    {
                        key = 'radius_tertiary',
                        func = h.factory.descriptor_value{key='radius_tertiary_description'},
                    },
                },
                sep = ' / ',
                fmt = i18n.tooltips.radius,
            },
        },
        -- Quality is before item stats, but after gem stuff and item class
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'quality'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'quality',
                        fmt = '+%i%%',
                        color = 'mod',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.quality,
            },
        },
        -- Weapon only
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'physical_damage_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'physical_damage_html',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.physical_damage,
            },       
        },
        {
            show = true, -- Elemental Damage
            func = function (tpl_args, frame)
                local keys = {'fire_damage_html', 'cold_damage_html', 'lightning_damage_html'}
                local elements = {}
                for _, key in ipairs(keys) do
                    if tpl_args[key] then
                        elements[#elements+1] = tpl_args[key]
                    end
                end
                local text = table.concat(elements, ', ') -- returns empty string if elements is empty
                if text ~= '' then
                    return string.format(i18n.tooltips.elemental_damage, text)
                end
                return
            end,      
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'chaos_damage_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'chaos_damage_html',
                        fmt = '%s',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.chaos_damage,
            },       
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'critical_strike_chance_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'critical_strike_chance_html',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.critical_strike_chance,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'attack_speed_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'attack_speed_html',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.attacks_per_second,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'weapon_range_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'weapon_range_html',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.weapon_range,
            },
        },
        -- Map only
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'map_area_level'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'map_area_level',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.map_level,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'map_tier'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'map_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.map_tier,
            },
        },
        {
            show = function (tpl_args, frame)
                return tpl_args.map_guild_character ~= nil and tpl_args.rarity_id == 'normal'
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'map_guild_character',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.map_guild_character,
            },
        },
        {
            show = function (tpl_args, frame)
                return tpl_args.unique_map_guild_character ~= nil and tpl_args.rarity_id == 'unique'
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'unique_map_guild_character',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.map_guild_character,
            },
        },
        {
            show = true,
            func = core.factory.infobox_line{
                type = 'stat',
                parts = {
                    {
                        key = 'map_item_drop_quantity_+%',
                        fmt = '+%i%%',
                        color = 'mod',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.item_quantity,
            },
        },
        {
            show = true,
            func = core.factory.infobox_line{
                type = 'stat',
                parts = {
                    {
                        key = 'map_item_drop_rarity_+%',
                        fmt = '+%i%%',
                        color = 'mod',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.item_rarity,
            },
        },
        {
            show = true,
            func = core.factory.infobox_line{
                type = 'stat',
                parts = {
                    {
                        key = 'map_pack_size_+%',
                        fmt = '+%i%%',
                        color = 'mod',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.monster_pack_size,
            },
        },
        -- Jewel Only
        {
            show = true,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'item_limit',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.limited_to,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'jewel_radius_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'jewel_radius_html',
                        fmt = '%s',
                        color = false, -- html already has color
                    },
                },
                fmt = i18n.tooltips.radius,
            },
        },
        -- Flask only
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'flask_mana_html', 'flask_duration_html'},
            },
            --func = core.factory.display_flask('flask_mana'),
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'flask_mana_html',
                        fmt = '%s',
                    },
                    {
                        key = 'flask_duration_html',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.flask_mana_recovery,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'flask_life_html', 'flask_duration_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'flask_life_html',
                        fmt = '%s',
                    },
                    {
                        key = 'flask_duration_html',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.flask_life_recovery,
            },
        },
        {
            -- don't display for mana/life flasks
            show = function (tpl_args, frame)
                for _, k in ipairs({'flask_life_html', 'flask_mana_html'}) do
                    if tpl_args[k] ~= nil then
                        return false
                    end
                end
                return tpl_args['flask_duration_html'] ~= nil
            end,
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'flask_duration_html',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.flask_duration,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'charges_per_use_html', 'charges_max_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'charges_per_use_html',
                        fmt = '%s',
                    },
                    {
                        key = 'charges_max_html',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.flask_charges_per_use,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'buff_stat_text'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'buff_stat_text',
                        color = 'mod',
                    },
                },
            },
        },
        -- Armor only
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'block_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'block_html',
                        fmt = '%s',
                        hide_default = 0,
                        hide_default_key = 'block',
                    },
                },
                fmt = i18n.tooltips.chance_to_block,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'armour_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'armour_html',
                        fmt = '%s',
                        hide_default = 0,
                        hide_default_key = 'armour',
                    },
                },
                fmt = i18n.tooltips.armour,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'evasion_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'evasion_html',
                        fmt = '%s',
                        hide_default = 0,
                        hide_default_key = 'evasion',
                    },
                },
                fmt = i18n.tooltips.evasion,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'energy_shield_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'energy_shield_html',
                        fmt = '%s',
                        hide_default = 0,
                        hide_default_key = 'energy_shield',
                    },
                },
                fmt = i18n.tooltips.energy_shield,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'ward_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'ward_html',
                        fmt = '%s',
                        hide_default = 0,
                        hide_default_key = 'ward',
                    },
                },
                fmt = i18n.tooltips.ward,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'movement_speed'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'movement_speed',
                        fmt = '%s%%',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.movement_speed,
            },
        },
        -- Amulet only
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'talisman_tier'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'talisman_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.talisman_tier,
            },
        },
        -- Misc
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'stack_size'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'stack_size',
                        fmt = '%i',
                        hide_default = 1,
                    },
                },
                fmt = i18n.tooltips.stack_size,
            },
        },
        -- Essence stuff
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'essence_level'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'essence_level',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.essence_level,
            },
        },
        -- Blight items
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'blight_item_tier'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'blight_item_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.blight_item_tier,
            },
        },
        -- Harvest seeds (upper section)
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_tier'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_tier',
                        fmt = '%i',
                    },
                },
                fmt = i18n.tooltips.seed_tier,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_tier'},
                conditions = {processed = true},
            },
            func = function (tpl_args, value)
                return i18n.tooltips.seed_monster
            end,
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_type_html'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_type_html',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.seed_lifeforce_gained,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_growth_cycles'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_growth_cycles',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.seed_growth_cycles,
            },
        },
        -- Heist
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'heist_required_npcs'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'heist_required_npcs',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.heist_required_npc,
            },
        },
    },
    -- Requirements
    {
        -- Instead of item level, show drop level if any
        {
            show = true, -- Requires...
            func = function (tpl_args, frame)
                local parts = {
                    {
                        key = 'required_level_final_html',
                        hide_default = 1,
                        hide_default_key = 'required_level_final',
                        inline = i18n.tooltips.level_inline,
                        inline_color = false,
                    },
                }
                for _, attr in ipairs(m_game.constants.attribute_order) do
                    parts[#parts+1] = {
                        key = string.format('required_%s_html', attr),
                        hide = function (tpl_args, frame, value)
                            local min = m_game.constants.characters.minimum_attributes[m_game.constants.attributes[attr].arg]
                            return value.min <= min and value.max <= min
                        end,
                        hide_key = string.format('required_%s', attr),
                        inline = ', %s ' .. m_game.constants.attributes[attr].short_upper,
                        inline_color = false,
                    }
                end
                local requirements = core.factory.infobox_line{parts = parts}(tpl_args, frame)
                if requirements == nil then -- return early
                    return
                end
                requirements = string.gsub(requirements, '^, ', '')
                return string.format(i18n.tooltips.requires, requirements)
            end,
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'heist_required_job', 'heist_required_job_level'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'heist_required_job_level',
                        fmt = '%s',
                    },
                    {
                        key = 'heist_required_job',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.heist_required_job,
            },
        },
    },
    -- Gem description
    {
        class = 'tc -gemdesc',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'gem_description'},
            },
            func = h.factory.display_raw_value('gem_description'),
        },
    },
    -- Gem Quality Stats
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'skill_quality'},
            },
            func = function (tpl_args, frame)
                local span = mw.html.create('span')
                span
                    :addClass('quality')
                    
                local span2 = span:tag('span')
                span2
                    :addClass('quality-header')
                    :tag('span')
                        :wikitext(m_util.html.poe_color('default', i18n.tooltips.gem_quality))
                    
                for i, quality_data in ipairs(tpl_args.skill_quality) do
                    local span_inner = span2:tag('span')
                    span_inner
                        :addClass('quality-section-select')
                        :addClass('quality-' .. i)
                        :wikitext(i)
                        :tag('span')
                            :wikitext(i18n.tooltips['gem_quality_' .. i])
                            
                    if i == 1 then
                        span_inner:addClass('quality-selected')
                    end
                end
                
                for i, quality_data in ipairs(tpl_args.skill_quality) do
                    local span_inner = span:tag('span')
                    span_inner
                        :addClass('quality-box')
                        :addClass('quality-' .. i)
                        :wikitext(quality_data.stat_text)
                     
                     if i == 1 then
                        span_inner:addClass('quality-selected')
                     end
                end
                
                return tostring(span)
            end,
        },
    },
    -- Gem Implicit Stats
    {
        class = 'tc -mod',
        {
            show = function (tpl_args, frame)
                return cfg.class_groups.gems.keys[tpl_args.class_id] and tpl_args.stat_text
            end,
            func = function (tpl_args, frame)
                local lines = {}
                lines[#lines+1] = tpl_args.stat_text
                for _, tag in ipairs(tpl_args.gem_tags) do
                    if tag == m_game.constants.item.gem_tags.vaal.tag then
                        lines[#lines+1] = i18n.tooltips.corrupted
                        break
                    end
                end
                return table.concat(lines, '<br>')
            end,
        },
    },
    -- Implicit Stats
    {
        class = 'tc -mod',
        func = function (tpl_args, frame, container_type)
            if tpl_args.implicit_stat_text then
                return {h.strip_random_stats(tpl_args, frame, tpl_args.implicit_stat_text, container_type)}
            else
                return {}
            end
        end,
    },
    -- Stats
    {
        class = 'tc -mod',
        func = function (tpl_args, frame, container_type)
            if tpl_args.explicit_stat_text then
                return {h.strip_random_stats(tpl_args, frame, tpl_args.explicit_stat_text, container_type)}
            else
                return {}
            end
        end,
    },
    -- Experience
    --[[{
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'experience'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'experience',
                        fmt = '%i',
                    },
                },
            },
        },
    },]]--
    -- Harvest seeds (lower section)
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_consumed_wild_lifeforce_percentage'},
                conditions = {processed = true},
            },
            func = function (tpl_args, frame)
                if tpl_args.seed_consumed_wild_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_wild_lifeforce_percentage, m_util.html.poe_color('wild', m_game.seed_types.wild))
                end
            end
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_consumed_vivid_lifeforce_percentage'},
                conditions = {processed = true},
            },
            func = function (tpl_args, frame)
                if tpl_args.seed_consumed_vivid_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_vivid_lifeforce_percentage, m_util.html.poe_color('vivid', m_game.seed_types.vivid))
                end
            end
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_consumed_primal_lifeforce_percentage'},
                conditions = {processed = true},
            },
            func = function (tpl_args, frame)
                if tpl_args.seed_consumed_primal_lifeforce_percentage > 0 then
                    return string.format(i18n.tooltips.seed_lifeforce_consumed, tpl_args.seed_consumed_primal_lifeforce_percentage, m_util.html.poe_color('primal', m_game.seed_types.primal))
                end
            end
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_required_nearby_seed_tier', 'seed_type_html', 'seed_required_nearby_seed_amount'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seed_required_nearby_seed_amount',
                        fmt = '%s',
                    },
                    {
                        key = 'seed_type_html',
                        fmt = '%s',
                    },
                    {
                        key = 'seed_required_nearby_seed_tier',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.seed_required_seeds,
                color = 'mod',
            },
        },
    },
    {
        class = 'tc -crafted',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seed_effect'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('seed_effect'),
        },
    },
    -- Description (currency, doodads)
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'description'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('description'),
        },
        --[[{
            show = h.factory.maybe_show_infobox_line{
                keys = {'plant_booster_additional_crafting_options'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'plant_booster_additional_crafting_options',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.plant_booster_additional_crafting_options,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'plant_booster_extra_chances'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'plant_booster_extra_chances',
                        fmt = '%s%%',
                    },
                },
                fmt = i18n.tooltips.plant_booster_extra_chances,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'plant_booster_lifeforce'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'plant_booster_lifeforce',
                        fmt = '%s%%',
                    },
                },
                fmt = i18n.tooltips.plant_booster_lifeforce,
            },
        },]]
    },
    {
        class = 'tc -crafted',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'incubator_effect'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('incubator_effect'),
        },
    },
    -- Variations (for doodads)
    {
        class = 'tc -mod',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'variation_count'},
                conditions = {processed = true},
            },
            func = function (tpl_args, frame)
                local txt
                if tpl_args.variation_count == 1 then
                    txt = i18n.tooltips.variation_singular
                else
                    txt = i18n.tooltips.variation_plural
                end
                return string.format('%i %s', tpl_args.variation_count, txt)
            end,
        },
    },
    -- Flavour Text
    {
        class = 'tc -flavour',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'flavour_text'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('flavour_text'),
        },
    },
    -- Prophecy text
    {
        class = 'tc -value',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'prediction_text'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('prediction_text'),
        },
    },
    -- Can not be traded or modified
    {
        class = 'tc -canttradeormodify',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'cannot_be_traded_or_modified'},
                conditions = {processed = true},
            },
            func = function (tpl_args, frame)
                if tpl_args.cannot_be_traded_or_modified == true then
                    return i18n.tooltips.cannot_be_traded_or_modified
                end
            end,
        },
    },
    -- Help text
    {
        class = 'tc -help',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'help_text'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('help_text'),
        },
    },
}

--
-- This is meant to show additional information about the item in a separate infobox
--
c.extra_display_groups = {
    {
        heading = i18n.tooltips.extra_info,
        class = '',
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'atlas_connections'},
                conditions = {processed = true},
            },
            func = function (tpl_args, frame)
                local fields = {
                    [false] = {
                        value = '✗',
                        sort = 0,
                        class = 'table-cell-xmark',
                    },
                    [true] = {
                        value = '✓',
                        sort = 1,
                        class = 'table-cell-checkmark',
                    },
                }
                
                local tbl = mw.html.create('table')
                tbl
                    :attr('class', 'wikitable')
                    :attr('style', 'width:100%;')
                    :tag('tr')
                        :tag('th')
                            :attr('colspan', 6)
                            :attr('style', 'text-decoration: underline;')
                            :wikitext(i18n.tooltips.header_overall)
                            :done()
                        :done()
                    :tag('tr')
                        :tag('th')
                            :wikitext(i18n.tooltips.header_upgrades)
                            :done()
                        :tag('th')
                            :wikitext(0)
                            :done()
                        :tag('th')
                            :wikitext(1)
                            :done()
                        :tag('th')
                            :wikitext(2)
                            :done()
                        :tag('th')
                            :wikitext(3)
                            :done()
                        :tag('th')
                            :wikitext(4)
                            :done()
                        :done()
                    
                for _, vtype in ipairs({'tier', 'level'}) do
                    local tr = tbl:tag('tr')
                    tr
                        :tag('th')
                            :wikitext(i18n.tooltips['header_map_' .. vtype])
                            :done()
                    
                    for i=0,4 do
                        local value = tpl_args['atlas_map_tier' .. i]
                        if value == 0 then
                            value = fields[false].value
                        elseif vtype == 'level' then
                            value = value + 67
                        end
                        tr
                            :tag('td')
                                :wikitext(value)
                                :done()
                    end
                    tr:done()
                end
                
                tbl
                    :tag('tr')
                        :tag('th')
                            :attr('colspan', 6)
                            :attr('style', 'text-decoration: underline;')
                            :wikitext(i18n.tooltips.header_connections)
                            :done()
                        :done()
                
                -- sort alphabetically
                local sorted = {}
                for key, value in pairs(tpl_args.atlas_connections) do
                    sorted[#sorted+1] = key
                end
                table.sort(sorted)
                
                for _, key in ipairs(sorted) do
                    local tr = tbl:tag('tr')
                    tr
                        :tag('th')
                            :wikitext(key)
                            :done()
                    
                    for i=0,4 do
                        local field = fields[tpl_args.atlas_connections[key]['region' .. i]]
                        tr
                            :tag('td')
                                :attr('data-sort-value', field.sort)
                                :attr('class', field.class)
                                :wikitext(field.value)
                                :done()
                    end
                    tr:done()
                end
                
                return tostring(tbl)
            end
        },
    },
    -- Acquisition
    {
        heading = i18n.tooltips.acquisition,
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'drop_level'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'drop_level',
                        fmt = '%i',
                        
                    },
                    {
                        key = 'drop_level_maximum',
                        fmt = '%i',
                        hide_default = 100,
                    },
                },
                sep = ' / ',
                fmt = i18n.tooltips.area_level,
            },
        },
        {
            show = function (tpl_args, frame)
                if tpl_args.drop_enabled == false then
                    return true
                end
                return false
            end,
            func = function (tpl_args, frame)
                local span = mw.html.create('span')
                span
                    :attr('class', 'infobox-disabled-drop')
                    :wikitext(i18n.tooltips.drop_disabled)
                    :done()
                return tostring(span)
            end,
        },
        {
            show = function (tpl_args, frame)
                if tpl_args.is_drop_restricted == true and tpl_args.drop_enabled ~= false then
                    return true
                end
                return false
            end,
            func = function (tpl_args, frame)
                local span = mw.html.create('span')
                span
                    :attr('class', 'infobox-restricted-drop')
                    :wikitext(i18n.tooltips.drop_restricted)
                    :done()
                return tostring(span)
            end,
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'drop_leagues'},
                conditions = {processed = true},
            },
            func = function (tpl_args, frame)
                return string.format(i18n.tooltips.league_restriction, m_util.html.poe_color('value', table.concat(tpl_args.drop_leagues, ', ')))
            end
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'drop_areas_html'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('drop_areas_html'),
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'drop_text'},
                conditions = {processed = true},
            },
            func = h.factory.display_raw_value('drop_text'),
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'master', 'master_level_requirement'},
                conditions = {processed = true},
            },
            func = function (tpl_args, frame)
                local master
                for _, v in ipairs(m_game.constants.masters) do
                    if tpl_args.master == v.full then
                        master = v
                        break
                    end
                end
                local text = string.format('[[%s|%s]] ', master.full, master.short_upper) .. string.format(i18n.tooltips.master_level, tpl_args.master_level_requirement)
                return string.format(i18n.tooltips.master, m_util.html.poe_color('value', text))
            end
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'master', 'master_favour_cost'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'master_favour_cost',
                        color = 'currency',
                        hide_default = 0,
                    },
                },
                fmt = i18n.tooltips.favour_cost,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'seal_cost'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'seal_cost',
                        fmt = function (tpl_args, frame, value)
                            return string.format('%s %s', i18n.fmt.item_count, h.item_link{metadata_id='Metadata/Items/Currency/CurrencySilverCoin', html=''})
                        end,
                        color = 'currency',
                    },
                },
                fmt = i18n.tooltips.seal_cost,
            },
        },
    },
    {
        -- Vendor prices
        heading = i18n.tooltips.purchase_costs,
        {
            show = function (tpl_args, frame)
                for rarity, data in pairs(tpl_args.purchase_costs) do
                    if #data > 0 then
                        return true
                    end
                end
                return false
            end,
            func = function (tpl_args, frame)
                local tbl = mw.html.create('table')
                tbl
                    --:attr('class', 'wikitable')
                    :attr('style', 'width: 100%; margin-top: 0px;')
                    
                for _, rarity_id in ipairs(m_game.constants.rarity_order) do
                    local data = tpl_args.purchase_costs[rarity_id]
                    if #data > 0 then
                        local tr = tbl:tag('tr')
                        tr
                            :tag('td')
                                :wikitext(m_game.constants.rarities[rarity_id].long_upper)
                        local td = tr:tag('td')
                        for _, purchase_data in ipairs(data) do
                            td:wikitext(string.format('%dx [[%s]]<br />', purchase_data.amount, purchase_data.name))
                        end
                    end
                end
                
                return tostring(tbl)
            end,
        },
    },
    {
        -- Vendor offer
        heading = i18n.tooltips.sell_price,
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'sell_price_order'},
            },
            func = function (tpl_args, frame)
                local out = {}
                if #tpl_args.sell_price_order > 0 then
                    for _, item_name in ipairs(tpl_args.sell_price_order) do
                        out[#out+1] = string.format('%dx [[%s]]', tpl_args.sell_prices[item_name], item_name)
                    end
                end
                return table.concat(out, '<br />')
            end,
        },
    },
    -- Damage per second
    {
        heading = i18n.tooltips.damage_per_second,
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'physical_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'physical_dps_html',
                        fmt = '%s',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.physical_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'fire_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'fire_dps_html',
                        fmt = '%s',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.fire_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'cold_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'cold_dps_html',
                        fmt = '%s',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.cold_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'lightning_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'lightning_dps_html',
                        fmt = '%s',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.lightning_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'chaos_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'chaos_dps_html',
                        fmt = '%s',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.chaos_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'elemental_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'elemental_dps_html',
                        fmt = '%s',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.elemental_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'poison_dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'poison_dps_html',
                        fmt = '%s',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.poison_dps,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'dps_html'},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'dps_html',
                        fmt = '%s',
                        color = false, -- the html already contains the colour
                    },
                },
                fmt = i18n.tooltips.dps,
            },
        },
    },
    {
        heading = i18n.tooltips.metadata,
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'class'},
                conditions = {processed = true},
            },
            func = core.factory.infobox_line{
                parts = {
                    {
                        key = 'class',
                        fmt = '%s',
                    },
                },
                fmt = i18n.tooltips.item_class,
            },
        },
        {
            show = h.factory.maybe_show_infobox_line{
                keys = {'metadata_id'},
                conditions = {processed = true},
            },
            func = function (tpl_args, frame)
                return core.factory.infobox_line{
                    parts = {
                        {
                            key = 'metadata_id',
                            fmt = '%s',
                            inline = m_util.html.abbr('%s', tpl_args.metadata_id),
                        },
                    },
                    fmt = tostring(
                        mw.html.create('span')
                            :addClass('u-truncate-line')
                            :wikitext(i18n.tooltips.metadata_id)
                    ),
                }(tpl_args, frame)
            end,
        },
    },
}

-- ----------------------------------------------------------------------------
-- Subroutines
-- ----------------------------------------------------------------------------

local s = {}

-- Subroutines for p.item. These exist to declutter the main function. Each one of these is only called once.

function s.get_item_config(tpl_args, frame)
    -- Returns primary item configuration, based on item class

    local config = {
        tables = {}, -- Table names that data may be stored to
        args = {}, -- Args to process early
        late_args = {}, -- Args to process late
        defaults = {}, -- Defaults based on item class
    }
    for _, v in ipairs(cfg.tables) do
        table.insert(config.tables, v)
    end
    for _, v in ipairs(cfg.default_args) do
        table.insert(config.args, v)
    end
    for _, v in ipairs(cfg.late_args) do
        table.insert(config.late_args, v)
    end

    -- Process class_id
    h.process_arguments(tpl_args, frame, {'class_id'})

    local extend_keys = {'tables', 'args', 'late_args'} -- We will do defaults separately to preserve order of args
    for _, row in pairs(cfg.class_groups) do
        if row.keys[tpl_args.class_id] then
            for _, k in ipairs(extend_keys) do
                if row[k] then
                    for _, v in ipairs(row[k]) do
                        table.insert(config[k], v)
                    end
                end
            end
            if row['defaults'] then
                for k, v in pairs(row['defaults']) do
                    config['defaults'][k] = v
                end
            end
            break
        end
    end
    local class_specifics = cfg.class_specifics[tpl_args.class_id]
    if class_specifics then
        for _, k in ipairs(extend_keys) do
            if class_specifics[k] then
                for _, v in ipairs(class_specifics[k]) do
                    table.insert(config[k], v)
                end
            end
        end
        if class_specifics['defaults'] then
            for k, v in pairs(class_specifics['defaults']) do
                config['defaults'][k] = v
            end
        end
    end
    return config
end

function s.process_quest_rewards(tpl_args, frame)
    local rid = 1
    local continue
    tpl_args.quest_rewards = {}
    tpl_args.vendor_rewards = {}
    repeat 
        continue = true
        local prefix = string.format('quest_reward%s_', rid)
        
        local input_args = {
            shared = {
                ['type'] = true, 
                ['quest'] = false, 
                ['quest_id'] = false, 
                ['act'] = true, 
                ['class_ids'] = false,
                },
            vendor = {
                ['npc'] = true,
            },
            quest = {
                ['sockets'] = false, 
                ['item_level'] = false, 
                ['rarity_id'] = false, 
                ['notes'] = false,
            },
        }
        
        local rdata = {}
        
        for key, is_required in pairs(input_args.shared) do
            rdata[key] = tpl_args[prefix .. key]
            if is_required then
                if rdata[key] == nil then
                    continue = false
                    break
                end
            end
        end
        
        if rdata.quest == nil or rdata.quest_id == nil then
            continue = false
        end
        
        if continue and rdata.type == 'vendor' or rdata.type == 'quest' then
            for key, is_required in pairs(input_args[rdata.type]) do
                rdata[key] = tpl_args[prefix .. key]
                if is_required then
                    if rdata[key] == nil then
                        continue = false
                        break
                    end
                end
            end
        else
            continue = false
        end
        
        if continue then
            rdata.classes = {}
            if rdata.class_ids ~= nil then
                rdata.class_ids = m_util.string.split(rdata.class_ids, ',%s*')
                for index, class_id in ipairs(rdata.class_ids) do
                    local class = m_game.constants.characters[class_id] 
                    if class == nil then
                        error(string.format('Class id %s is invalid', class_id))
                    else
                        rdata.class_ids[index] = class.str_id
                        rdata.classes[index] = class.name
                    end
                end
            end
            
            
            if rdata.item_level then
                rdata.item_level = m_util.cast.number(rdata.item_level)
            end
            
            if rdata.rarity_id then
                if m_game.constants.rarities[rdata.rarity_id] == nil then
                    error(string.format(i18n.errors.invalid_rarity_id, tostring(rdata.rarity_id)))
                end
            end
            
            rdata._table = rdata.type .. '_rewards'
            rdata.type = nil
            
            tpl_args[rdata._table] = rdata
            
            m_cargo.store(frame, rdata)
            
            -- TODO: Verify quests and quest ids?
        end
        
        rid = rid + 1
    until continue == false
end

function s.process_base_item(tpl_args, frame)
    local where
    if tpl_args.base_item_id ~= nil then
        where = string.format('items.metadata_id="%s"', tpl_args.base_item_id)
    elseif tpl_args.base_item_page ~= nil then
        where = string.format('items._pageName="%s"' , tpl_args.base_item_page)
    elseif tpl_args.base_item ~= nil then
        where = string.format('items.name="%s"' , tpl_args.base_item)
    elseif tpl_args.rarity_id ~= 'normal' then
        error(i18n.errors.missing_base_item)
    else
        return
    end
    
    if where ~= nil and tpl_args.rarity_id == 'normal' and not tpl_args._flags.is_prophecy then
        error(i18n.errors.missing_rarity)
    end
    
    where = string.format('%s AND items.class_id="%s" AND items.rarity_id="normal"', where, tpl_args.class_id)
    
    local join = {}
    
    for _, table_name in ipairs(tpl_args._item_config.tables) do
        if table_name ~= 'items' then
            join[#join+1] = string.format('items._pageID=%s._pageID', table_name)
        end
    end
    
    local fields = {
        'items._pageName',
        'items.name',
        'items.metadata_id',
    }
    
    for _, k in ipairs(tpl_args._base_item_args) do
        local data = core.map[k]
        if data.field ~= nil then
            fields[#fields+1] = string.format('%s.%s', data.table, data.field)
        end
    end
    
    local result = m_cargo.query(
        tpl_args._item_config.tables,
        fields,
        {
            where=where,
            join=table.concat(join, ','),
            groupBy='items._pageID',
        }
    )
    
    if #result > 1 then
        error(i18n.errors.duplicate_base_items)
        -- TODO be more explicit in the error?
    elseif #result == 0 then
        error(i18n.errors.base_item_not_found)
    end
    
    result = result[1]
    
    tpl_args.base_item_data = result
    h.process_arguments(tpl_args, frame, {'base_item', 'base_item_page', 'base_item_id'})

    --Copy values..
    for _, k in ipairs(tpl_args._base_item_args) do
        local data = core.map[k]
        if data.field ~= nil and data.func_fetch == nil then
            local value = result[string.format('%s.%s', data.table, data.field)]
            if value ~= nil then
                local default = type(data.default) == 'function' and data.default(tpl_args, frame) or data.default
                -- Inherit value from base item if derived item value is not equal to the default value.
                -- This verbose comparison is needed since two empty tables are not considered equal to one another.
                if tpl_args[k] == data.default or (type(tpl_args[k]) == 'table' and #tpl_args[k] == 0 and type(data.default) == 'table' and #data.default == 0) then
                    tpl_args[k] = value
                    if data.func ~= nil then
                        tpl_args[k] = data.func(tpl_args, frame, tpl_args[k])
                    end
                    if data.func_copy ~= nil then
                        data.func_copy(tpl_args, frame, tpl_args[k])
                    end
                elseif tpl_args.debug then
                    mw.log(string.format(i18n.debug.field_value_mismatch, k, tostring(tpl_args[k])))
                end
            elseif tpl_args.debug then
                mw.log(string.format(i18n.debug.base_item_field_not_found, data.table, data.field))
            end
        elseif data.func_fetch ~= nil then
            data.func_fetch(tpl_args, frame)
        end
    end
end

function s.process_mods(tpl_args, frame)
    for _, k in ipairs({'implicit', 'explicit'}) do
        local success = true
        local i = 1
        while success do
            success = h.validate_mod(tpl_args, frame, {key=k, i=i})
            i = i + 1
        end
    end

    -- If the item does not have its own implicit mods, fall back to the implicit mods on the base item.
    local implicit_mods = tpl_args._defined_implicit_mods
    if #implicit_mods == 0 then
        implicit_mods = tpl_args._base_implicit_mods
    end
    for _, v in ipairs(implicit_mods) do
        table.insert(tpl_args._mods, v)
    end
    if #tpl_args._mods > 0 then
        local mods = {}
        local mod_ids = {}
        local non_random_mod_ids = {}
        for _, mod_data in ipairs(tpl_args._mods) do
            if mod_data.result == nil then
                mods[mod_data.id] = mod_data
                mod_ids[#mod_ids+1] = mod_data.id
                if not mod_data.is_random then
                    table.insert(non_random_mod_ids, mod_data.id)
                end
            end
            tpl_args._subobjects[#tpl_args._subobjects+1] = {
                _table = 'item_mods',
                id = mod_data.id,
                text = mod_data.stat_text,
                is_implicit = mod_data.is_implicit,
                is_random = mod_data.is_random,
            }
        end
        
        local results = m_cargo.array_query{
            tables={'mods'},
            fields={'mods._pageName', 'mods.id', 'mods.required_level', 'mods.stat_text'},
            id_field='mods.id',
            id_array=mod_ids,
        }
        
        for _, data in ipairs(results) do
            local mod_data = mods[data['mods.id']]
            mod_data.result = data
            
            if mod_data.is_random == false then
                 -- update item level requirement
                local keys = {'required_level_final'}
                -- only update base item requirement if this is an implicit
                if mod_data.key == 'implicit' then
                    keys[#keys+1] = 'required_level'
                end
                
                for _, key in ipairs(keys) do
                    local req = math.floor(tonumber(data['mods.required_level']) * cfg.item_required_level_modifier_contribution)
                    if req > tpl_args[key] then
                        tpl_args[key] = req
                    end
                end
            end
        end
        
        -- fetch stats
        results = m_cargo.query(
            {'mods', 'mod_stats'},
            {'mods.id', 'mod_stats.id', 'mod_stats.min', 'mod_stats.max'},
            {
                join='mods._pageID=mod_stats._pageID',
                where=string.format('mod_stats.id IS NOT NULL AND mods.id IN ("%s")', table.concat(mod_ids, '", "')),
            }
        )
        for _, data in ipairs(results) do
            -- Stat subobject
            local mod_data = mods[data['mods.id']]
            if mod_data.result.stats == nil then
                mod_data.result.stats = {data, }
            else
                mod_data.result.stats[#mod_data.result.stats+1] = data
            end
        
            local id = data['mod_stats.id']
            local value = {
                min = tonumber(data['mod_stats.min']),
                max = tonumber(data['mod_stats.max']),
            }
            value.avg = (value.min+value.max)/2
            
            local prefix = ''
            if mod_data.is_random then
                prefix = '_random'
            end
            core.stats_update(tpl_args, id, value, mod_data.result['mods.id'], prefix .. '_stats')
            if mod_data.is_implicit then
                core.stats_update(tpl_args, id, value, mod_data.result['mods.id'], prefix .. '_implicit_stats')
            else
                core.stats_update(tpl_args, id, value, mod_data.result['mods.id'], prefix .. '_explicit_stats')
            end
        end
        
        if tpl_args.is_sellable == true and tpl_args._flags.sell_prices_override ~= true then
            -- fetch sell prices
            results = m_cargo.query(
                {'mods', 'mod_sell_prices'},
                {'mods.id', 'mod_sell_prices.amount', 'mod_sell_prices.name'},
                {
                    join='mods._pageID=mod_sell_prices._pageID',
                    -- must be non random mods to avoid accumulating sell prices of randomized modifiers
                    where=string.format('mod_sell_prices.amount IS NOT NULL AND mods.id IN ("%s")', table.concat(non_random_mod_ids, '", "')),
                }
            )
            
            for _, data in ipairs(results) do
                local mod_data = mods[data['mods.id']]
                if not mod_data.is_implicit then
                    local values = {
                        name = data['mod_sell_prices.name'],
                        amount = tonumber(data['mod_sell_prices.amount']), 
                    }
                    -- sell_prices is defined in core.map.sell_prices_override
                    tpl_args.sell_prices[values.name] = (tpl_args.sell_prices[values.name] or 0) + values.amount
                end
            end
         end
    end
    if tpl_args.is_sellable == true and tpl_args._flags.sell_prices_override ~= true then
        local missing_sell_price = true
        for _, _ in pairs(tpl_args.sell_prices) do
            missing_sell_price = false
            break
        end
        
        if missing_sell_price then
            tpl_args.sell_prices[i18n.tooltips.default_vendor_offer] = 1
        end
        
        -- Set sell price on page
        for name, amount in pairs(tpl_args.sell_prices) do
            -- sell_price_order is defined in core.map.sell_prices_override
            tpl_args.sell_price_order[#tpl_args.sell_price_order+1] = name
            tpl_args._subobjects[#tpl_args._subobjects+1] = {
                _table = 'item_sell_prices',
                amount = amount,
                name = name,
            }
        end
        table.sort(tpl_args.sell_price_order)
    end
end

function s.process_stats(tpl_args, frame)
    -- Add stats - this is for when mods are not set, but we still need stats to calcuate new armour values etc
    m_util.args.stats(tpl_args, {prefix='extra_'})
    for _, stat in ipairs(tpl_args.extra_stats) do
        if stat.value ~= nil then
            stat.min = stat.value
            stat.max = stat.value
            stat.avg = stat.value
        end
        core.stats_update(tpl_args, stat.id, stat, nil, '_stats')
        core.stats_update(tpl_args, stat.id, stat, nil, '_explicit_stats')
    end

    -- Transpose stats into cargo data
    for _, random_prefix in ipairs({'', '_random'}) do
        for _, type_prefix in ipairs({'', '_implicit', '_explicit'}) do
            for id, data in pairs(tpl_args[random_prefix .. type_prefix .. '_stats']) do
                local is_implicit
                if type_prefix == '_implicit' then
                    is_implicit = true
                elseif type_prefix == '_explicit' then
                    is_implicit = false
                end
                tpl_args._subobjects[#tpl_args._subobjects+1] = {
                    _table = 'item_stats',
                    id = id,
                    min = data.min,
                    max = data.max,
                    avg = data.avg,
                    is_implicit = is_implicit,
                    is_random = random_prefix == '_random',
                }
            end
        end
    end
    
    -- Handle extra stats (for gems)
    if cfg.class_groups.gems.keys[tpl_args.class_id] then
        h.skill(tpl_args, frame)
    end
    
    --
    -- Handle local stats increases/reductions/additions
    --
    
    local skip = {}
    
    -- general stats
    for k, data in pairs(core.stat_map) do
        local value = tpl_args[k]
        if value ~= nil and skip[k] == nil then
            value = {min=value, max=value, base=value}
            -- If stats are overriden we scan save some CPU time here
            local overridden = false
            if data.stats_override ~= nil then
                for stat_id, override_value in pairs(data.stats_override) do
                    local stat_value = tpl_args._stats[stat_id]
                    if stat_value ~= nil then
                        -- Use the value of stat
                        if override_value == true then
                            value.min = stat_value.min
                            value.max = stat_value.max
                            overridden = true
                        elseif stat_value ~= 0 then
                            value.min = override_value.min
                            value.max = override_value.max
                            overridden = true
                        end
                    end
                end
           end
                
           if overridden == false then
                -- The simple cases; this must be using ipairs as "add" must apply before
                for _, operator in ipairs({'add', 'more'}) do
                    local st = data['stats_' .. operator]
                    if st ~= nil then
                        for _, statid in ipairs(st) do
                            if tpl_args._stats[statid] ~= nil then
                                h.stat[operator](value, tpl_args._stats[statid])
                            end
                        end
                    end
                end
                
                -- For increased stats we need to add them up first
                for stat_key, stat_func in pairs({increased=h.stat.more, increased_inverse=h.stat.more_inverse}) do
                    local st = data['stats_' .. stat_key]
                    if st ~= nil then
                        local total_increase = {min=0, max=0}
                        for _, statid in ipairs(st) do
                            if tpl_args._stats[statid] ~= nil then
                                for var, current_value in pairs(total_increase) do
                                    total_increase[var] = current_value + tpl_args._stats[statid][var]
                                end
                            end
                        end
                        stat_func(value, total_increase)
                    end
                end
                
                if data.minimum ~= nil then
                    for _, key in ipairs({'min', 'max'}) do
                        if value[key] < data.minimum then
                            value[key] = data.minimum 
                        end
                    end
                end
            else

            end
            
            value.avg = (value.min + value.max) / 2
            
            -- don't add the properties unless we need to
            if (data.default ~= nil and (value.min ~= data.default or value.max ~= data.default)) or data.default == nil then
                for short_key, range_data in pairs(c.range_map) do
                    tpl_args[data.field .. range_data.var] = value[short_key]
                end
                
                -- process to HTML to use on list pages or other purposes
                h.handle_range_args(tpl_args, frame, k, data.field, value, data.html_fmt_options or {})
            end
            
            for short_key, range_data in pairs(c.range_map) do
                tpl_args[k .. range_data.var] = value[short_key]
            end
        end
    end
end

function s.process_weapon_dps(tpl_args, frame)
    for key, data in pairs(core.dps_map) do
        local damage = {
            min = {},
            max = {},
        }
        for var_type, value in pairs(damage) do
            -- covers the min/max/avg range
            for short_key, range_data in pairs(c.range_map) do
                value[short_key] = 0
                for _, damage_key in ipairs(data.damage_args) do
                    value[short_key] = value[short_key] + (tpl_args[string.format('%s_%s%s', damage_key, var_type, range_data.var)] or 0)
                end
            end
        end
        local value = {}
        for short_key, range_data in pairs(c.range_map) do
            local result = (damage.min[short_key] + damage.max[short_key]) / 2 * tpl_args[string.format('attack_speed%s', range_data.var)]
            value[short_key] = result
            tpl_args[string.format('%s%s', data.field, range_data.var)] = result
        end
        if value.avg > 0 then
            h.handle_range_args(tpl_args, frame, key, data.field, value, data.html_fmt_options or {})
        end
    end
end

function s.get_categories(tpl_args, frame)
    local cats = {}
    if tpl_args.rarity_id == 'unique' then
        cats[#cats+1] = string.format(i18n.categories.unique_affix, tpl_args.class)
    elseif tpl_args._flags.is_prophecy then
        cats[#cats+1] = i18n.categories.prophecies
    elseif tpl_args._flags.is_blight_item then
        cats[#cats+1] = i18n.categories.blight_item
    elseif tpl_args.is_talisman then
        cats[#cats+1] = i18n.categories.talismans
    elseif tpl_args.is_essence then
        cats[#cats+1] = i18n.categories.essences
    elseif tpl_args.class_id == 'Map' then
        cats[#cats+1] = string.format('%s %s', tpl_args.map_series, tpl_args.class)
    else
        cats[#cats+1] = tpl_args.class
    end
    
    if tpl_args.rarity_id ~= 'normal' or tpl_args.base_item_id == 'Metadata/Items/Currency/CurrencyItemisedProphecy' then
        cats[#cats+1] = i18n.categories.derived_items
    else
        cats[#cats+1] = i18n.categories.base_items
    end
    
    for _, attr in ipairs(m_game.constants.attribute_order) do
        if tpl_args[attr .. '_percent'] then
            cats[#cats+1] = string.format('%s %s', m_game.constants.attributes[attr].long_upper, tpl_args.class)
        end
    end
    
    local affix
    if tpl_args.class_id == 'Active Skill Gem' or tpl_args.class_id == 'Support Skill Gem' then
        affix = i18n.categories.gem_tag_affix
    end
    if affix ~= nil then
        for _, tag in ipairs(tpl_args.gem_tags) do
            cats[#cats+1] = string.format(affix, tag)
        end
    end

    if #tpl_args._defined_implicit_mods > 0 and tpl_args.rarity_id ~= 'normal' then
        cats[#cats+1] = i18n.categories.implicit_modifier_override
    end
    
    if #tpl_args.alternate_art_inventory_icons > 0 then
        cats[#cats+1] = i18n.categories.alternate_artwork
    end
    
    if tpl_args.release_version == nil then
        cats[#cats+1] = i18n.categories.missing_release_version
    end
    
    if tpl_args._flags.text_modifier and not tpl_args.suppress_improper_modifiers_category then
        cats[#cats+1] = i18n.categories.improper_modifiers
    end
    
    -- 
    for _, k in ipairs({'broken_upgraded_from_reference', 'duplicate_upgraded_from_reference', 'duplicate_query_area_ids', 'sell_prices_override'}) do
        if tpl_args._flags[k] then
            cats[#cats+1] = i18n.categories[k]
        end
    end

    if tpl_args._flags.has_deprecated_skill_parameters then
        cats[#cats+1] = i18n.categories.deprecated_skill_parameters
    end
    return cats
end

-- ----------------------------------------------------------------------------
-- Exported functions
-- ----------------------------------------------------------------------------

local p = {}

--
-- Template:Item
--
function p.item(frame)
    local t = os.clock() -- Start time (for logging)
    
    local tpl_args = getArgs(frame, {
        parentFirst = true
    })
    frame = m_util.misc.get_frame(frame)
    
    tpl_args._flags = {}
    tpl_args._base_item_args = {}
    tpl_args._base_implicit_mods = {}
    tpl_args._defined_implicit_mods = {}
    tpl_args._mods = {}
    for _, k in ipairs({'', '_random'}) do
        for _, prefix in ipairs({'', '_implicit', '_explicit'}) do
            tpl_args[k .. prefix .. '_stats'] = {}
        end
    end
    tpl_args._subobjects = {}
    tpl_args._properties = {}
    tpl_args._errors = {}
    
    -- Item configuration
    tpl_args._item_config = s.get_item_config(tpl_args, frame)

    -- Add table names to core.map and append range fields.
    h.append_schema(tpl_args, frame, tpl_args._item_config.tables)
    
    -- Using general purpose function to handle release and removal versions
    m_util.args.version(tpl_args, {frame=frame, set_properties=true})
    
    -- Must validate some argument early. It is required for future things
    h.process_arguments(tpl_args, frame, tpl_args._item_config.args)
    
    -- Base item
    s.process_base_item(tpl_args, frame)
    
    -- Prophecies are considered currency items, but they have their own schema
    if tpl_args._flags.is_prophecy then
        h.process_arguments(tpl_args, frame, cfg.prophecy_args)
    end
    
    -- Mods
    s.process_mods(tpl_args, frame)

    -- Stats
    s.process_stats(tpl_args, frame)

    -- Calculate and handle weapon dps
    if cfg.class_groups.weapons.keys[tpl_args.class_id] then
        s.process_weapon_dps(tpl_args, frame)
    end
    
    -- Late argument processing
    h.process_arguments(tpl_args, frame, tpl_args._item_config.late_args)
    
    -- Handle upgrade from restrictions/info
    h.process_upgraded_from(tpl_args, frame)
    
    -- Quest reward info
    s.process_quest_rewards(tpl_args, frame)
    
    -- ------------------------------------------------------------------------
    -- Infobox handling 
    -- ------------------------------------------------------------------------
    -- Store the infobox so it can be accessed with ease on other pages
    tpl_args.html = tostring(h.make_main_container(tpl_args, frame, 'inline'))
    local container = h.make_main_container(tpl_args, frame, 'infobox')
    
    if tpl_args.inventory_icon ~= nil and tpl_args.class_id ~= 'DivinationCard' then
        container:tag('span')
            :addClass('images')
            :wikitext(string.format(
                '[[%s|%sx%spx]]',
                tpl_args.inventory_icon,
                cfg.image_size_full * tpl_args.size_x,
                cfg.image_size_full * tpl_args.size_y
            ))
    end
    
    --
    -- Secondary infobox
    --
    
    tpl_args.extra_infobox = mw.html.create('span')
        :attr( 'class', 'item-box -' .. tpl_args.frame_type)
        
    h.add_to_container_from_map(tpl_args, frame, tpl_args.extra_infobox, c.extra_display_groups)
    
    -- 
    -- Output 
    --
    
    local infobox = mw.html.create('span')
    infobox
        :attr('class', 'infobox-page-container')
        :node(container)
        :node(tpl_args.extra_infobox)
        
    -- skill_screenshot is set in skill module
    if tpl_args.skill_screenshot then
        infobox:wikitext(string.format('<br>[[%s|300px]]', tpl_args.skill_screenshot))
    end
    
    local out = tostring(infobox)
    tpl_args.html_extra = out
    
    local cats = s.get_categories(tpl_args, frame)
    
    out = out .. m_util.misc.add_category(cats, {ignore_blacklist=tpl_args.debug})
    
    --
    --  Misc
    --
     
    -- Also show the infobox for areas right away for maps, since they're both on the same page
    -- if tpl_args.map_series ~= i18n.misc.betrayal then
    local query_id
    if tpl_args.rarity_id == 'normal' and tpl_args.map_area_id ~= nil then
        query_id = tpl_args.map_area_id
    elseif tpl_args.rarity_id == 'unique' and tpl_args.unique_map_area_id ~= nil then
        query_id = tpl_args.unique_map_area_id
    end

    if query_id then
        out = out .. h.query_area_info{cats=true, where=string.format('areas.id="%s"', query_id)}
    end
    
    -- ------------------------------------------------------------------------
    -- Store cargo data
    -- ------------------------------------------------------------------------
    -- Map argument values for cargo storage
    for _, table_name in ipairs(tpl_args._item_config.tables) do
        tpl_args._subobjects[table_name] = {
            _table = table_name,
        }
    end
    for k, v in pairs(tpl_args) do
        local data = core.map[k]
        if data ~= nil then
            if data.table ~= nil and data.field ~= nil then
                if data.type == 'Integer' then
                    v = tonumber(string.format("%.0f", v))
                    if v ~= tpl_args[k] then
                        mw.log(string.format('Float value "%s" for integer field "%s.%s"', tpl_args[k], data.table, data.field))
                    end
                end
                tpl_args._subobjects[data.table][data.field] = v
            elseif data.table ~= nil and data.field == nil then
                error(string.format('Missing field for table "%s", key "%s", \nvalue:\n "%s" \ndata:\n%s', data.table, k, mw.dumpObject(v), mw.dumpObject(data)))
            elseif data.table == nil and data.field ~= nil then
                mw.log(string.format('Possibly redundant argument "%s", value:\n "%s"', k, mw.dumpObject(v)))
            end
        end
    end
    
    -- Don't store cargo data in testing mode
    if not tpl_args.test then
        local attach = {}
        for _, data in pairs(tpl_args._subobjects) do
            if attach[data._table] == nil then
                local i = 0 
                for _, _ in pairs(data) do
                    i = i + 1
                    -- Don't attach to tables we don't store data to. _table is always present so we need to check for 2 or more entries.
                    if i > 1 then
                        attach[data._table] = true
                        -- Keeping this here in case it might be useful in the future.
                        -- Recreating table is very slow and doing anything while the queue is running just creates a big mess.
                        frame:expandTemplate{title=string.format('Template:Item/cargo/attach/%s', data._table), args={}}
                        break
                    end
                end
            end
            m_cargo.store(frame, data, {
                debug=tpl_args.debug,
                sep={
                    name_list='�',
                },
            })
        end
    end
    
    -- Show additional error messages in console to help fixing them
    if #tpl_args._errors > 0 then
        mw.log(table.concat(tpl_args._errors, '\n'))
    end
    
    if tpl_args.debug then
        mw.log(os.clock() - t)
        mw.log('Start logging tpl_args.')
        mw.logObject(tpl_args)
        mw.log('Stop logging tpl_args.')
        mw.log('Start logging core.map.')
        mw.logObject(core.map)
        mw.log('Stop logging core.map.')
    end
    if tpl_args.test then
        tpl_args.out = out
        return tpl_args
    end
    return out
end

p.itembox = p.item -- Apparently this is still used somewhere???

-- 
-- Template:Itembox
-- 
function p.query_itembox(frame)
    --[[
    Queries for an item box.
    
    Examples
    --------
    =p.query_itembox{page='Beach Map (Betrayal)'}
    ]]
    
    local tpl_args = getArgs(frame, {
        parentFirst = true
    })
    frame = m_util.misc.get_frame(frame)
    
    local results = m_cargo.query(
        {'items', 'maps', 'areas'}, 
        {'items.html_extra', 'maps.area_id', 'areas.id', 'areas.infobox_html'},
        {
            join='items._pageID=maps._pageID, maps.area_id=areas.id',
            where=string.format('items._pageName="%s"', tpl_args.page),
        }
    )
    
    if #results == 0 then
        error(i18n.errors.no_results_found)
    end
    
    local out = {
        results[1]['items.html_extra'], 
        results[1]['areas.infobox_html'],
    }
    
    return table.concat(out, '')
end

return p