No edit summary |
No edit summary |
||
(30 intermediate revisions by the same user not shown) | |||
Line 1: | Line 1: | ||
+ | ------------------------------------------------------------------------------- |
||
− | -- Cargo reworked item module |
||
+ | -- |
||
+ | -- Module:Item2 |
||
+ | -- |
||
+ | -- This module implements Template:Item and Template:Itembox |
||
+ | ------------------------------------------------------------------------------- |
||
-- ---------------------------------------------------------------------------- |
-- ---------------------------------------------------------------------------- |
||
Line 32: | Line 37: | ||
-- maybe smw |
-- maybe smw |
||
+ | |||
− | -- ---------------------------------------------------------------------------- |
||
− | -- Imports |
||
− | -- ---------------------------------------------------------------------------- |
||
− | local m_util = require('Module:Util/sandbox') |
||
local getArgs = require('Module:Arguments').getArgs |
local getArgs = require('Module:Arguments').getArgs |
||
− | local |
+ | local m_util = require('Module:Util') |
− | local |
+ | local m_cargo = require('Module:Cargo') |
+ | local m_skill = require('Module:Skill') |
||
local m_area = require('Module:Area') |
local m_area = require('Module:Area') |
||
− | local m_cargo = require('Module:Cargo') |
||
− | local f_item_link = require('Module:Item link').item_link |
||
− | local |
+ | 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() |
||
+ | -- Lazy loading |
||
− | -- ---------------------------------------------------------------------------- |
||
+ | local f_item_link -- require('Module:Item link').item_link |
||
− | -- Strings |
||
+ | local f_process_upgraded_from -- require('Module:Item2/upgrade').process_upgraded_from |
||
− | -- ---------------------------------------------------------------------------- |
||
+ | local f_build_cargo_data -- require('Module:Item2/cargo').build_cargo_data |
||
− | -- This section contains strings used by this module. |
||
− | -- Add new strings here instead of in-code directly, this will help other |
||
− | -- 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 = '[[:Category:%s (gem tag)|%s]]', |
||
− | |||
− | misc = { |
||
− | -- used to identify betrayal map series to avoid showing area infobox. |
||
− | betrayal = 'Betrayal', |
||
− | upgraded_from_map = 'Lower tier map upgrades randomly into a directly connected higher tier 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 = 'Items with improper modifiers', |
||
− | missing_release_version = 'Items without a release version', |
||
− | broken_upgraded_from_reference = 'Items with broken item references in upgraded from parameters', |
||
− | duplicate_upgraded_from_reference = 'Items with duplicate sets in upgraded from parameters', |
||
− | duplicate_query_area_ids = 'Items with duplicate area ids from queries', |
||
− | base_items = 'Base items', |
||
− | derived_items = 'Derived items', |
||
− | sell_prices_override = 'Items with sell prices overrides', |
||
+ | local i18n = cfg.i18n |
||
− | -- regular cats |
||
− | alternate_artwork = 'Items with alternate artwork', |
||
+ | local core = use_sandbox and require('Module:Item2/core/sandbox') or require('Module:Item2/core') |
||
− | -- misc |
||
− | gem_tag_affix = '%s (gem tag)', |
||
− | unique_affix = 'Unique %s', |
||
− | |||
− | prophecies = 'Prophecies', |
||
− | blight_item = 'Oils', |
||
− | talismans = 'Talismans', |
||
− | essences = 'Essences', |
||
− | }, |
||
+ | local c = {} |
||
− | stat_skip_patterns = { |
||
− | + | c.item_classes = {} |
|
− | '%d+%% increased Quantity of Items found in this Area', |
||
− | '%d+%% increased Rarity of Items found in this Area', |
||
− | '%+%d+%% Monster pack size', |
||
− | -- ranges |
||
− | '%(%d+%-%d+%)%% increased Quantity of Items found in this Area', |
||
− | '%(%d+%-%d+%)%% increased Rarity of Items found in this Area', |
||
− | '%+%(%d+%-%d+%)%% Monster pack size', |
||
− | }, |
||
− | jewels = { |
||
− | 'Limited to %d+ %(Hidden%)', |
||
− | 'Jewel has a radius of %d+ %(Hidden%)', |
||
− | }, |
||
− | }, |
||
− | |||
− | help_text_defaults = { |
||
− | active_gem = 'Place into an item socket of the right colour to gain this skill. Right click to remove from a socket.', |
||
− | support_gem = 'This is a Support Gem. It does not grant a bonus to your character, but skills in sockets connected to it. Place into an item socket connected to a socket containing the Active Skill Gem you wish to augment. Right click to remove from a socket.', |
||
− | jewel = 'Place into an allocated Jewel Socket on the Passive Skill Tree. Right click to remove from the Socket.', |
||
− | }, |
||
− | |||
− | -- texts specific to upgraded from |
||
− | upgraded_from_tooltips = { |
||
− | -- formatters |
||
− | f = { |
||
− | random = 'random %s', |
||
− | random_corrupted = string.format('random %s %%s', m_util.html.poe_color('corrupted', 'corrupted')), |
||
− | random_unidentified_corrupted = string.format('random %s %%s', m_util.html.poe_color('corrupted', 'unidentified corrupted')), |
||
− | random_two_implicit_corrupted = string.format('random %s %%s', m_util.html.poe_color('corrupted', 'two-implicit corrupted')), |
||
− | random_item_level_x = 'random item level %s %s', |
||
− | random_x_link = 'random %s-link %s', |
||
− | random_x_link_item_level_y = 'random %s-link item level %s %s', |
||
− | random_x_amount = 'random %s (%sx)', |
||
− | random_shaper = 'random shaper %s', |
||
− | random_shaper_item_level_x = 'random shaper item level %s %s', |
||
− | random_elder_item_level_x = 'random elder item level %s %s', |
||
− | |||
− | tier_x_map = 'tier %s map', |
||
− | level_x_gem = 'level %s gem', |
||
− | level_x_y_gem = 'level %s %s gem', |
||
− | superior_gem_q_x = 'superior gem (Q%s)', |
||
− | superior_x_gem_q_y = 'superior %s gem (Q%s)', |
||
− | |||
− | x_item = '%s item', |
||
− | }, |
||
− | |||
− | -- items / rewards not covered by module game |
||
− | agate_amulet = 'Agate Amulet', |
||
− | unset_ring = 'Unset Ring', |
||
− | gold_ring = 'Gold Ring', |
||
− | prismatic_ring = 'Prismatic Ring', |
||
− | two_stone_ring = 'Two-Stone Ring', |
||
− | talisman = 'Talisman', |
||
− | tier_1_talisman = 'tier 1 talisman', |
||
− | breachstone = 'Breachstone', |
||
− | scarab = 'Scarab', |
||
− | gilded_scarab = 'Gilded Scarab', |
||
− | divination_card = 'divination card', |
||
− | deafening_essence = 'Deafening Essence', |
||
− | shrieking_essence = 'Shrieking Essence', |
||
− | essence = 'Essence', |
||
− | harbinger_fragment = 'Harbinger Fragment', |
||
− | body_armour = 'body armour', |
||
− | shield = 'Shield', |
||
− | map = 'Map', |
||
− | belt = 'Belt', |
||
− | armour = 'Armour', |
||
− | weapon = 'Weapon', |
||
− | jewellery = 'Jewellery', |
||
− | one_hand_weapon = 'one-handed weapon', |
||
− | two_hand_weapon = 'two-handed weapon', |
||
− | sword = 'Sword', |
||
− | axe = 'Axe', |
||
− | flask = 'Flask', |
||
− | amulet = 'Amulet', |
||
− | ring = 'Ring', |
||
− | league_specific_item = 'league-specific item', |
||
− | item = 'item', |
||
− | fated_item = 'fated unique item', |
||
− | |||
− | -- prefix |
||
− | life = 'Life', |
||
− | |||
− | -- |
||
− | -- used within essences |
||
− | -- |
||
− | essence_plus_one_level = string.format('+1 level %s outcome', m_util.html.poe_color('corrupted', 'corruption')), |
||
− | essence_type_change = string.format('type change %s outcome', m_util.html.poe_color('corrupted', 'corruption')), |
||
− | }, |
||
− | |||
− | -- Used by the item info box |
||
− | tooltips = { |
||
− | corrupted = m_util.html.poe_color('corrupted', 'Corrupted'), |
||
− | support_icon = 'Icon: %s', |
||
− | radius = 'Radius: %s', |
||
− | mana_cost = 'Mana Cost: %s', |
||
− | mana_reserved = 'Mana Reserved: %s', |
||
− | cost = 'Cost: %s', |
||
− | reservation = 'Reservation: %s', |
||
− | mana = 'Mana', |
||
− | life = 'Life', |
||
− | energy_shield = 'Energy Shield', |
||
− | rage = 'Rage', |
||
− | mana_multiplier = 'Cost and Reservation Multiplier: %s', |
||
− | vaal_souls_per_use = 'Souls Per Use: %s', |
||
− | stored_uses = 'Can Store %s Use(s)', |
||
− | vaal_soul_gain_prevention_time = 'Soul Gain Prevention: %s', |
||
− | cooldown_time = 'Cooldown Time: %s', |
||
− | cast_time = 'Cast Time: %s', |
||
− | critical_strike_chance = 'Critical Strike Chance: %s', |
||
− | attack_speed_multiplier = 'Attack Speed: %s', |
||
− | attack_speed_multiplier_fmt = '%i%% of Base', |
||
− | damage_effectiveness = 'Effectiveness of Added Damage: %s', |
||
− | projectile_speed = 'Projectile Speed: %s', |
||
− | quality = 'Quality: %s', |
||
− | physical_damage = 'Physical Damage: %s', |
||
− | elemental_damage = 'Elemental Damage: %s', |
||
− | chaos_damage = 'Chaos Damage: %s', |
||
− | attacks_per_second = 'Attacks per Second: %s', |
||
− | weapon_range = 'Weapon Range: %s', |
||
− | map_level = 'Map Level: %s', |
||
− | map_tier = 'Map Tier: %s', |
||
− | map_guild_character = m_util.html.abbr('Guild Character', 'When used in guild creation, this map can be used for the listed character') .. ': %s', |
||
− | item_quantity = 'Item Quantity: %s', |
||
− | item_rarity = 'Item Rarity: %s', |
||
− | monster_pack_size = 'Monster Pack Size: %s', |
||
− | limited_to = 'Limited to: %s', |
||
− | flask_mana_recovery = 'Recovers %s Mana over %s seconds', |
||
− | flask_life_recovery = 'Recovers %s Life over %s seconds', |
||
− | flask_duration = 'Lasts %s Seconds', |
||
− | flask_charges_per_use = 'Consumes %s of %s Charges on use', |
||
− | chance_to_block = 'Chance to Block: %s', |
||
− | armour = 'Armour: %s', |
||
− | evasion = 'Evasion: %s', |
||
− | energy_shield = 'Energy Shield: %s', |
||
− | movement_speed = 'Movement Speed: %s', |
||
− | talisman_tier = 'Talisman Tier: %s', |
||
− | stack_size = 'Stack Size: %s', |
||
− | essence_level = 'Essence Level: %s', |
||
− | blight_item_tier = 'Oil Tier: %s', |
||
− | requires = 'Requires %s', |
||
− | level_inline = 'Level %s', |
||
− | level = 'Level: %s', |
||
− | gem_quality = 'Per 1% Quality:', |
||
− | gem_quality_1 = 'Superior', |
||
− | gem_quality_2 = 'Anomalous', |
||
− | gem_quality_3 = 'Divergent', |
||
− | gem_quality_4 = 'Phantasmal', |
||
− | variation_singular = 'Variation', |
||
− | variation_plural = 'Variations', |
||
− | favour_cost = 'Favour cost: %s', |
||
− | seal_cost = 'Seal Cost: <br>%s', |
||
− | cannot_be_traded_or_modified = 'Cannot be traded or modified', |
||
− | |||
− | -- harvest seeds |
||
− | |||
− | seed_tier = 'Seed Tier: %s', |
||
− | seed_monster = 'Spawns a level ? Monster when Harvested', |
||
− | seed_lifeforce_gained = 'Provides ? Units of Raw %s Lifeforce when Harvested', |
||
− | seed_growth_cycles = 'Can be Harvested after %s Growth Cycles', |
||
− | |||
− | seed_lifeforce_consumed = 'Consumes (%s%%) %s Units of Condensed Lifeforce per Growth Cycle', |
||
− | seed_required_seeds = 'Requires %s Adjacent %s Seeds of at least Tier %s to Grow', |
||
− | |||
− | -- 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 = 'This item can be equipped by: %s', |
||
− | heist_required_job = 'Requires %s in %s', |
||
− | heist_any_job = 'Any job', |
||
− | |||
− | -- ClientStrings.dat -> WeaponClassDisplayName.* |
||
− | item_class_map = { |
||
− | ['Staff'] = 'Staff', |
||
− | ['Bow'] = 'Bow', |
||
− | ['Wand'] = 'Wand', |
||
− | ['Two Hand Axe'] = 'Two Handed Axe', |
||
− | ['Two Hand Sword'] = 'Two Hand Sword', |
||
− | ['Two Hand Mace'] = 'Two Hand Mace', |
||
− | ['Warstaff'] = 'Warstaff', |
||
− | ['Sceptre'] = 'Sceptre', |
||
− | ['One Hand Mace'] = 'One Handed Mace', |
||
− | ['One Hand Axe'] = 'One Handed Axe', |
||
− | ['One Hand Sword'] = 'One Handed Sword', |
||
− | ['Thrusting One Hand Sword'] = 'One Handed Sword', |
||
− | ['Claw'] = 'Claw', |
||
− | ['Dagger'] = 'Dagger', |
||
− | ['Rune Dagger'] = 'Rune Dagger', |
||
− | ['FishingRod'] = 'Fishing Rod', |
||
− | ['HideoutDoodad'] = 'Hideout Item', |
||
− | }, |
||
− | |||
− | random_mod = '<<random modifier %s>>', |
||
− | |||
− | -- |
||
− | -- secondary infobox |
||
− | -- |
||
− | extra_info = 'Additional Information', |
||
− | header_overall = 'Region Upgrades Chart', |
||
− | header_upgrades = 'Upgrade Level', |
||
− | header_map_tier = 'Tier', |
||
− | header_map_level = 'Map Level', |
||
− | header_connections = 'Connections', |
||
− | |||
− | drop_restrictions = 'Acquisition', |
||
− | league_restriction = m_util.html.abbr('League(s):', 'Item can be obtained in relation to these league(s)') .. ' %s', |
||
− | drop_disabled = 'DROP DISABLED', |
||
− | |||
− | purchase_costs = m_util.html.abbr('Purchase Costs', 'Cost of purchasing an item of this type at NPC vendors. This does not indicate whether NPCs actually sell the item.'), |
||
− | sell_price = m_util.html.abbr('Sell Price', 'Items or currency received when selling this item at NPC vendors. Certain vendor recipes may override this value.'), |
||
− | |||
− | damage_per_second = 'Weapon DPS', |
||
− | 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 = 'Elemental', |
||
− | poison_dps = 'Phys+Chaos', |
||
− | dps = 'Total', |
||
− | |||
− | misc = 'Miscellaneous', |
||
− | item_class = 'Item class: %s', |
||
− | metadata_id = 'Metadata ID: %s', |
||
− | }, |
||
− | |||
− | damage = { |
||
− | standard_range = '%s-%s', |
||
− | variable_range = '%s to %s', |
||
− | }, |
||
− | |||
− | item_class_infobox = { |
||
− | page = '[[Item class]]', |
||
− | info = m_util.html.abbr('(?)', 'Item classes categorize items. Classes are often used to restrict items or skill gems to a specific class or by item filters'), |
||
− | also_referred_to_as = '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 = 'Base item could not be found in the database. Check for spelling mistakes or whether the base item page exists on the wiki. If the base item page exists on the wiki, but it can not be found please null-edit the page.', |
||
− | invalid_league = '%s is not a recognized league', |
||
− | invalid_tag = '%s is not a valid tag', |
||
− | 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 = 'Duplicate metadata id "%s" on page "%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 = 'The item class id "%s" is invalid. Using the correct item class id is required for the template to work correctly.', |
||
− | invalid_rarity_id = 'The rarity id "%s" is invalid. Acceptable values are "normal", "magic", "rare" and "unique".', |
||
− | invalid_region_upgrade_count = 'atlas_connection%s_tier: Invalid amount (%s) of connections, only 5 are allowed', |
||
− | }, |
||
− | } |
||
-- ---------------------------------------------------------------------------- |
-- ---------------------------------------------------------------------------- |
||
− | -- |
+ | -- Helper functions |
-- ---------------------------------------------------------------------------- |
-- ---------------------------------------------------------------------------- |
||
Line 379: | Line 78: | ||
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 |
||
− | |||
− | -- helper to loop over the range variables easier |
||
− | h.range_map = { |
||
− | min = { |
||
− | var = '_range_minimum', |
||
− | }, |
||
− | 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 |
||
− | |||
− | function h.stats_update(tpl_args, id, value, modid, key) |
||
− | if tpl_args[key][id] == nil then |
||
− | tpl_args[key][id] = { |
||
− | 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 |
||
− | |||
− | 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 |
||
− | |||
− | -- ---------------------------------------------------------------------------- |
||
− | -- 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_item_link(args) |
||
end |
end |
||
− | function |
+ | function h.validate_mod(tpl_args, frame, args) |
-- args: |
-- args: |
||
-- key - implict or explicit |
-- key - implict or explicit |
||
Line 545: | Line 93: | ||
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, |
||
Line 550: | Line 99: | ||
id=nil, |
id=nil, |
||
stat_text=nil, |
stat_text=nil, |
||
− | is_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( |
+ | table.insert(mods_table, out) |
return true |
return true |
||
Line 565: | Line 115: | ||
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( |
+ | 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 = |
+ | is_implicit = is_implicit, |
is_random = true, |
is_random = true, |
||
}) |
}) |
||
Line 581: | Line 131: | ||
out.stat_text = value |
out.stat_text = value |
||
out.is_random = false |
out.is_random = false |
||
− | table.insert( |
+ | table.insert(mods_table, out) |
return true |
return true |
||
Line 589: | Line 139: | ||
end |
end |
||
− | function |
+ | 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 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) |
||
+ | for _, k in ipairs(params) do |
||
+ | 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 c.item_classes[tpl_args.class_id].defaults ~= nil and c.item_classes[tpl_args.class_id].defaults[k] ~= nil then |
||
+ | tpl_args[k] = c.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 |
||
+ | |||
+ | -- add defaults from class specifics and class groups |
||
+ | function h.build_item_classes(tpl_args, frame) |
||
+ | core.map.class.func(tpl_args, frame) |
||
+ | |||
+ | c.item_classes[tpl_args.class_id] = { |
||
+ | tables = {}, |
||
+ | args = {}, |
||
+ | late_args = {}, |
||
+ | defaults = {}, |
||
+ | } |
||
+ | |||
+ | for _, table_name in ipairs(cfg.tables) do |
||
+ | table.insert(c.item_classes[tpl_args.class_id].tables, table_name) |
||
+ | end |
||
+ | |||
+ | local item_classes_extend = {'tables', 'args', 'late_args'} |
||
+ | |||
+ | for _, row in pairs(cfg.class_groups) do |
||
+ | for class, _ in pairs(row.keys) do |
||
+ | if class == tpl_args.class_id then |
||
+ | for _, k in ipairs(item_classes_extend) do |
||
+ | if row[k] ~= nil then |
||
+ | for _, value in ipairs(row[k]) do |
||
+ | table.insert(c.item_classes[tpl_args.class_id][k], value) |
||
+ | end |
||
+ | end |
||
+ | end |
||
+ | break |
||
+ | end |
||
+ | end |
||
+ | end |
||
+ | |||
+ | local class_specifics = cfg.class_specifics[tpl_args.class_id] |
||
+ | if class_specifics then |
||
+ | for _, k in ipairs(item_classes_extend) do |
||
+ | if class_specifics[k] ~= nil then |
||
+ | for _, value in ipairs(class_specifics[k]) do |
||
+ | table.insert(c.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 |
||
+ | c.item_classes[tpl_args.class_id].defaults[key] = value |
||
+ | end |
||
+ | end |
||
+ | end |
||
+ | end |
||
+ | |||
+ | function h.process_mods(tpl_args, frame) |
||
+ | -- 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 mods = {} |
||
local mod_ids = {} |
local mod_ids = {} |
||
Line 631: | Line 303: | ||
for _, key in ipairs(keys) do |
for _, key in ipairs(keys) do |
||
− | local req = math.floor(tonumber(data['mods.required_level']) * |
+ | local req = math.floor(tonumber(data['mods.required_level']) * cfg.item_required_level_modifier_contribution) |
if req > tpl_args[key] then |
if req > tpl_args[key] then |
||
tpl_args[key] = req |
tpl_args[key] = req |
||
Line 669: | Line 341: | ||
prefix = '_random' |
prefix = '_random' |
||
end |
end |
||
− | + | core.stats_update(tpl_args, id, value, mod_data.result['mods.id'], prefix .. '_stats') |
|
if mod_data.is_implicit then |
if mod_data.is_implicit then |
||
− | + | core.stats_update(tpl_args, id, value, mod_data.result['mods.id'], prefix .. '_implicit_stats') |
|
else |
else |
||
− | + | core.stats_update(tpl_args, id, value, mod_data.result['mods.id'], prefix .. '_explicit_stats') |
|
end |
end |
||
end |
end |
||
Line 710: | Line 382: | ||
if missing_sell_price then |
if missing_sell_price then |
||
− | tpl_args.sell_prices[ |
+ | tpl_args.sell_prices[i18n.tooltips.default_vendor_offer] = 1 |
end |
end |
||
Line 727: | Line 399: | ||
end |
end |
||
− | function |
+ | function h.process_base_item(tpl_args, frame) |
local where |
local where |
||
if tpl_args.base_item_id ~= nil then |
if tpl_args.base_item_id ~= nil then |
||
Line 749: | Line 421: | ||
local join = {} |
local join = {} |
||
− | for _, table_name in ipairs( |
+ | for _, table_name in ipairs(c.item_classes[tpl_args.class_id].tables) do |
if table_name ~= 'items' then |
if table_name ~= 'items' then |
||
join[#join+1] = string.format('items._pageID=%s._pageID', table_name) |
join[#join+1] = string.format('items._pageID=%s._pageID', table_name) |
||
Line 769: | Line 441: | ||
local result = m_cargo.query( |
local result = m_cargo.query( |
||
− | + | c.item_classes[tpl_args.class_id].tables, |
|
fields, |
fields, |
||
{ |
{ |
||
Line 788: | Line 460: | ||
tpl_args.base_item_data = result |
tpl_args.base_item_data = result |
||
− | + | h.process_arguments(tpl_args, frame, {'base_item', 'base_item_page', 'base_item_id'}) |
|
--Copy values.. |
--Copy values.. |
||
Line 819: | Line 491: | ||
end |
end |
||
− | function |
+ | function h.process_quest_rewards(tpl_args, frame) |
− | for _, k in ipairs(args.array) do |
||
− | 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 |
||
− | |||
− | function core.process_quest_rewards(tpl_args, frame) |
||
local rid = 1 |
local rid = 1 |
||
local continue |
local continue |
||
Line 1,030: | Line 589: | ||
end |
end |
||
+ | -- Lazy loading for Module:Item2/cargo |
||
+ | function h.build_cargo_data(tpl_args, frame, item_classes) |
||
+ | if not f_build_cargo_data then |
||
+ | f_build_cargo_data = use_sandbox and require('Module:Item2/cargo/sandbox').build_cargo_data or require('Module:Item2/cargo').build_cargo_data |
||
+ | end |
||
+ | return f_build_cargo_data(tpl_args, frame, item_classes) |
||
+ | end |
||
+ | -- Lazy loading for Module:Item2/upgrade |
||
− | function core.process_upgraded_from(tpl_args, frame) |
||
+ | function h.process_upgraded_from(tpl_args, frame) |
||
− | local query_data = { |
||
+ | if not f_process_upgraded_from then |
||
− | id = {}, |
||
+ | f_process_upgraded_from = use_sandbox and require('Module:Item2/upgrade/sandbox').process_upgraded_from or require('Module:Item2/upgrade').process_upgraded_from |
||
− | name = {}, |
||
− | page = {}, |
||
− | } |
||
− | 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 |
||
− | |||
− | 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 |
||
− | setid = setid + 1 |
||
− | 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 |
||
− | |||
− | -- 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 |
||
− | for _, condition in ipairs(data.condition) do |
||
− | continue = condition(tpl_args, frame) and continue |
||
− | if not continue then |
||
− | break |
||
− | end |
||
− | end |
||
− | |||
− | 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 |
||
− | query_data['id'][row.item_id] = {{#sets, groupid}, } |
||
− | end |
||
− | end |
||
− | end |
||
− | 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 |
||
+ | return f_process_upgraded_from(tpl_args, frame) |
||
end |
end |
||
-- |
-- |
||
+ | -- 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 |
||
− | end |
||
+ | stat_text = string.gsub(stat_text, '<table class="random%-modifier%-stats.+</table>', text, 1) |
||
− | end |
||
− | |||
− | function core.factory.args_present(...) |
||
− | local args = {...} |
||
− | return function (tpl_args) |
||
− | for _, k in ipairs(args) do |
||
− | if tpl_args[k] == nil then |
||
− | return false |
||
end |
end |
||
− | + | until text == nil |
|
− | return true |
||
end |
end |
||
+ | return stat_text |
||
end |
end |
||
+ | function h.add_to_container_from_map(tpl_args, frame, container, mapping, container_type) |
||
− | function core.factory.infobox_line(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') |
||
− | -- parts: |
||
− | + | :done() |
|
− | + | local count = 0 -- Number of groups in container |
|
+ | for _, group in ipairs(mapping) do |
||
− | -- allow_zero: allow zero values |
||
− | + | local lines = {} |
|
+ | if group.func == nil then |
||
− | -- hide_default_key: key to use if it isn't equal to the key parameter |
||
− | + | for _, line in ipairs(group) do |
|
+ | local show = true |
||
− | -- -- from m_util.html.format_value -- |
||
+ | if container_type == 'inline' and line.inline == false then -- TODO: This is not used currently. Need to address what is hidden in inline view. |
||
− | -- func: Function to transform the value retrieved from the database |
||
− | + | show = false |
|
− | + | elseif line.show == false then |
|
− | + | show = false |
|
+ | elseif type(line.show) == 'function' then |
||
− | -- class: Additional css class added to color tag |
||
+ | show = line.show(tpl_args, frame, container_type) |
||
− | -- inline: Format string to use for the output |
||
− | -- inline_color: poe_color code to use for the output. False for no color. Default: 'default' |
||
− | -- inline_class: Additional css class added to inline color tag |
||
− | -- sep: If specified, parts are joined with this separator before being formatted for output |
||
− | -- fmt: Format string to use for output. If not specified, parts are simply concatenated |
||
− | -- color: poe_color code to use for output. Default: no color |
||
− | -- class: Additional css class added to output |
||
− | |||
− | args.parts = args.parts or {} |
||
− | 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.parts) 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 |
||
− | + | if show then |
|
+ | lines[#lines+1] = line.func(tpl_args, frame, container_type) |
||
− | elseif args.type == 'stat' then |
||
− | for i, data in ipairs(args.parts) 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 |
||
− | + | 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 |
|
− | + | count = count + 1 |
|
− | + | local heading = '' |
|
− | + | if group.heading == nil then |
|
− | + | elseif type(group.heading) == 'function' 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 |
||
− | + | 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 |
||
+ | statcont |
||
+ | :tag('span') |
||
+ | :attr('class', 'group ' .. (group.class or '')) |
||
+ | :wikitext(heading .. table.concat(lines, '<br>')) |
||
+ | :done() |
||
end |
end |
||
− | |||
− | -- all zeros = dont display and return early |
||
− | if #final_values == 0 then |
||
− | return nil |
||
− | end |
||
− | |||
− | local parts = {} |
||
− | for i, data in ipairs(final_values) do |
||
− | local value = data.value |
||
− | value.base = base_values[data.index] |
||
− | |||
− | local options = args.parts[data.index] |
||
− | |||
− | if options.color == nil and args.type == 'gem' then |
||
− | value.color = 'value' |
||
− | end |
||
− | if options.truncate then |
||
− | options.inline_class = (options.inline_class or '') .. ' u-truncate-line' |
||
− | end |
||
− | |||
− | parts[#parts+1] = m_util.html.format_value(tpl_args, frame, value, options) |
||
− | end |
||
− | if args.sep then |
||
− | -- Join parts with separator before formatting |
||
− | parts = {table.concat(parts, args.sep)} |
||
− | end |
||
− | |||
− | -- Build output string |
||
− | local out |
||
− | if args.fmt then |
||
− | out = string.format(args.fmt, unpack(parts)) |
||
− | else |
||
− | out = table.concat(parts) |
||
− | end |
||
− | if args.color then |
||
− | out = m_util.html.poe_color(args.color, out, args.class) |
||
− | elseif args.class then |
||
− | out = tostring(mw.html.create('em') |
||
− | :attr('class', class) |
||
− | :wikitext(out) |
||
− | ) |
||
− | end |
||
− | return out |
||
end |
end |
||
− | end |
||
+ | -- Add groups to container |
||
− | function core.factory.display_raw_value(key) |
||
+ | if count > 0 then |
||
− | return function(tpl_args, frame) |
||
− | + | 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) |
||
− | 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.infobox_line{ |
||
− | parts = { |
||
− | { |
||
− | key = key, |
||
− | color = false, |
||
− | hide_default = 0, |
||
− | } |
||
− | } |
||
− | }(tpl_args, frame) |
||
− | end |
||
− | if value.min and value.max then |
||
− | local color = args.key or false |
||
− | local range_fmt |
||
− | if tpl_args[keys.min .. '_range_minimum'] ~= tpl_args[keys.min .. '_range_maximum'] or tpl_args[keys.max .. '_range_minimum'] ~= tpl_args[keys.max .. '_range_maximum'] then |
||
− | -- Variable damage range, based on modifier rolls |
||
− | if args.key == 'physical' then |
||
− | color = 'mod' |
||
− | end |
||
− | range_fmt = i18n.damage.variable_range |
||
− | else |
||
− | -- Standard damage range |
||
− | if args.key == 'physical' then |
||
− | color = 'value' |
||
− | end |
||
− | range_fmt = i18n.damage.standard_range |
||
− | end |
||
− | value = string.format(range_fmt, value.min, value.max) |
||
− | if color then |
||
− | value = m_util.html.poe_color(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) |
||
Line 1,747: | Line 753: | ||
:done() |
:done() |
||
− | + | h.add_to_container_from_map(tpl_args, frame, container, c.item_infobox_groups, container_type) |
|
end |
end |
||
Line 1,757: | Line 763: | ||
end |
end |
||
+ | -- |
||
− | function core.display.add_to_container_from_map(tpl_args, frame, container, mapping, container_type) |
||
+ | -- Factory |
||
− | 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 |
||
+ | h.factory = {} |
||
− | -- Add groups to container |
||
− | if count > 0 then |
||
− | container:node(statcont) |
||
− | end |
||
− | end |
||
+ | function h.factory.args_present(...) |
||
− | function core.display.strip_random_stats(tpl_args, frame, stat_text, container_type) |
||
+ | local args = {...} |
||
− | if tpl_args._flags.random_mods and container_type == 'inline' then |
||
+ | return function (tpl_args) |
||
− | repeat |
||
+ | for _, k in ipairs(args) do |
||
− | local text = string.match(stat_text, '<th class="mw%-customtoggle%-31">(.+)</th>') |
||
− | if |
+ | if tpl_args[k] == nil then |
+ | return false |
||
− | stat_text = string.gsub(stat_text, '<table class="random%-modifier%-stats.+</table>', text, 1) |
||
− | end |
||
− | until text == nil |
||
− | end |
||
− | return stat_text |
||
− | end |
||
− | |||
− | -- |
||
− | -- argument mapping |
||
− | -- |
||
− | -- format: |
||
− | -- tpl_args key = { |
||
− | -- no_copy = true or nil -- When loading an base item, dont copy this key |
||
− | -- property = 'prop', -- Property associated with this key |
||
− | -- 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 |
||
end |
end |
||
− | + | return true |
|
− | -- 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 == 'Prophecy' or tpl_args.base_item_page == 'Prophecy' 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 |
||
− | 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 |
||
− | }, |
||
− | seed_type_html = { |
||
− | field = nil, |
||
− | 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 |
||
− | }, |
||
− | 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, |
||
− | }, |
||
− | -- |
||
− | -- 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', |
||
− | }, |
||
− | } |
||
− | |||
− | -- 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 |
||
− | |||
− | 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 |
+ | 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 |
||
− | + | 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 |
+ | 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 = { |
||
− | { |
||
− | -- Lysah's Respite |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardLysahsRespite", |
||
− | amount = 6, |
||
− | }, |
||
− | }, |
||
}, |
}, |
||
− | { |
+ | avg = { |
− | + | 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, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.unset_ring)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Penitent |
||
− | 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, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.gold_ring)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Glimmer of Hope |
||
− | 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, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.prismatic_ring)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Hope |
||
− | 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, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.two_stone_ring)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Lantador's Lost Love |
||
− | 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, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.two_stone_ring)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Heterochromia |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardHeterochromia", |
||
− | amount = 2, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | -- |
||
− | -- 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 = { |
||
− | { |
||
− | -- Call to the First Ones |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardCallToTheFirstOnes", |
||
− | amount = 5, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | condition = { |
||
− | h.conditions.unique, |
||
− | function (tpl_args, frame) |
||
− | return string.find(tpl_args.name, 'Atziri') |
||
− | 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, 'Atziri'))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Admirer |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardTheAdmirer", |
||
− | amount = 9, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | condition = { |
||
− | h.conditions.unique, |
||
− | function (tpl_args, frame) |
||
− | return string.find(tpl_args.name, 'Doedre') |
||
− | 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, 'Doedre'))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Doedre's Madness |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardDoedresMadness", |
||
− | amount = 9, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | condition = { |
||
− | h.conditions.unique, |
||
− | function (tpl_args, frame) |
||
− | return string.find(tpl_args.name, 'Shavronne') |
||
− | 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, 'Shavronne'))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Aesthete |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardTheAesthete", |
||
− | amount = 8, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | condition = { |
||
− | h.conditions.unique, |
||
− | function (tpl_args, frame) |
||
− | return string.find(tpl_args.name, 'Rigwald') |
||
− | 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, 'Rigwald'))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Wolf |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardTheWolf", |
||
− | amount = 5, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | condition = { |
||
− | h.conditions.unique, |
||
− | function (tpl_args, frame) |
||
− | return string.find(tpl_args.name, 'Lioneye') |
||
− | 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, 'Lioneye'))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Lion |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardTheLion", |
||
− | amount = 5, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | -- |
||
− | -- League specific items |
||
− | -- |
||
− | { |
||
− | condition = { |
||
− | h.conditions.unique, |
||
− | h.conditions.factory.league{league='Nemesis'}, |
||
− | }, |
||
− | 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, 'Nemesis'))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Valkyrie |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardTheValkyrie", |
||
− | amount = 8, |
||
− | |||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | defaults = { |
||
− | is_corrupted = false, |
||
− | }, |
||
− | condition = { |
||
− | h.conditions.unique, |
||
− | h.conditions.factory.league{league='Nemesis'}, |
||
− | }, |
||
− | 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, 'Nemesis'))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Undaunted |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardTheUndaunted", |
||
− | amount = 5, |
||
− | |||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | condition = { |
||
− | h.conditions.unique, |
||
− | h.conditions.factory.league{league='Beyond'}, |
||
− | }, |
||
− | 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, 'Beyond'))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Calling |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardTheCalling", |
||
− | amount = 6, |
||
− | |||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | condition = { |
||
− | h.conditions.unique, |
||
− | h.conditions.factory.league{league='Breach'}, |
||
− | }, |
||
− | 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, 'Breach'))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Breach |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardTheBreach", |
||
− | amount = 4, |
||
− | |||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | condition = { |
||
− | h.conditions.unique, |
||
− | h.conditions.factory.league{league='Delve'}, |
||
− | }, |
||
− | 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, 'Delve'))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Alone in the Darkness |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardAloneInTheDarkness", |
||
− | amount = 5, |
||
− | |||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | condition = { |
||
− | h.conditions.unique, |
||
− | h.conditions.factory.league{league='Bestiary'}, |
||
− | }, |
||
− | 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, 'Bestiary'))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Boon of the First Ones |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardBoonOfTheFirstOnes", |
||
− | amount = 6, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | -- |
||
− | -- Subset of class |
||
− | -- |
||
− | { |
||
− | condition = { |
||
− | h.conditions.normal, |
||
− | -- Seems like the other breach stones are in a different category, so this is good enough to separate from the improved stones |
||
− | h.conditions.factory.arg{arg='class_id', value='MiscMapItem'}, |
||
− | function (tpl_args, frame) |
||
− | return string.find(tpl_args.metadata_id, 'BreachFragment') |
||
− | 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.breachstone)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Obscured |
||
− | 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, m_util.html.poe_color('currency', i18n.upgraded_from_tooltips.deafening_essence), 3) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Cacophony |
||
− | 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, m_util.html.poe_color('currency', i18n.upgraded_from_tooltips.shrieking_essence), 9) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Harmony of Souls |
||
− | 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, m_util.html.poe_color('currency', i18n.upgraded_from_tooltips.essence), 3) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Three Voices |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardThreeVoices", |
||
− | amount = 3, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | 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, m_util.html.poe_color('normal', string.format(i18n.upgraded_from_tooltips.f.tier_x_map, 5))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Cartographer's Delight |
||
− | 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, m_util.html.poe_color('normal', string.format(i18n.upgraded_from_tooltips.f.tier_x_map, 14))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Surveyor |
||
− | 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, m_util.html.poe_color('normal', string.format(i18n.upgraded_from_tooltips.f.tier_x_map, 15))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Lost Worlds |
||
− | 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, m_util.html.poe_color('rare', string.format(i18n.upgraded_from_tooltips.f.tier_x_map, 15))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Trial |
||
− | 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, m_util.html.poe_color('rare', string.format(i18n.upgraded_from_tooltips.f.tier_x_map, 16))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Left to Fate |
||
− | 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, 21, m_game.constants.item.gem_tags.golem.tag))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Rite of Elements |
||
− | 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.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 = { |
||
− | { |
||
− | -- Volatile Power |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardVolatilePower", |
||
− | amount = 9, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | 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, |
||
− | 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 = { |
||
− | { |
||
− | -- More is Never Enough |
||
− | 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 = { |
||
− | { |
||
− | -- Cameria's Cut |
||
− | 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 = { |
||
− | { |
||
− | -- Skittering Incubator |
||
− | item_id = "Metadata/Items/Currency/CurrencyIncubationScarabs", |
||
− | amount = 1, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | 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 = { |
||
− | { |
||
− | -- Primal Incubator |
||
− | item_id = "Metadata/Items/Currency/CurrencyIncubationTalismans", |
||
− | amount = 1, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | -- |
||
− | -- One class |
||
− | -- |
||
− | { |
||
− | 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 = { |
||
− | { |
||
− | -- The Messenger |
||
− | 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 = { |
||
− | { |
||
− | -- The Body |
||
− | 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 = { |
||
− | { |
||
− | -- The Mercenary |
||
− | 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, m_util.html.poe_color('unique', i18n.tooltips.item_class_map['Claw'])) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Wolverine |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardTheWolverine", |
||
− | amount = 4, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | condition = { |
||
− | h.conditions.unique, |
||
− | h.conditions.factory.arg{arg='class_id', values={'Dagger', 'Runedagger'}}, |
||
− | }, |
||
− | 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 = { |
||
− | { |
||
− | -- Assassin's Favour |
||
− | 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 = { |
||
− | { |
||
− | -- The Lord of Celebration |
||
− | 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 = { |
||
− | { |
||
− | -- Hunter's Resolve |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardHuntersResolve", |
||
− | amount = 8, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | 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', m_game.constants.item.classes.Jewel.full)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Garish Power |
||
− | 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', m_game.constants.item.classes.Jewel.full)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Eye of the Dragon |
||
− | 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 = { |
||
− | { |
||
− | -- The Sigil |
||
− | 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 = { |
||
− | { |
||
− | -- The Warden |
||
− | 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, 83, m_util.html.poe_color('magic', string.format('%s %s', i18n.upgraded_from_tooltips.ring, frame:expandTemplate{title='Modifier link',args={id='ChaosResist6'}}))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Lord in Black |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardTheLordInBlack", |
||
− | amount = 6, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | 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, 100, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.ring)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Opulent |
||
− | 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, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.ring)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Hubris |
||
− | 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, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.ring)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Blind Venture |
||
− | 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 = { |
||
− | { |
||
− | -- The Wretched |
||
− | 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, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.map)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Encroaching Darkness |
||
− | 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, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.map)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Otherworldly Incubator |
||
− | item_id = "Metadata/Items/Currency/CurrencyIncubationUniqueMaps", |
||
− | amount = 8, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | 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 = { |
||
− | { |
||
− | -- The Traitor |
||
− | 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 = { |
||
− | { |
||
− | -- The Tower |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardTheTower", |
||
− | amount = 6, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | condition = { |
||
− | h.conditions.normal, |
||
− | h.conditions.factory.arg{arg='class_id', values={'Staff', 'Warstaff'}}, |
||
− | 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, 5, 66, m_util.html.poe_color('normal', i18n.tooltips.item_class_map['Staff'])) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Flora's Gift |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardTheFlorasGift", |
||
− | amount = 5, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | condition = { |
||
− | h.conditions.normal, |
||
− | h.conditions.factory.arg{arg='class_id', values={'Staff', 'Warstaff'}}, |
||
− | 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, 6, 55, m_util.html.poe_color('normal', i18n.tooltips.item_class_map['Staff'])) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Dark Mage |
||
− | 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, 6, 100, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.body_armour)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Dapper Prodigy |
||
− | 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, 6, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.body_armour)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Chains that Bind |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardTheChainsThatBind", |
||
− | amount = 11, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | 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, 20, m_game.constants.item.gem_tags.support.tag))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Gift of the Gemling Queen |
||
− | 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 = { |
||
− | { |
||
− | -- Dialla's Subjugation |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardDiallasSubjugation", |
||
− | amount = 7, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | 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, 100, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.body_armour)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Destined to Crumble |
||
− | 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, m_util.html.poe_color('normal', i18n.upgraded_from_tooltips.map)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Boundless Realms |
||
− | 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, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.map)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Explorer |
||
− | 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, m_util.html.poe_color('unique', m_game.constants.item.classes['Gloves'].full)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Mitts |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardMitts", |
||
− | amount = 5, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | 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, m_util.html.poe_color('divination', i18n.upgraded_from_tooltips.divination_card)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Gambler |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardTheGambler", |
||
− | amount = 5, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | 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, m_util.html.poe_color('divination', i18n.upgraded_from_tooltips.divination_card)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Stacked Deck |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardDeck", |
||
− | 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 = { |
||
− | { |
||
− | -- The Battle Born |
||
− | 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', 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_corrupted, m_util.html.poe_color('gem', string.format(i18n.upgraded_from_tooltips.f.level_x_y_gem, 21, m_game.constants.item.gem_tags.aura.tag))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Wilted Rose |
||
− | 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 = { |
||
− | { |
||
− | -- The Fox |
||
− | 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 = { |
||
− | { |
||
− | -- The Summoner |
||
− | 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, 21, m_game.constants.item.gem_tags.spell.tag))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | --The Cataclysm |
||
− | 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 = { |
||
− | { |
||
− | -- Gemcutter's Promise |
||
− | 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 = { |
||
− | { |
||
− | -- The Inoculated |
||
− | 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.life, i18n.upgraded_from_tooltips.armour))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Carrion Crow |
||
− | 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, 100, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.jewellery)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Perfection |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardPerfection", |
||
− | amount = 5, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | 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, 79, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.jewellery)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Lover |
||
− | 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, 85, m_util.html.poe_color('magic', string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='ReduceGlobalFlatManaCostStrIntMasterVendor'}}, i18n.upgraded_from_tooltips.jewellery))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Blessing of God |
||
− | 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, 76, m_util.html.poe_color('magic', string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='AddedLightningDamage9'}}, i18n.upgraded_from_tooltips.jewellery))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | --Struck by Lightning |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardStruckByLightning", |
||
− | 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, 100, 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))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Merciless Armament |
||
− | 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, 100, 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))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Jester |
||
− | 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, 100, 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))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Road to Power |
||
− | 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 = { |
||
− | { |
||
− | -- The Gentleman |
||
− | 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, 100, m_util.html.poe_color('magic',string.format('%s %s', frame:expandTemplate{title='Modifier link',args={id='LocalIncreasedPhysicalDamagePercent8'}}, i18n.upgraded_from_tooltips.weapon))) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Tyrant |
||
− | 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, 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 = { |
||
− | { |
||
− | -- The Web |
||
− | 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, m_util.html.poe_color('unique', i18n.upgraded_from_tooltips.weapon)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- Atziri's Arsenal |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardAtzirisArsenal", |
||
− | amount = 4, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | condition = { |
||
− | h.conditions.normal, |
||
− | -- specifically exclude crit flasks |
||
− | 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 = { |
||
− | { |
||
− | -- The Surgeon |
||
− | 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 = { |
||
− | { |
||
− | -- Time-Lost Relic |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardTimeLostRelic", |
||
− | amount = 10, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | -- |
||
− | -- Generic items |
||
− | -- |
||
− | { |
||
− | condition = { |
||
− | h.conditions.normal, |
||
− | -- should exclude all items that can't be rare |
||
− | 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, 100, m_util.html.poe_color('rare', i18n.upgraded_from_tooltips.item)) |
||
− | end, |
||
− | groups = { |
||
− | { |
||
− | -- The Hale Heart |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardTheHaleHeart", |
||
− | amount = 4, |
||
− | }, |
||
− | }, |
||
− | }, |
||
− | { |
||
− | defaults = { |
||
− | is_drop_restricted = false, |
||
− | }, |
||
− | condition = { |
||
− | h.conditions.unique, |
||
− | h.conditions.factory.arg{arg='is_fated', value=true}, |
||
− | }, |
||
− | 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 = { |
||
− | { |
||
− | -- Akil's Prophecy |
||
− | 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 = { |
||
− | { |
||
− | -- Arrogance of the Vaal |
||
− | 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 = { |
||
− | { |
||
− | -- Jack in the Box |
||
− | item_id = "Metadata/Items/DivinationCards/DivinationCardJackInTheBox", |
||
− | amount = 4, |
||
− | }, |
||
− | }, |
||
}, |
}, |
||
− | -- TODO: The void? |
||
} |
} |
||
Line 6,388: | Line 821: | ||
-- 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 = { |
||
-- [n]: |
-- [n]: |
||
-- class: Additional css class added to group tag |
-- class: Additional css class added to group tag |
||
Line 6,399: | Line 832: | ||
-- Cosmetic item type |
-- Cosmetic item type |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('cosmetic_type'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 6,417: | Line 850: | ||
end |
end |
||
− | return |
+ | return cfg.class_groups.weapons.keys[tpl_args.class_id] ~= nil |
end, |
end, |
||
func = function(tpl_args, frame) |
func = function(tpl_args, frame) |
||
− | local v = i18n |
+ | 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, |
||
Line 6,430: | Line 863: | ||
end, |
end, |
||
func = function(tpl_args, frame) |
func = function(tpl_args, frame) |
||
− | return i18n |
+ | return i18n.item_class_map[tpl_args.class_id] |
end, |
end, |
||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('gem_tags'), |
func = function(tpl_args, frame) |
func = function(tpl_args, frame) |
||
local out = {} |
local out = {} |
||
Line 6,445: | Line 878: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('support_gem_letter_html'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 6,456: | Line 889: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('radius'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
{ |
{ |
||
key = 'radius', |
key = 'radius', |
||
− | func = |
+ | func = h.factory.descriptor_value{key='radius_description'}, |
}, |
}, |
||
{ |
{ |
||
key = 'radius_secondary', |
key = 'radius_secondary', |
||
− | func = |
+ | func = h.factory.descriptor_value{key='radius_secondary_description'}, |
}, |
}, |
||
{ |
{ |
||
key = 'radius_tertiary', |
key = 'radius_tertiary', |
||
− | func = |
+ | func = h.factory.descriptor_value{key='radius_tertiary_description'}, |
}, |
}, |
||
}, |
}, |
||
Line 6,478: | Line 911: | ||
-- TODO: gem level here. Maybe put max level here? |
-- TODO: gem level here. Maybe put max level here? |
||
{ |
{ |
||
+ | -- TODO: Rework for 3.14.0 skill cost and reservation changes |
||
show = true, |
show = true, |
||
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
Line 6,512: | Line 946: | ||
}, |
}, |
||
{ |
{ |
||
− | show = true, |
+ | show = true, -- TODO: Show only if has mana_multiplier |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
type = 'gem', |
type = 'gem', |
||
Line 6,525: | Line 959: | ||
}, |
}, |
||
}, |
}, |
||
− | -- TODO: i18n |
||
{ |
{ |
||
− | show = true, |
+ | show = true, -- TODO: Show only if has cooldown |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
type = 'gem', |
type = 'gem', |
||
parts = { |
parts = { |
||
{ |
{ |
||
− | key = ' |
+ | key = 'cooldown', |
hide_default = 0, |
hide_default = 0, |
||
− | fmt = '% |
+ | fmt = '%.2f ' .. m_game.units.seconds.short_lower, |
}, |
}, |
||
}, |
}, |
||
− | fmt = i18n.tooltips. |
+ | 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, |
show = true, |
||
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
Line 6,546: | Line 980: | ||
parts = { |
parts = { |
||
{ |
{ |
||
− | key = ' |
+ | key = 'stored_uses', |
hide_default = 0, |
hide_default = 0, |
||
fmt = '%i', |
fmt = '%i', |
||
Line 6,555: | Line 989: | ||
}, |
}, |
||
{ |
{ |
||
− | show = true, |
+ | show = true, -- TODO: Show only if has vaal_souls_requirement |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
type = 'gem', |
type = 'gem', |
||
parts = { |
parts = { |
||
{ |
{ |
||
− | key = ' |
+ | key = 'vaal_souls_requirement', |
hide_default = 0, |
hide_default = 0, |
||
fmt = '%i', |
fmt = '%i', |
||
}, |
}, |
||
}, |
}, |
||
− | fmt = i18n.tooltips. |
+ | fmt = i18n.tooltips.vaal_souls_per_use, |
}, |
}, |
||
}, |
}, |
||
{ |
{ |
||
− | show = true, |
+ | show = true, -- TODO: Show only if has vaal_stored_uses |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
type = 'gem', |
type = 'gem', |
||
parts = { |
parts = { |
||
{ |
{ |
||
− | key = ' |
+ | key = 'vaal_stored_uses', |
hide_default = 0, |
hide_default = 0, |
||
− | + | fmt = '%i', |
|
− | fmt = '%.3f sec', |
||
}, |
}, |
||
}, |
}, |
||
− | fmt = i18n.tooltips. |
+ | fmt = i18n.tooltips.stored_uses, -- TODO: Singular or plural based on number |
}, |
}, |
||
}, |
}, |
||
{ |
{ |
||
− | show = true, |
+ | show = true, -- TODO: Show only if has vaal_soul_gain_prevention_time |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
type = 'gem', |
type = 'gem', |
||
parts = { |
parts = { |
||
{ |
{ |
||
− | key = ' |
+ | key = 'vaal_soul_gain_prevention_time', |
hide_default = 0, |
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. |
+ | fmt = i18n.tooltips.vaal_soul_gain_prevention_time, |
}, |
}, |
||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('cast_time'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
{ |
{ |
||
key = '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, |
||
}, |
}, |
||
}, |
}, |
||
Line 6,611: | Line 1,049: | ||
}, |
}, |
||
{ |
{ |
||
− | show = true, |
+ | show = true, -- TODO: Show only if has critical_strike_chance |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
type = 'gem', |
type = 'gem', |
||
Line 6,625: | Line 1,063: | ||
}, |
}, |
||
{ |
{ |
||
− | show = true, |
+ | show = true, -- TODO: Show only if has attack_speed_multiplier |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
type = 'gem', |
type = 'gem', |
||
Line 6,632: | Line 1,070: | ||
key = 'attack_speed_multiplier', |
key = 'attack_speed_multiplier', |
||
hide_default = 100, |
hide_default = 100, |
||
− | fmt = |
+ | fmt = '%i%%', |
+ | inline = '%s ' .. i18n.tooltips.of_base_stat, |
||
+ | inline_color = 'value', |
||
}, |
}, |
||
}, |
}, |
||
Line 6,639: | Line 1,079: | ||
}, |
}, |
||
{ |
{ |
||
− | show = true, |
+ | 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%%', |
||
+ | 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{ |
func = core.factory.infobox_line{ |
||
type = 'gem', |
type = 'gem', |
||
Line 6,653: | Line 1,109: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('projectile_speed'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 6,665: | Line 1,121: | ||
-- Quality is before item stats, but after gem stuff and item class |
-- Quality is before item stats, but after gem stuff and item class |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('quality'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 6,680: | Line 1,136: | ||
-- Weapon only |
-- Weapon only |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('physical_damage_html'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 6,709: | Line 1,165: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('chaos_damage_html'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 6,722: | Line 1,178: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('critical_strike_chance_html'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 6,734: | Line 1,190: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('attack_speed_html'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 6,746: | Line 1,202: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('weapon_range_html'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 6,759: | Line 1,215: | ||
-- Map only |
-- Map only |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('map_area_level'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 6,771: | Line 1,227: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('map_tier'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 6,869: | Line 1,325: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('jewel_radius_html'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 6,875: | Line 1,331: | ||
key = 'jewel_radius_html', |
key = 'jewel_radius_html', |
||
fmt = '%s', |
fmt = '%s', |
||
+ | color = false, -- html already has color |
||
}, |
}, |
||
}, |
}, |
||
Line 6,882: | Line 1,339: | ||
-- Flask only |
-- Flask only |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('flask_mana_html', 'flask_duration_html'), |
--func = core.factory.display_flask('flask_mana'), |
--func = core.factory.display_flask('flask_mana'), |
||
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
Line 6,899: | Line 1,356: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('flask_life_html', 'flask_duration_html'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 6,935: | Line 1,392: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('charges_per_use_html', 'charges_max_html'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 6,951: | Line 1,408: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('buff_stat_text'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 6,963: | Line 1,420: | ||
-- armor |
-- armor |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('block_html'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 6,977: | Line 1,434: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('armour_html'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 6,991: | Line 1,448: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('evasion_html'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,005: | Line 1,462: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('energy_shield_html'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,019: | Line 1,476: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('movement_speed'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,033: | Line 1,490: | ||
-- Amulet only |
-- Amulet only |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('talisman_tier'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,046: | Line 1,503: | ||
-- Misc |
-- Misc |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('stack_size'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,060: | Line 1,517: | ||
-- Essence stuff |
-- Essence stuff |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('essence_level'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,073: | Line 1,530: | ||
-- Blight items |
-- Blight items |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('blight_item_tier'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,086: | Line 1,543: | ||
-- Harvest seeds (upper section) |
-- Harvest seeds (upper section) |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('seed_tier'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,098: | Line 1,555: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('seed_tier'), |
func = function (tpl_args, value) |
func = function (tpl_args, value) |
||
return i18n.tooltips.seed_monster |
return i18n.tooltips.seed_monster |
||
Line 7,104: | Line 1,561: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('seed_type_html'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,116: | Line 1,573: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('seed_growth_cycles'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,130: | Line 1,587: | ||
-- TODO: Remaining enhancements |
-- TODO: Remaining enhancements |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('plant_booster_radius'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,142: | Line 1,599: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('heist_required_npcs'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,158: | Line 1,615: | ||
-- TODO: i18n Master name? |
-- TODO: i18n Master name? |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('master', 'master_level_requirement'), |
func = function(tpl_args, frame) |
func = function(tpl_args, frame) |
||
-- masters have been validated before |
-- masters have been validated before |
||
Line 7,188: | Line 1,645: | ||
parts[#parts+1] = { |
parts[#parts+1] = { |
||
key = string.format('required_%s_html', attr), |
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 = ', %s ' .. m_game.constants.attributes[attr].short_upper, |
||
inline_color = false, |
inline_color = false, |
||
Line 7,203: | Line 1,663: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('heist_required_job', 'heist_required_job_level'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,223: | Line 1,683: | ||
class = 'tc -gemdesc', |
class = 'tc -gemdesc', |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('gem_description'), |
− | func = |
+ | func = h.factory.display_raw_value('gem_description'), |
}, |
}, |
||
}, |
}, |
||
Line 7,231: | Line 1,691: | ||
class = 'tc -mod', |
class = 'tc -mod', |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('skill_quality'), |
func = function(tpl_args, frame) |
func = function(tpl_args, frame) |
||
local span = mw.html.create('span') |
local span = mw.html.create('span') |
||
Line 7,278: | Line 1,738: | ||
{ |
{ |
||
show = function(tpl_args, frame) |
show = function(tpl_args, frame) |
||
− | return |
+ | 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) |
||
Line 7,284: | Line 1,744: | ||
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 == |
+ | 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 |
||
Line 7,298: | Line 1,758: | ||
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 { |
+ | return {h.strip_random_stats(tpl_args, frame, tpl_args.implicit_stat_text, container_type)} |
else |
else |
||
return {} |
return {} |
||
Line 7,309: | Line 1,769: | ||
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 { |
+ | return {h.strip_random_stats(tpl_args, frame, tpl_args.explicit_stat_text, container_type)} |
else |
else |
||
return {} |
return {} |
||
Line 7,318: | Line 1,778: | ||
--[[{ |
--[[{ |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('experience'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,333: | Line 1,793: | ||
class = 'tc -mod', |
class = 'tc -mod', |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('seed_consumed_wild_lifeforce_percentage'), |
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 |
||
Line 7,341: | Line 1,801: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('seed_consumed_vivid_lifeforce_percentage'), |
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 |
||
Line 7,349: | Line 1,809: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('seed_consumed_primal_lifeforce_percentage'), |
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 |
||
Line 7,357: | Line 1,817: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('seed_required_nearby_seed_tier', 'seed_type_html', 'seed_required_nearby_seed_amount'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,381: | Line 1,841: | ||
class = 'tc -crafted', |
class = 'tc -crafted', |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('seed_effect'), |
− | func = |
+ | func = h.factory.display_raw_value('seed_effect'), |
}, |
}, |
||
}, |
}, |
||
Line 7,389: | Line 1,849: | ||
class = 'tc -mod', |
class = 'tc -mod', |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('description'), |
− | func = |
+ | func = h.factory.display_raw_value('description'), |
}, |
}, |
||
--[[{ |
--[[{ |
||
− | show = |
+ | show = h.factory.args_present('plant_booster_additional_crafting_options'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,405: | Line 1,865: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('plant_booster_extra_chances'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,417: | Line 1,877: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('plant_booster_lifeforce'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,432: | Line 1,892: | ||
class = 'tc -crafted', |
class = 'tc -crafted', |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('incubator_effect'), |
− | func = |
+ | func = h.factory.display_raw_value('incubator_effect'), |
}, |
}, |
||
}, |
}, |
||
Line 7,440: | Line 1,900: | ||
class = 'tc -mod', |
class = 'tc -mod', |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('variation_count'), |
func = function(tpl_args, frame) |
func = function(tpl_args, frame) |
||
local txt |
local txt |
||
Line 7,456: | Line 1,916: | ||
class = 'tc -flavour', |
class = 'tc -flavour', |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('flavour_text'), |
− | func = |
+ | func = h.factory.display_raw_value('flavour_text'), |
}, |
}, |
||
}, |
}, |
||
Line 7,464: | Line 1,924: | ||
class = 'tc -value', |
class = 'tc -value', |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('prediction_text'), |
− | func = |
+ | func = h.factory.display_raw_value('prediction_text'), |
}, |
}, |
||
}, |
}, |
||
Line 7,472: | Line 1,932: | ||
class = 'tc -canttradeormodify', |
class = 'tc -canttradeormodify', |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('cannot_be_traded_or_modified'), |
func = function(tpl_args, frame) |
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 |
||
Line 7,484: | Line 1,944: | ||
class = 'tc -help', |
class = 'tc -help', |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('help_text'), |
− | func = |
+ | func = h.factory.display_raw_value('help_text'), |
}, |
}, |
||
}, |
}, |
||
Line 7,492: | Line 1,952: | ||
--class = '', |
--class = '', |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('master_favour_cost'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,504: | Line 1,964: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('seal_cost'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
{ |
{ |
||
key = 'seal_cost', |
key = 'seal_cost', |
||
− | fmt = |
+ | fmt = function (tpl_args, frame, value) |
+ | return '%dx ' .. h.item_link{metadata_id='Metadata/Items/Currency/CurrencySilverCoin', html=''} |
||
+ | end, |
||
color = 'currency', |
color = 'currency', |
||
}, |
}, |
||
Line 7,522: | Line 1,984: | ||
-- 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 |
||
-- |
-- |
||
− | + | c.extra_display_groups = { |
|
{ |
{ |
||
heading = i18n.tooltips.extra_info, |
heading = i18n.tooltips.extra_info, |
||
class = '', |
class = '', |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('atlas_connections'), |
func = function(tpl_args, frame) |
func = function(tpl_args, frame) |
||
local fields = { |
local fields = { |
||
Line 7,640: | Line 2,102: | ||
class = '', |
class = '', |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('drop_enabled'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,659: | Line 2,121: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = function(tpl_args, frame) |
+ | if tpl_args.drop_enabled == false then |
||
+ | return true |
||
+ | end |
||
+ | return false |
||
+ | end, |
||
func = function(tpl_args, frame) |
func = function(tpl_args, frame) |
||
+ | local span = mw.html.create('span') |
||
− | return string.format(i18n.tooltips.league_restriction, m_util.html.poe_color('value', table.concat(tpl_args.drop_leagues, ', '))) |
||
− | + | span |
|
+ | :attr('class', 'infobox-disabled-drop') |
||
− | }, |
||
+ | :wikitext(i18n.tooltips.drop_disabled) |
||
− | { |
||
− | + | :done() |
|
− | + | return tostring(span) |
|
− | + | end, |
|
− | { |
||
− | show = core.factory.args_present('drop_text'), |
||
− | func = core.factory.display_raw_value('drop_text'), |
||
}, |
}, |
||
{ |
{ |
||
show = function(tpl_args, frame) |
show = function(tpl_args, frame) |
||
− | if tpl_args. |
+ | if tpl_args.is_drop_restricted == true and tpl_args.drop_enabled ~= false then |
− | return |
+ | return true |
end |
end |
||
− | return |
+ | 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 |
||
− | :attr('class', 'infobox- |
+ | :attr('class', 'infobox-restricted-drop') |
− | :wikitext(i18n.tooltips. |
+ | :wikitext(i18n.tooltips.drop_restricted) |
:done() |
:done() |
||
return tostring(span) |
return tostring(span) |
||
end, |
end, |
||
+ | }, |
||
+ | { |
||
+ | show = h.factory.args_present('drop_leagues'), |
||
+ | 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.args_present('drop_areas_html'), |
||
+ | func = h.factory.display_raw_value('drop_areas_html'), |
||
+ | }, |
||
+ | { |
||
+ | show = h.factory.args_present('drop_text'), |
||
+ | func = h.factory.display_raw_value('drop_text'), |
||
}, |
}, |
||
}, |
}, |
||
Line 7,727: | Line 2,205: | ||
heading = i18n.tooltips.sell_price, |
heading = i18n.tooltips.sell_price, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('sell_price_order'), |
func = function(tpl_args, frame) |
func = function(tpl_args, frame) |
||
local out = {} |
local out = {} |
||
Line 7,746: | Line 2,224: | ||
heading = i18n.tooltips.misc, |
heading = i18n.tooltips.misc, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('class'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,758: | Line 2,236: | ||
}, |
}, |
||
{ |
{ |
||
− | show = |
+ | show = h.factory.args_present('metadata_id'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,774: | Line 2,252: | ||
for i, data in ipairs(core.dps_map) do |
for i, data in ipairs(core.dps_map) do |
||
− | table.insert( |
+ | table.insert(c.extra_display_groups[4], { |
− | show = |
+ | show = h.factory.args_present(data.name .. '_html'), |
func = core.factory.infobox_line{ |
func = core.factory.infobox_line{ |
||
parts = { |
parts = { |
||
Line 7,789: | Line 2,267: | ||
}) |
}) |
||
if i == 5 then |
if i == 5 then |
||
− | table.insert( |
+ | table.insert(c.extra_display_groups[4], { |
show = function (tpl_args, frame) |
show = function (tpl_args, frame) |
||
return tpl_args.elemental_dps_html ~= nil or tpl_args.poison_dps_html ~= nil |
return tpl_args.elemental_dps_html ~= nil or tpl_args.poison_dps_html ~= nil |
||
Line 7,798: | Line 2,276: | ||
}) |
}) |
||
elseif i == 7 then |
elseif i == 7 then |
||
− | table.insert( |
+ | table.insert(c.extra_display_groups[4], { |
− | show = |
+ | show = h.factory.args_present('dps_html'), |
func = function (tpl_args, frame) |
func = function (tpl_args, frame) |
||
return '' |
return '' |
||
Line 7,808: | Line 2,286: | ||
-- ---------------------------------------------------------------------------- |
-- ---------------------------------------------------------------------------- |
||
+ | -- Exported functions |
||
− | -- Tables |
||
-- ---------------------------------------------------------------------------- |
-- ---------------------------------------------------------------------------- |
||
+ | local p = {} |
||
− | function cargo_declare(data) |
||
− | return function(frame) |
||
− | local tpl_args = getArgs(frame, { |
||
− | parentFirst = true |
||
− | }) |
||
− | frame = m_util.misc.get_frame(frame) |
||
− | |||
− | local dcl_args = {} |
||
− | dcl_args._table = data.table |
||
− | for k, field_data in pairs(data.fields) do |
||
− | if field_data.field then |
||
− | dcl_args[field_data.field] = field_data.type |
||
− | for _, stat_data in pairs(core.stat_map) do |
||
− | if stat_data.field == k then |
||
− | for _, range_fields in ipairs(h.range_fields) do |
||
− | -- if the type is nil, use the parent type |
||
− | -- so this is set integer/float values correctly |
||
− | dcl_args[stat_data.field .. range_fields.field] = range_fields.type or field_data.type |
||
− | end |
||
− | break |
||
− | end |
||
− | end |
||
− | end |
||
− | end |
||
− | |||
− | if dcl_args._table == 'weapons' then |
||
− | for _, dps_data in ipairs(core.dps_map) do |
||
− | for _, range_fields in ipairs(h.range_fields) do |
||
− | -- since there is no parent, the default is float |
||
− | dcl_args[dps_data.field .. range_fields.field] = range_fields.type or 'Float' |
||
− | end |
||
− | end |
||
− | end |
||
− | if tpl_args.debug then |
||
− | mw.logObject(dcl_args) |
||
− | end |
||
− | return m_cargo.declare(frame, dcl_args) |
||
− | end |
||
− | end |
||
− | |||
− | p.table_items = cargo_declare(core.cargo.items) |
||
− | p.table_item_sell_prices = cargo_declare(core.cargo.item_sell_prices) |
||
− | p.table_item_purchase_costs = cargo_declare(core.cargo.item_purchase_costs) |
||
− | p.table_item_mods = cargo_declare(core.cargo.item_mods) |
||
− | p.table_item_stats = cargo_declare(core.cargo.item_stats) |
||
− | p.table_item_buffs = cargo_declare(core.cargo.item_buffs) |
||
− | p.table_upgraded_from_sets = cargo_declare(core.cargo.upgraded_from_sets) |
||
− | p.table_upgraded_from_groups = cargo_declare(core.cargo.upgraded_from_groups) |
||
− | p.table_amulets = cargo_declare(core.cargo.amulets) |
||
− | p.table_flasks = cargo_declare(core.cargo.flasks) |
||
− | p.table_weapons = cargo_declare(core.cargo.weapons) |
||
− | p.table_armours = cargo_declare(core.cargo.armours) |
||
− | 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 |
-- Template:Item |
||
-- |
-- |
||
+ | function p.item(frame) |
||
− | |||
− | function p.itembox (frame) |
||
− | -- |
||
− | -- Args/Frame |
||
− | -- |
||
local t = os.clock() |
local t = os.clock() |
||
Line 7,907: | Line 2,308: | ||
tpl_args._flags = {} |
tpl_args._flags = {} |
||
tpl_args._base_item_args = {} |
tpl_args._base_item_args = {} |
||
+ | tpl_args._base_implicit_mods = {} |
||
+ | tpl_args._defined_implicit_mods = {} |
||
tpl_args._mods = {} |
tpl_args._mods = {} |
||
for _, k in ipairs({'', '_random'}) do |
for _, k in ipairs({'', '_random'}) do |
||
Line 7,917: | Line 2,320: | ||
tpl_args._errors = {} |
tpl_args._errors = {} |
||
− | + | h.process_arguments(tpl_args, frame, {'class_id'}) |
|
− | + | h.build_item_classes(tpl_args, frame) |
|
− | + | h.build_cargo_data(tpl_args, frame, c.item_classes) |
|
-- Using general purpose function to handle release and removal versions |
-- Using general purpose function to handle release and removal versions |
||
Line 7,925: | Line 2,328: | ||
-- Must validate some argument early. It is required for future things |
-- Must validate some argument early. It is required for future things |
||
− | + | h.process_arguments(tpl_args, frame, cfg.default_args) |
|
− | + | h.process_arguments(tpl_args, frame, c.item_classes[tpl_args.class_id].args) |
|
-- Base Item |
-- Base Item |
||
+ | h.process_base_item(tpl_args, frame) |
||
− | |||
− | core.process_base_item(tpl_args, frame) |
||
-- Prophecy special snowflake |
-- Prophecy special snowflake |
||
if tpl_args._flags.is_prophecy then |
if tpl_args._flags.is_prophecy then |
||
− | err = |
+ | err = h.process_arguments(tpl_args, frame, cfg.prophecy_args) |
if err then |
if err then |
||
return err |
return err |
||
end |
end |
||
− | |||
− | tpl_args.inventory_icon = string.format(i18n.inventory_icon, 'Prophecy') |
||
end |
end |
||
-- Mods |
-- Mods |
||
− | |||
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 = |
+ | success = h.validate_mod(tpl_args, frame, {key=k, i=i}) |
i = i + 1 |
i = i + 1 |
||
end |
end |
||
end |
end |
||
− | + | h.process_mods(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 |
||
Line 7,963: | Line 2,362: | ||
stat.avg = stat.value |
stat.avg = stat.value |
||
end |
end |
||
− | + | core.stats_update(tpl_args, stat.id, stat, nil, '_stats') |
|
− | + | core.stats_update(tpl_args, stat.id, stat, nil, '_explicit_stats') |
|
end |
end |
||
Line 7,992: | Line 2,391: | ||
-- Handle extra stats (for gems) |
-- Handle extra stats (for gems) |
||
− | if |
+ | if cfg.class_groups.gems.keys[tpl_args.class_id] then |
m_skill._skill(tpl_args, frame) |
m_skill._skill(tpl_args, frame) |
||
end |
end |
||
Line 8,072: | Line 2,471: | ||
-- 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( |
+ | 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 |
||
Line 8,080: | Line 2,479: | ||
end |
end |
||
− | for short_key, range_data in pairs( |
+ | 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 |
||
Line 8,087: | Line 2,486: | ||
-- calculate and handle weapon dps |
-- calculate and handle weapon dps |
||
− | if |
+ | if cfg.class_groups.weapons.keys[tpl_args.class_id] then |
for _, data in ipairs(core.dps_map) do |
for _, data in ipairs(core.dps_map) do |
||
local damage = { |
local damage = { |
||
Line 8,096: | Line 2,495: | ||
for var_type, value in pairs(damage) do |
for var_type, value in pairs(damage) do |
||
-- covers the min/max/avg range |
-- covers the min/max/avg range |
||
− | for short_key, range_data in pairs( |
+ | for short_key, range_data in pairs(c.range_map) do |
value[short_key] = 0 |
value[short_key] = 0 |
||
for _, damage_key in ipairs(data.damage_args) do |
for _, damage_key in ipairs(data.damage_args) do |
||
Line 8,105: | Line 2,504: | ||
local value = {} |
local value = {} |
||
− | for short_key, range_data in pairs( |
+ | 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)] |
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 |
value[short_key] = result |
||
Line 8,118: | Line 2,517: | ||
-- late processing |
-- late processing |
||
− | + | h.process_arguments(tpl_args, frame, cfg.late_args) -- General late args |
|
− | + | h.process_arguments(tpl_args, frame, c.item_classes[tpl_args.class_id].late_args) -- Class-specific late args |
|
-- Handle upgrade from restrictions/info |
-- Handle upgrade from restrictions/info |
||
− | + | h.process_upgraded_from(tpl_args, frame) |
|
− | |||
-- Quest reward info |
-- Quest reward info |
||
− | + | h.process_quest_rewards(tpl_args, frame) |
|
-- ------------------------------------------------------------------------ |
-- ------------------------------------------------------------------------ |
||
Line 8,132: | Line 2,530: | ||
-- ------------------------------------------------------------------------ |
-- ------------------------------------------------------------------------ |
||
-- Store the infobox so it can be accessed with ease on other pages |
-- Store the infobox so it can be accessed with ease on other pages |
||
− | tpl_args.html = tostring( |
+ | tpl_args.html = tostring(h.make_main_container(tpl_args, frame, 'inline')) |
− | local container = |
+ | local container = h.make_main_container(tpl_args, frame, 'infobox') |
if tpl_args.inventory_icon ~= nil and tpl_args.class_id ~= 'DivinationCard' then |
if tpl_args.inventory_icon ~= nil and tpl_args.class_id ~= 'DivinationCard' then |
||
− | container:wikitext(string.format('[[%s|%sx%spx]]', tpl_args.inventory_icon, |
+ | container: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 |
end |
||
Line 8,146: | Line 2,544: | ||
:attr( 'class', 'item-box -' .. tpl_args.frame_type) |
: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) |
|
-- |
-- |
||
Line 8,187: | Line 2,585: | ||
end |
end |
||
− | if tpl_args.rarity_id ~= 'normal |
+ | 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 |
||
Line 8,207: | Line 2,605: | ||
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 |
||
Line 8,253: | Line 2,655: | ||
-- ------------------------------------------------------------------------ |
-- ------------------------------------------------------------------------ |
||
-- Map argument values for cargo storage |
-- Map argument values for cargo storage |
||
− | for _, table_name in ipairs( |
+ | for _, table_name in ipairs(c.item_classes[tpl_args.class_id].tables) do |
tpl_args._subobjects[table_name] = { |
tpl_args._subobjects[table_name] = { |
||
_table = table_name, |
_table = table_name, |
||
Line 8,318: | Line 2,720: | ||
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. |
||
Line 8,345: | Line 2,749: | ||
if #results == 0 then |
if #results == 0 then |
||
− | error( |
+ | error(i18n.errors.no_results_found) |
end |
end |
||
Line 8,355: | Line 2,759: | ||
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 = { |
||
− | 'Item classes', |
||
− | 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 |
Revision as of 18:50, 19 June 2021
This is the module sandbox page for Module:Item2 (diff). See also the companion subpage for test cases (run). |
This Lua module is used on a very large number of pages. To avoid large-scale disruption and unnecessary server load, any changes to this module should first be tested in its /sandbox or /testcases subpages. The tested changes can then be added to this page in one single edit. Please consider discussing any changes on the talk page before implementing them. |
This module depends on the following other modules: |
The item module provides functionality for various item-related templates.
Overview
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 templates
Module:Item2
All templates defined in Module:Item2:
Module:Item table
All templates defined in Module:Item table:
- {{Item table}}
- {{Query base items}}
- {{Query unique items}}
- {{Item unique versions}}
- {{Area item drops}}
- {{Item table/skill gems}}
- {{Map item drops}}
- {{Prophecy description}}
- {{Simple item list}}
Module:Item link
All templates defined in Module:Item link:
- {{Item link}}
- {{Il}}
- {{Item icon link}}
Module:Item acquisition
- {{Item acquisition}}
Editors can experiment in this module's sandbox and testcases pages.
Please add categories to the /doc subpage. Subpages of this module.
-------------------------------------------------------------------------------
--
-- 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
-- maybe smw
local getArgs = require('Module:Arguments').getArgs
local m_util = require('Module:Util')
local m_cargo = require('Module:Cargo')
local m_skill = require('Module:Skill')
local m_area = require('Module:Area')
local m_game = mw.loadData('Module:Game')
-- Should we use the sandbox version of our submodules?
local use_sandbox = m_util.misc.maybe_sandbox()
-- Lazy loading
local f_item_link -- require('Module:Item link').item_link
local f_process_upgraded_from -- require('Module:Item2/upgrade').process_upgraded_from
local f_build_cargo_data -- require('Module:Item2/cargo').build_cargo_data
-- 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')
local c = {}
c.item_classes = {}
-- ----------------------------------------------------------------------------
-- Helper functions
-- ----------------------------------------------------------------------------
local h = {}
function h.debug(tpl_args, func)
if tpl_args.debug == nil then
return
end
func()
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
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)
for _, k in ipairs(params) do
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 c.item_classes[tpl_args.class_id].defaults ~= nil and c.item_classes[tpl_args.class_id].defaults[k] ~= nil then
tpl_args[k] = c.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
-- add defaults from class specifics and class groups
function h.build_item_classes(tpl_args, frame)
core.map.class.func(tpl_args, frame)
c.item_classes[tpl_args.class_id] = {
tables = {},
args = {},
late_args = {},
defaults = {},
}
for _, table_name in ipairs(cfg.tables) do
table.insert(c.item_classes[tpl_args.class_id].tables, table_name)
end
local item_classes_extend = {'tables', 'args', 'late_args'}
for _, row in pairs(cfg.class_groups) do
for class, _ in pairs(row.keys) do
if class == tpl_args.class_id then
for _, k in ipairs(item_classes_extend) do
if row[k] ~= nil then
for _, value in ipairs(row[k]) do
table.insert(c.item_classes[tpl_args.class_id][k], value)
end
end
end
break
end
end
end
local class_specifics = cfg.class_specifics[tpl_args.class_id]
if class_specifics then
for _, k in ipairs(item_classes_extend) do
if class_specifics[k] ~= nil then
for _, value in ipairs(class_specifics[k]) do
table.insert(c.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
c.item_classes[tpl_args.class_id].defaults[key] = value
end
end
end
end
function h.process_mods(tpl_args, frame)
-- 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._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[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 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
function h.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(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(c.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(
c.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
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)]
-- 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
function h.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
-- Lazy loading for Module:Item2/cargo
function h.build_cargo_data(tpl_args, frame, item_classes)
if not f_build_cargo_data then
f_build_cargo_data = use_sandbox and require('Module:Item2/cargo/sandbox').build_cargo_data or require('Module:Item2/cargo').build_cargo_data
end
return f_build_cargo_data(tpl_args, frame, item_classes)
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
--
-- 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
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.args_present(...)
local args = {...}
return function (tpl_args)
for _, k in ipairs(args) do
if tpl_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.args_present('cosmetic_type'),
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.args_present('gem_tags'),
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.args_present('support_gem_letter_html'),
func = core.factory.infobox_line{
parts = {
{
key = 'support_gem_letter_html',
},
},
fmt = i18n.tooltips.support_icon,
},
},
{
show = h.factory.args_present('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,
},
},
-- TODO: gem level here. Maybe put max level here?
{
-- TODO: Rework for 3.14.0 skill cost and reservation changes
show = true,
func = core.factory.infobox_line{
type = 'gem',
parts = {
{
key = 'mana_cost',
hide_default = 100,
fmt = function (tpl_args, frame)
if tpl_args.has_percentage_mana_cost then
return '%i%%'
else
return '%i'
end
end,
inline = function (tpl_args, frame)
if tpl_args.has_reservation_mana_cost then
return i18n.tooltips.mana_reserved
else
return i18n.tooltips.mana_cost
end
end,
},
{
key = 'life_cost',
hide_default = 100,
fmt = '%i',
inline = function (tpl_args, frame)
return i18n.tooltips.life_cost
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%%',
},
},
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 = h.factory.args_present('cast_time'),
func = 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 = i18n.tooltips.cast_time,
},
},
{
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%%',
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%%',
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%%',
},
},
fmt = i18n.tooltips.damage_effectiveness,
},
},
{
show = h.factory.args_present('projectile_speed'),
func = core.factory.infobox_line{
parts = {
{
key = 'projectile_speed',
},
},
fmt = i18n.tooltips.projectile_speed,
},
},
-- Quality is before item stats, but after gem stuff and item class
{
show = h.factory.args_present('quality'),
func = core.factory.infobox_line{
parts = {
{
key = 'quality',
fmt = '+%i%%',
color = 'mod',
hide_default = 0,
},
},
fmt = i18n.tooltips.quality,
},
},
-- Weapon only
{
show = h.factory.args_present('physical_damage_html'),
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.args_present('chaos_damage_html'),
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.args_present('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.args_present('attack_speed_html'),
func = core.factory.infobox_line{
parts = {
{
key = 'attack_speed_html',
fmt = '%s',
},
},
fmt = i18n.tooltips.attacks_per_second,
},
},
{
show = h.factory.args_present('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.args_present('map_area_level'),
func = core.factory.infobox_line{
parts = {
{
key = 'map_area_level',
fmt = '%i',
},
},
fmt = i18n.tooltips.map_level,
},
},
{
show = h.factory.args_present('map_tier'),
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.args_present('jewel_radius_html'),
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.args_present('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.args_present('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.args_present('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.args_present('buff_stat_text'),
func = core.factory.infobox_line{
parts = {
{
key = 'buff_stat_text',
color = 'mod',
},
},
},
},
-- armor
{
show = h.factory.args_present('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.args_present('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.args_present('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.args_present('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.args_present('movement_speed'),
func = core.factory.infobox_line{
parts = {
{
key = 'movement_speed',
fmt = '%s%%',
hide_default = 0,
},
},
fmt = i18n.tooltips.movement_speed,
},
},
-- Amulet only
{
show = h.factory.args_present('talisman_tier'),
func = core.factory.infobox_line{
parts = {
{
key = 'talisman_tier',
fmt = '%i',
},
},
fmt = i18n.tooltips.talisman_tier,
},
},
-- Misc
{
show = h.factory.args_present('stack_size'),
func = core.factory.infobox_line{
parts = {
{
key = 'stack_size',
fmt = '%i',
hide_default = 1,
},
},
fmt = i18n.tooltips.stack_size,
},
},
-- Essence stuff
{
show = h.factory.args_present('essence_level'),
func = core.factory.infobox_line{
parts = {
{
key = 'essence_level',
fmt = '%i',
},
},
fmt = i18n.tooltips.essence_level,
},
},
-- Blight items
{
show = h.factory.args_present('blight_item_tier'),
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.args_present('seed_tier'),
func = core.factory.infobox_line{
parts = {
{
key = 'seed_tier',
fmt = '%i',
},
},
fmt = i18n.tooltips.seed_tier,
},
},
{
show = h.factory.args_present('seed_tier'),
func = function (tpl_args, value)
return i18n.tooltips.seed_monster
end,
},
{
show = h.factory.args_present('seed_type_html'),
func = core.factory.infobox_line{
parts = {
{
key = 'seed_type_html',
fmt = '%s',
},
},
fmt = i18n.tooltips.seed_lifeforce_gained,
},
},
{
show = h.factory.args_present('seed_growth_cycles'),
func = core.factory.infobox_line{
parts = {
{
key = 'seed_growth_cycles',
fmt = '%s',
},
},
fmt = i18n.tooltips.seed_growth_cycles,
},
},
-- Harvest plant boosters
-- TODO: Remaining enhancements
{
show = h.factory.args_present('plant_booster_radius'),
func = core.factory.infobox_line{
parts = {
{
key = 'plant_booster_radius',
fmt = '%s',
},
},
fmt = i18n.tooltips.radius,
},
},
{
show = h.factory.args_present('heist_required_npcs'),
func = core.factory.infobox_line{
parts = {
{
key = 'heist_required_npcs',
fmt = '%s',
},
},
fmt = i18n.tooltips.heist_required_npc,
},
},
},
-- Requirements
{
-- TODO: i18n Master name?
{
show = h.factory.args_present('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
{
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.args_present('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.args_present('gem_description'),
func = h.factory.display_raw_value('gem_description'),
},
},
-- Gem Quality Stats
{
class = 'tc -mod',
{
show = h.factory.args_present('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)
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.args_present('experience'),
func = core.factory.infobox_line{
parts = {
{
key = 'experience',
fmt = '%i',
},
},
},
},
},]]--
-- Harvest seeds (lower section)
{
class = 'tc -mod',
{
show = h.factory.args_present('seed_consumed_wild_lifeforce_percentage'),
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.args_present('seed_consumed_vivid_lifeforce_percentage'),
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.args_present('seed_consumed_primal_lifeforce_percentage'),
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.args_present('seed_required_nearby_seed_tier', 'seed_type_html', 'seed_required_nearby_seed_amount'),
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.args_present('seed_effect'),
func = h.factory.display_raw_value('seed_effect'),
},
},
-- Description (currency, doodads)
{
class = 'tc -mod',
{
show = h.factory.args_present('description'),
func = h.factory.display_raw_value('description'),
},
--[[{
show = h.factory.args_present('plant_booster_additional_crafting_options'),
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.args_present('plant_booster_extra_chances'),
func = core.factory.infobox_line{
parts = {
{
key = 'plant_booster_extra_chances',
fmt = '%s%%',
},
},
fmt = i18n.tooltips.plant_booster_extra_chances,
},
},
{
show = h.factory.args_present('plant_booster_lifeforce'),
func = core.factory.infobox_line{
parts = {
{
key = 'plant_booster_lifeforce',
fmt = '%s%%',
},
},
fmt = i18n.tooltips.plant_booster_lifeforce,
},
},]]
},
{
class = 'tc -crafted',
{
show = h.factory.args_present('incubator_effect'),
func = h.factory.display_raw_value('incubator_effect'),
},
},
-- Variations (for doodads)
{
class = 'tc -mod',
{
show = h.factory.args_present('variation_count'),
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.args_present('flavour_text'),
func = h.factory.display_raw_value('flavour_text'),
},
},
-- Prophecy text
{
class = 'tc -value',
{
show = h.factory.args_present('prediction_text'),
func = h.factory.display_raw_value('prediction_text'),
},
},
-- Can not be traded or modified
{
class = 'tc -canttradeormodify',
{
show = h.factory.args_present('cannot_be_traded_or_modified'),
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.args_present('help_text'),
func = h.factory.display_raw_value('help_text'),
},
},
-- Cost (i.e. vendor costs)
{
--class = '',
{
show = h.factory.args_present('master_favour_cost'),
func = core.factory.infobox_line{
parts = {
{
key = 'master_favour_cost',
color = 'currency',
},
},
fmt = i18n.tooltips.favour_cost,
},
},
{
show = h.factory.args_present('seal_cost'),
func = core.factory.infobox_line{
parts = {
{
key = 'seal_cost',
fmt = function (tpl_args, frame, value)
return '%dx ' .. h.item_link{metadata_id='Metadata/Items/Currency/CurrencySilverCoin', html=''}
end,
color = 'currency',
},
},
fmt = i18n.tooltips.seal_cost,
},
},
},
}
--
-- 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.args_present('atlas_connections'),
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
},
},
-- Drop info
{
heading = i18n.tooltips.drop_restrictions,
class = '',
{
show = h.factory.args_present('drop_enabled'),
func = core.factory.infobox_line{
parts = {
{
key = 'drop_level',
fmt = '%i',
},
{
key = 'drop_level_maximum',
fmt = '%i',
hide_default = 100,
},
},
sep = ' / ',
fmt = i18n.tooltips.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.args_present('drop_leagues'),
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.args_present('drop_areas_html'),
func = h.factory.display_raw_value('drop_areas_html'),
},
{
show = h.factory.args_present('drop_text'),
func = h.factory.display_raw_value('drop_text'),
},
},
{
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,
},
},
{
heading = i18n.tooltips.sell_price,
{
show = h.factory.args_present('sell_price_order'),
func = function(tpl_args, frame)
local out = {}
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
return table.concat(out, '<br />')
end,
},
},
-- Damage per second
{
heading = i18n.tooltips.damage_per_second,
-- Autoinsert here from dps map
},
{
heading = i18n.tooltips.misc,
{
show = h.factory.args_present('class'),
func = core.factory.infobox_line{
parts = {
{
key = 'class',
fmt = '%s',
},
},
fmt = i18n.tooltips.item_class,
},
},
{
show = h.factory.args_present('metadata_id'),
func = core.factory.infobox_line{
parts = {
{
key = 'metadata_id',
fmt = '%s',
truncate = true,
},
},
fmt = i18n.tooltips.metadata_id,
},
},
},
}
for i, data in ipairs(core.dps_map) do
table.insert(c.extra_display_groups[4], {
show = h.factory.args_present(data.name .. '_html'),
func = core.factory.infobox_line{
parts = {
{
key = data.name .. '_html',
inline = data.label_infobox .. ': %s',
fmt = '%s',
-- the html already contains the colour
color = false,
},
},
},
})
if i == 5 then
table.insert(c.extra_display_groups[4], {
show = function (tpl_args, frame)
return tpl_args.elemental_dps_html ~= nil or tpl_args.poison_dps_html ~= nil
end,
func = function (tpl_args, frame)
return ''
end,
})
elseif i == 7 then
table.insert(c.extra_display_groups[4], {
show = h.factory.args_present('dps_html'),
func = function (tpl_args, frame)
return ''
end,
})
end
end
-- ----------------------------------------------------------------------------
-- Exported functions
-- ----------------------------------------------------------------------------
local p = {}
--
-- Template:Item
--
function p.item(frame)
local t = os.clock()
local tpl_args = getArgs(frame, {
parentFirst = true
})
frame = m_util.misc.get_frame(frame)
--
-- Shared args
--
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 = {}
h.process_arguments(tpl_args, frame, {'class_id'})
h.build_item_classes(tpl_args, frame)
h.build_cargo_data(tpl_args, frame, c.item_classes)
-- 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, cfg.default_args)
h.process_arguments(tpl_args, frame, c.item_classes[tpl_args.class_id].args)
-- Base Item
h.process_base_item(tpl_args, frame)
-- Prophecy special snowflake
if tpl_args._flags.is_prophecy then
err = h.process_arguments(tpl_args, frame, cfg.prophecy_args)
if err then
return err
end
end
-- Mods
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
h.process_mods(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
m_skill._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
-- calculate and handle weapon dps
if cfg.class_groups.weapons.keys[tpl_args.class_id] then
for _, data in ipairs(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, data.name, data.field, value, data.html_fmt_options or {})
end
end
end
-- late processing
h.process_arguments(tpl_args, frame, cfg.late_args) -- General late args
h.process_arguments(tpl_args, frame, c.item_classes[tpl_args.class_id].late_args) -- Class-specific late args
-- Handle upgrade from restrictions/info
h.process_upgraded_from(tpl_args, frame)
-- Quest reward info
h.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: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
-- ------------------------------------------------------------------------
-- Category handling
-- ------------------------------------------------------------------------
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
-- TODO: add maintenance categories
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
out = out .. m_util.misc.add_category(cats, {ingore_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 .. m_area.query_area_info{cats=yes, where=string.format('areas.id="%s"', query_id)}
end
-- ------------------------------------------------------------------------
-- Store cargo data
-- ------------------------------------------------------------------------
-- Map argument values for cargo storage
for _, table_name in ipairs(c.item_classes[tpl_args.class_id].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.logObject(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 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
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)))
end
end
end
-- Don't actually save 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.logObject(table.concat(tpl_args._errors, '\n'))
end
if tpl_args.test then
tpl_args.out = out
return tpl_args
else
mw.logObject(os.clock() - t)
return out
end
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