Melvor Idle

Module:Items/UseTables: Difference between revisions

Module Discussion

Module:Items/UseTables (view source)

Revision as of 19:20, 6 September 2024

3,779 bytes added ,  6 September 2024
_getItemUses: Ensure 'All skills' is displayed before any skills
(more right-aligning)
(_getItemUses: Ensure 'All skills' is displayed before any skills)
(57 intermediate revisions by 7 users not shown)
Line 1: Line 1:
local p = {}
local p = {}
local MonsterData = mw.loadData('Module:Monsters/data')
local ItemData = mw.loadData('Module:Items/data')
local SkillData = mw.loadData('Module:Skills/data')


local Constants = require('Module:Constants')
local Constants = require('Module:Constants')
local Common = require('Module:Common')
local Shared = require('Module:Shared')
local Shared = require('Module:Shared')
local GameData = require('Module:GameData')
local SkillData = GameData.skillData
local Modifiers = require('Module:Modifiers')
local Skills = require('Module:Skills')
local Magic = require('Module:Magic')
local Magic = require('Module:Magic')
local Areas = require('Module:CombatAreas')
local Areas = require('Module:CombatAreas')
Line 13: Line 14:
local Agility = require('Module:Skills/Agility')
local Agility = require('Module:Skills/Agility')
local Shop = require('Module:Shop')
local Shop = require('Module:Shop')
 
local Num = require('Module:Number')


--Brute forcing some item uses to make things easier
--Brute forcing some item uses to make things easier
local itemUseArray = {
local itemUseArray = {
  Agility = {},
Agility = {},
  Attack = {},
Astrology = {'melvorF:Stardust', 'melvorF:Golden_Stardust', 'melvorItA:Abyssal_Stardust'},
  Combat = {'Gold Emerald Ring'},
Archaeology = {},
  Cooking = {'Cooking Gloves', 'Crown of Rhaelyx'},
Attack = {},
  Crafting = {'Crown of Rhaelyx'},
Cartography = {},
  Defence = {},
Combat = {'melvorF:Gold_Emerald_Ring', 'melvorD:Obsidian_Cape', 'melvorF:Throwing_Power_Gloves'},
  Farming = {'Compost', 'Weird Gloop', 'Bob's Rake'},
Cooking = {'melvorD:Cooking_Gloves'},
  Firemaking = {'Crown of Rhaelyx'},
Crafting = {'melvorItA:Abyssal_Crafting_Gloves'},
  Fishing = {'Amulet of Fishing', 'Message in a Bottle'},
Defence = {},
  Fletching = {'Crown of Rhaelyx'},
Farming = {'melvorD:Compost', 'melvorD:Weird_Gloop', 'melvorItA:Abyssal_Compost', 'melvorD:Bobs_Rake'},
  Herblore = {'Crown of Rhaelyx'},
Firemaking = {'melvorItA:Abyssal_Firemaking_Gloves'},
  Hitpoints = {},
Fishing = {'melvorD:Message_In_A_Bottle', 'melvorD:Barbarian_Gloves'},
  Magic = {},
Fletching = {'melvorItA:Abyssal_Fletching_Gloves'},
  Mining = {'Mining Gloves', 'Gem Gloves'},
Harvesting = {'melvorItA:Abyssal_Harvesting_Gloves'},
  Prayer = {},
Herblore = {'melvorItA:Abyssal_Herblore_Gloves'},
  Ranged = {},
Hitpoints = {},
  Runecrafting = {'Crown of Rhaelyx'},
Magic = {},
  Slayer = {},
Mining = {'melvorD:Mining_Gloves', 'melvorD:Gem_Gloves', 'melvorItA:Abyssal_Mining_Gloves'},
  Smithing = {'Smithing Gloves', 'Crown of Rhaelyx'},
Prayer = {},
  Strength = {},
Ranged = {},
  Summoning = {'Crown of Rhaelyx'},
Runecrafting = {'melvorItA:Abyssal_Runecrafting_Gloves'},
  Thieving = {'Chapeau Noir', 'Thieving Gloves', 'Gloves of Silence'},
Slayer = {},
  Woodcutting = {},
Smithing = {'melvorD:Smithing_Gloves', 'melvorItA:Abyssal_Smithing_Gloves'},
  }
Smithing = {},
local potionUseArray = {
Strength = {},
  [0] = 'Combat',
Summoning = {},
  [1] = 'Combat',
Thieving = {'melvorF:Thieving_Gloves'},
  [2] = 'Combat',
Township = {},
  [3] = 'Combat',
Woodcutting = {},
  [4] = 'Combat',
}
  [5] = 'Combat',
 
  [6] = 'Combat',
-- List of modifier IDs which, if present on an item and not specific to any
  [7] = 'Woodcutting',
-- particular skill, indicate that the item applies to all skills
  [8] = 'Fishing',
local allSkillModIDs = {
  [9] = 'Firemaking',
-- Skill XP
  [10] = 'Cooking',
'skillXP',
  [11] = 'Mining',
'nonCombatSkillXP',
  [12] = 'Smithing',
'abyssalSkillXP',
  [13] = 'Thieving',
-- Mastery
  [14] = 'Farming',
'flatMasteryTokens',
  [15] = 'Fletching',
'xpFromMasteryTokens',
  [16] = 'Crafting',
'masteryPoolCap',
  [17] = 'Runecrafting',
'masteryXP',
  [18] = 'Herblore',
'masteryPoolProgress',
  [19] = 'Combat',
-- Resource preservation
  [20] = 'Combat',
'bypassGlobalPreservationChance',
  [21] = 'Combat',
'skillPreservationChance',
  [22] = 'Combat',
'skillPreservationCap',
  [23] = 'Combat',
-- Other preservation (consumables, summons, potion charges)
  [24] = 'Agility',
'consumablePreservationChance',
  [25] = 'Summoning'
'summoningChargePreservationChance',
'potionChargePreservationChance',
-- Item doubling
'globalItemDoublingChance',
-- Resource quantity
'flatBasePrimaryProductQuantity',
'basePrimaryProductQuantity',
'flatBaseRandomProductQuantity',
'flatAdditionalSkillItem',
'flatAdditionalPrimaryProductQuantity',
-- Cost reduction
'skillCostReduction',
-- Off item chance
'offItemChance'
}
}


function p._getItemUses(item, asList, addCategories)
local function allSkillModCriteriaFromIDs(modIDs)
  local useArray = {}
local modIDsWithProps = {}
  local categoryArray = {}
for i, modID in ipairs(allSkillModIDs) do
  local chr = asList and '* ' or ''
table.insert(modIDsWithProps, {
  --Another fun one. This time getting all the different possible ways an item can be used
["id"] = modID,
["type"] = 'id',
["props"] = {
["skillID"] = 'nil',
["modType"] = 'pos'
}
})
end
return Modifiers.getMatchCriteriaFromIDs(modIDsWithProps)
end


  --Before anything else, if this is a potion add it to the appropriate override section
local allSkillModCriteria = allSkillModCriteriaFromIDs(allSkillModIDs)
  if item.masteryID ~= nil and item.masteryID[1] == 19 then
    table.insert(itemUseArray[potionUseArray[item.masteryID[2]]], item.name)
  end


  --If the item has any modifiers that affect a given skill, add it to those lists
function p._getItemUses(item, asList, addCategories)
  if item.modifiers ~= nil then
-- Another fun one. This time getting all the different possible ways an item can be used
    local skillArray = Constants.getModifierSkills(item.modifiers)
local categoryArray = {}
    for i, skillName in Shared.skpairs(skillArray) do
local skillUses = {}
      table.insert(itemUseArray[skillName], item.name)
local otherUses = {}
    end
local otherUseText = {
  end
["Combat"] = Icons.Icon({'Combat'}),
["Upgrade"] = '[[Upgrading Items]]',
["Food"] = '[[Food]]',
["Chest"] = '[[Chest|Can Be Opened]]',
["Mastery"] = Icons.Icon({'Mastery'}),
["AllSkills"] = 'All skills',
["AltMagic"] = Icons.Icon({'Alt. Magic', type='skill'}),
["ChargeStone"] = 'Powering ' .. Icons.Icon({'Crown of Rhaelyx', type='item'}),
["Shop"] = Icons.Icon({'Shop'}),
["TownshipTask"] = Icons.Icon({'Tasks', type='township'})
}


  --First things added to the list are non-skill things that are easy to check
local addUse = function(useName)
  if Items.hasCombatStats(item) or Shared.contains(itemUseArray.Combat, item.name) then
local skillID = Constants.getSkillID(useName)
    table.insert(useArray, chr..Icons.Icon({'Combat'}))
if skillID == nil then
  end
-- May have been passed a skill ID instead
local skillName = Constants.getSkillName(useName)
if skillName ~= nil then
skillID = useName
skillUses[skillID] = skillName
end
else
skillUses[skillID] = useName
end


  if item.healsFor ~= nil then
if skillID == nil and not otherUses[useName] then
    table.insert(categoryArray, '[[Category:Food Items]]')
otherUses[useName] = true
    table.insert(useArray, chr..'[[Food]]')
end
  end
end
local hasUse = function(useName)
local skillID = Constants.getSkillID(useName)
if skillID == nil and Constants.getSkillName(useName) ~= nil then
skillID = useName
end
if skillID ~= nil then
return (skillUses[skillID] ~= nil) or false
else
return otherUses[useName] or false
end
end


  if item.dropTable ~= nil then
-- Check for any overrides within itemUseArray
    table.insert(categoryArray, '[[Category:Openable Items]]')
for useName, itemList in pairs(itemUseArray) do
    table.insert(useArray, chr..'[[Chest Drop Tables|Can Be Opened]]')
if Shared.contains(itemList, item.id) then
  end
addUse(useName)
end
end


  -- Check if the item is an entry requirement for any Slayer area
-- If the item has any modifiers that affect a given skill, add it to those tables
  local isSlayerAreaReq = false
-- Added special handling for Mastery Tokens since they were being incorrectly flagged as usable for all skills
  if item.isEquipment then
if item.modifiers ~= nil then
    local slayerAreas = Areas.getAreas(function(area) return area.type == 'slayer' end)
if item.modifiers.masteryToken ~= nil then
    for i, area in pairs(slayerAreas) do
-- Mastery tokens
      if area.entryRequirements ~= nil and type(area.entryRequirements) == 'table' then
addUse('Mastery')
        for j, req in pairs(area.entryRequirements) do
else
          if req.type == "SlayerItem" and req.itemID == item.id then
local modsAllSkills = Modifiers.getMatchingModifiers(item.modifiers, allSkillModCriteria)
            isSlayerAreaReq = true
if not Shared.tableIsEmpty(modsAllSkills.matched) then
            break
addUse('AllSkills')
          end
else
        end
local skillArray = Modifiers.getModifierSkills(item.modifiers)
        if isSlayerAreaReq then break end
for i, skillName in ipairs(skillArray) do
      end
addUse(skillName)
    end
end
  end
end
end
if item.modifiers.thievingStealth ~= nil then
addUse('melvorD:Thieving')
end
end


  --Next, upgrading, crafting, herblore, fletching, and runecrafting since we have to sift through other items for these
--First things added to the list are non-skill things that are easy to check
  local canUpgrade = false
if not hasUse('Combat') and (Items.hasCombatStats(item) or item.specialAttacks ~= nil) then
  local canCraft = false
addUse('Combat')
  local canFletch = false
end
  local canRunecraft = false
  local canHerblore = false
  local canAgile = false
  local canSummon = false


  if item.trimmedItemID ~= nil then
-- Check if the item is an entry requirement for any Slayer area
    canUpgrade = true
if not hasUse('Slayer') and (item.validSlots ~= nil or item.occupiesSlots ~= nil or item.equipmentStats ~= nil) then
  end
local slayerAreas = Areas.getAreas(function(area) return area.type == 'slayerArea' and type(area.entryRequirements) == 'table' end)
for i, area in ipairs(slayerAreas) do
for j, req in ipairs(area.entryRequirements) do
if req.type == "SlayerItem" and req.itemID == item.id then
addUse('Slayer')
break
end
end
if hasUse('Slayer') then
break
end
end
end


  for i, item2 in pairs(ItemData.Items) do
-- Is the item a cost in an upgrade?
    if item2.itemsRequired ~= nil then
for i, upgrade in ipairs(GameData.rawData.itemUpgrades) do
      for j, req in pairs(item2.itemsRequired) do
for j, itemCost in ipairs(upgrade.itemCosts) do
        if req[1] == item.id then
if itemCost.id == item.id then
          canUpgrade = true
addUse('Upgrade')
          break
table.insert(categoryArray, '[[Category:Upgradeable Items]]')
        end
break
      end
end
    end
end
if hasUse('Upgrade') then
break
end
end


    if item2.craftReq ~= nil then
if item.healsFor ~= nil then
      for j, req in pairs(item2.craftReq) do
table.insert(categoryArray, '[[Category:Food Items]]')
        if req.id == item.id then
addUse('Food')
          canCraft = true
end
          break
        end
      end
    end
    if item2.fletchReq ~= nil then
      for j, req in pairs(item2.fletchReq) do
        if req.id == item.id then
          canFletch = true
          break
        end
      end
    end
    if item2.runecraftReq ~= nil then
      for j, req in pairs(item2.runecraftReq) do
        if req.id == item.id then
          canRunecraft = true
          break
        end
      end
    end


    if item2.herbloreReq ~= nil then
if item.dropTable ~= nil then
      for j, req in pairs(item2.herbloreReq) do
table.insert(categoryArray, '[[Category:Openable Items]]')
        if req.id == item.id then
addUse('Chest')
          canHerblore = true
end
          break
        end
      end
    end


    if item2.summoningReq ~= nil then
-- Cooking, Smithing, Fletching, Crafting, Runecrafting, Herblore
      for j, reqSet in pairs(item2.summoningReq) do
-- All have somewhat consistent recipe data structures
        for k, req in pairs(reqSet) do
local recipeSkillIDs = {
          if req.id == item.id then
'melvorD:Cooking',
            canSummon = true
'melvorD:Smithing',
            break
'melvorD:Fletching',
          end
'melvorD:Crafting',
        end
'melvorD:Runecrafting',
      end
'melvorD:Herblore'
    end
}
  end
for i, recipeSkillID in ipairs(recipeSkillIDs) do
if not hasUse(recipeSkillID) then
local _, localSkillID = GameData.getLocalID(recipeSkillID)
-- Iterate over all recipes for the current skill
for j, recipe in ipairs(SkillData[localSkillID].recipes) do
for k, itemCost in ipairs(recipe.itemCosts) do
if itemCost.id == item.id then
addUse(recipeSkillID)
break
end
end
-- Some items (such as Arrow shafts) have multiple recipes
if not hasUse(recipeSkillID) and type(recipe.alternativeCosts) == 'table' then
for k, altCost in ipairs(recipe.alternativeCosts) do
for m, itemCost in ipairs(altCost.itemCosts) do
if itemCost.id == item.id then
addUse(recipeSkillID)
break
end
end
if hasUse(recipeSkillID) then
break
end
end
end
if hasUse(recipeSkillID) then
break
end
end
end
end


  --Check if Agility applies here
-- Firemaking
  canAgile = Shared.tableCount(Agility.getObstaclesForItem(item.id)) > 0
if not hasUse('melvorD:Firemaking') then
for i, recipe in ipairs(SkillData.Firemaking.logs) do
if recipe.logID == item.id then
addUse('melvorD:Firemaking')
break
end
end
end


  --Agility
-- Farming
  if canAgile or Shared.contains(itemUseArray.Agility, item.name) then
if not hasUse('melvorD:Farming') then
    table.insert(useArray, chr..Icons.Icon({'Agility', type='skill'}))
for i, recipe in ipairs(SkillData.Farming.recipes) do
  end
if recipe.seedCost.id == item.id then
  --Cooking
addUse('melvorD:Farming')
  if item.cookedItemID ~= nil or Shared.contains(itemUseArray.Cooking, item.name) then
break
    table.insert(useArray, chr..Icons.Icon({'Cooking', type='skill'}))
end
  end
end
  --Crafting
end
  if canCraft or Shared.contains(itemUseArray.Crafting, item.name) then
    table.insert(useArray, chr..Icons.Icon({'Crafting', type='skill'}))
  end
  --Farming
  if item.grownItemID ~= nil or Shared.contains(itemUseArray.Farming, item.name) then
    table.insert(useArray, chr..Icons.Icon({'Farming', type='skill'}))
  end
  --Firemaking
  if item.firemakingID ~= nil or Shared.contains(itemUseArray.Firemaking, item.name) then
    table.insert(useArray, chr..Icons.Icon({'Firemaking', type='skill'}))
  end
  --Fishing
  if Shared.contains(itemUseArray.Fishing, item.name) then
    table.insert(useArray, chr..Icons.Icon({'Fishing', type='skill'}))
  end
  --Fletching
  if canFletch or Shared.contains(itemUseArray.Fletching, item.name) then
    table.insert(useArray, chr..Icons.Icon({'Fletching', type='skill'}))
  end
  --Herblore
  if canHerblore or Shared.contains(itemUseArray.Herblore, item.name) then
    table.insert(useArray, chr..Icons.Icon({'Herblore', type='skill'}))
  end
  --Mining
  if Shared.contains(itemUseArray.Mining, item.name) then
    table.insert(useArray, chr..Icons.Icon({'Mining', type='skill'}))
  end
  --Prayer
  if item.prayerPoints ~= nil or (Shared.contains(itemUseArray.Prayer, item.name) and not Shared.contains(itemUseArray.Combat, item.name)) then
    if item.prayerPoints ~= nil then table.insert(categoryArray, '[[Category:Buriable Items]]') end
    table.insert(useArray, chr..Icons.Icon({'Prayer', type='skill'}))
  end
  --Runecrafting
  if canRunecraft or Shared.contains(itemUseArray.Runecrafting, item.name) then
    table.insert(useArray, chr..Icons.Icon({'Runecrafting', type='skill'}))
  end
  --Slayer
  if isSlayerAreaReq or Shared.contains(itemUseArray.Slayer, item.name) then
    table.insert(useArray, chr..Icons.Icon({'Slayer', type='skill'}))
  end
  --Smithing
  if item.type == 'Bar' or item.type == 'Ore' or Shared.contains(itemUseArray.Smithing, item.name) then
    table.insert(useArray, chr..Icons.Icon({'Smithing', type='skill'}))
  end
  --Summoning
  if canSummon or (item.type == 'Shard' and item.category == 'Summoning') or item.type == 'Familiar' or Shared.contains(itemUseArray.Summoning, item.name) then
    table.insert(useArray, chr..Icons.Icon({'Summoning', type='skill'}))
  end
  --Thieving
  if Shared.contains(itemUseArray.Thieving, item.name) then
    table.insert(useArray, chr..Icons.Icon({'Thieving', type='skill'}))
  end
  --Woodcutting
  if Shared.contains(itemUseArray.Woodcutting, item.name) then
    table.insert(useArray, chr..Icons.Icon({'Woodcutting', type='skill'}))
  end


  --Other odds and ends:
-- Agility
if not hasUse('melvorD:Agility') and not Shared.tableIsEmpty(Agility.getObstaclesForItem(item.id)) then
addUse('melvorD:Agility')
end


  --Mastery Tokens are tied to 'Mastery'
-- Summoning
  if item.isToken and item.skill ~= nil then
if not hasUse('melvorD:Summoning') then
    table.insert(useArray, chr..Icons.Icon({'Mastery'}))
for i, recipe in ipairs(SkillData.Summoning.recipes) do
  end
-- Tablets & Non-shard items
if recipe.productID == item.id or Shared.contains(recipe.nonShardItemCosts, item.id) then
addUse('melvorD:Summoning')
break
else
-- Shards
for j, itemCost in ipairs(recipe.itemCosts) do
if itemCost.id == item.id then
addUse('melvorD:Summoning')
break
end
end
end
end
end


  --Skillcapes are tied to the appropriate skill
-- Prayer
  --Except Max Skillcape, which is tied to all skills. (And so is the Signet Ring)
if item.prayerPoints ~= nil then
  --And combat skillcapes, since combat skills don't get special treatment
table.insert(categoryArray, '[[Category:Buriable Items]]')
if not hasUse('melvorD:Prayer') then
addUse('melvorD:Prayer')
end
elseif item.soulPoints ~= nil then
table.insert(categoryArray, '[[Category:Releasable Items]]')
if not hasUse('melvorD:Prayer') then
addUse('melvorD:Prayer')
end
end


  local ignoreCapes = {'Ranged Skillcape', 'Attack Skillcape', 'Strength Skillcape', 'Hitpoints Skillcape', 'Defence Skillcape'}
-- Magic
  if Shared.contains({'Max Skillcape', 'Aorpheat's Signet Ring', 'Cape of Completion'}, item.name) then
if not (hasUse('Magic') and hasUse('AltMagic')) then
    table.insert(useArray, chr..'All skills')
-- First check if the item its self is used in any spells
  elseif item.name == 'Magic Skillcape' then
local spellList = Magic.getSpellsUsingItem(item.id, true)
    table.insert(useArray, chr..Icons.Icon({'Magic', type='skill'}))
for i, spell in ipairs(spellList) do
    table.insert(useArray, chr..Icons.Icon({'Alt. Magic', type='skill'}))
local useKey = (spell.type == 'altMagic' and 'AltMagic' or 'Magic')
  elseif Shared.contains(item.name, 'Skillcape') and not Shared.contains(ignoreCapes, item.name) then
if not hasUse(useKey) then
    local skillName = Shared.splitString(item.name, ' ')[1]
addUse(useKey)
    --Avoiding double-listing the same skill twice
end
    if not Shared.contains(itemUseArray[skillName], item.name) then
end
      table.insert(useArray, chr..Icons.Icon({skillName, type='skill'}))
-- Check if the item provides runes, if it does check where they are used also
    end
if item.providedRunes ~= nil then
  end
for i, rune in ipairs(item.providedRunes) do
if hasUse('Magic') and hasUse('AltMagic') then
break
else
local spellList = Magic.getSpellsUsingItem(rune.id, false)
for j, spell in ipairs(spellList) do
local useKey = (spell.type == 'altMagic' and 'AltMagic' or 'Magic')
if not hasUse(useKey) then
addUse(useKey)
end
end
end
end
end
end


  if Shared.contains(item.name, 'Skillcape') or item.name == 'Cape of Completion' then table.insert(categoryArray, '[[Category:Skillcapes]]') end
-- Other odds and ends:


  --Special note for Charge Stone of Rhaelyx
-- Skillcapes are tied to the appropriate skill
  if item.name == 'Charge Stone of Rhaelyx' then
-- Except Maximum Skillcape, which is tied to all skills. (And so is the Signet Ring)
    table.insert(useArray, chr..'Powering '..Icons.Icon({'Crown of Rhaelyx', type='item'}))
-- And combat skillcapes, since combat skills don't get special treatment
  end
if item.tier == 'Skillcape' then
local ignoreCapes = {
'melvorD:Attack_Skillcape',
'melvorD:Strength_Skillcape',
'melvorD:Defence_Skillcape',
'melvorD:Hitpoints_Skillcape',
'melvorF:Ranged_Skillcape',
'melvorTotH:Superior_Attack_Skillcape',
'melvorTotH:Superior_Strength_Skillcape',
'melvorTotH:Superior_Defence_Skillcape',
'melvorTotH:Superior_Hitpoints_Skillcape',
'melvorTotH:Superior_Ranged_Skillcape',
}
local allCapes = {
'melvorF:Max_Skillcape',
'melvorF:Cape_of_Completion',
'melvorTotH:Superior_Max_Skillcape',
'melvorTotH:Superior_Cape_Of_Completion',
}
if Shared.contains(allCapes, item.id) then
addUse('AllSkills')
elseif Shared.contains({'melvorF:Magic_Skillcape', 'melvorTotH:Superior_Magic_Skillcape'}, item.id) then
addUse('melvorD:Magic')
addUse('AltMagic')
elseif not Shared.contains(ignoreCapes, item.id) then
local splitName = Shared.splitString(item.name, ' ')
local skillName = (splitName[1] == 'Superior' and splitName[2]) or splitName[1]
addUse(skillName)
end
table.insert(categoryArray, '[[Category:Skillcapes]]')
end
--Special note for Charge Stone of Rhaelyx
if item.id == 'melvorD:Charge_Stone_of_Rhaelyx' then
addUse('ChargeStone')
end


  --Some items are needed to make shop purchases
--Some items are needed to make shop purchases
  local shopArray = Shop.getItemCostArray(item.id)
local shopArray = Shop.getItemCostArray(item.id)
  if Shared.tableCount(shopArray) > 0 then
if not Shared.tableIsEmpty(shopArray) then
    table.insert(useArray, chr..Icons.Icon({'Shop'}))
addUse('Shop')
  end
end


  if canUpgrade then
-- Township Tasks
    if item.canUpgrade or (item.type == 'Armour' and item.canUpgrade == nil) then
for _, task in ipairs(SkillData.Township.tasks) do
      table.insert(categoryArray, '[[Category:Upgradeable Items]]')
if task.goals.items ~= nil then -- Skip tasks with no items
    end
if GameData.getEntityByID(task.goals.items, item.id) then
    table.insert(useArray, chr..'[[Upgrading Items]]')
addUse('TownshipTask')
  end
break
end
end
end
-- Generate result text
local useArray = {}
local prefix, delim = asList and '* ' or '', asList and '\r\n' or '<br/>'
-- Always place 'All skills' use before any skills
if hasUse('AllSkills') then
table.insert(useArray, prefix .. (otherUseText.AllSkills or 'AllSkills'))
otherUses.AllSkills = nil
end
for skillID, skillName in Shared.spairs(skillUses, function(t, a, b) return t[a] < t[b] end) do
table.insert(useArray, prefix .. Icons.Icon({skillName, type='skill'}))
end
for use, _ in Shared.skpairs(otherUses) do
table.insert(useArray, prefix .. (otherUseText[use] or use))
end


  local resultPart = {}
return table.concat(useArray, delim) .. (addCategories and table.concat(categoryArray, '') or '')
  table.insert(resultPart, asList and table.concat(useArray,'\r\n') or table.concat(useArray, '<br/>'))
  if addCategories then table.insert(resultPart, table.concat(categoryArray, '')) end
  return table.concat(resultPart)
end
end


function p.getItemUses(frame)
function p.getItemUses(frame)
  local itemName = frame.args ~= nil and frame.args[1] or frame
local itemName = frame.args ~= nil and frame.args[1] or frame
  local item = Items.getItem(itemName)
local item = Items.getItem(itemName)
  local addCategories = false
local addCategories = false
  local asList = true
local asList = true
  if frame.args ~= nil then
if frame.args ~= nil then
    addCategories = frame.args.addCategories ~= nil and frame.args.addCategories ~= '' and frame.args.addCategories ~= 'false'
addCategories = frame.args.addCategories ~= nil and frame.args.addCategories ~= '' and frame.args.addCategories ~= 'false'
    asList = frame.args.addCategories == nil or frame.args.addCategories == '' or frame.args.addCategories == 'true'
asList = frame.args.addCategories == nil or frame.args.addCategories == '' or frame.args.addCategories == 'true'
  end
end
  if item == nil then
if item == nil then
    return "ERROR: No item named "..itemName.." exists in the data module"
return Shared.printError('No item named "' .. itemName .. '" exists in the data module')
  end
end


  return p._getItemUses(item, asList, addCategories)
return p._getItemUses(item, asList, addCategories)
end
end


function p._getItemUseTable(item)
function p._getItemUseTable(item)
  local useArray = {}
local useArray = {}
  local potTierMastery = {[0] = 0, [1] = 20, [2] = 50, [3] = 90}


  --First, loop through all items to find anything that can be made or upgraded into using our source
-- Loop through all upgrades to find anything that can be upgraded using our source
  for i, item2 in pairs(ItemData.Items) do
for i, upgrade in ipairs(GameData.rawData.itemUpgrades) do
    if item2.itemsRequired ~= nil then
for j, itemCost in ipairs(upgrade.itemCosts) do
      for j, req in pairs(item2.itemsRequired) do
if itemCost.id == item.id then
        if req[1] == item.id then
local rowReq = nil
          local mat = item2.itemsRequired
-- Potions do have upgrade requirements though
          local xp = 'N/A'
local upgradeItem = Items.getItemByID(upgrade.upgradedItemID)
          local rowReq = 'None'
if upgradeItem ~= nil and upgradeItem.charges ~= nil and upgradeItem.tier ~= nil then
          --Potions do have upgrade requirements though
local levelUnlock = GameData.getEntityByProperty(SkillData.Herblore.masteryLevelUnlocks, 'descriptionID', upgradeItem.tier + 1)
          if item2.potionTier ~= nil then
if levelUnlock ~= nil then
            rowReq = Icons._MasteryReq(item2.name, potTierMastery[item2.potionTier])
rowReq = Icons._MasteryReq(upgradeItem.name, levelUnlock.level)
          end
end
          table.insert(useArray, {item = item2, qty = 1, mats = mat, skill = 'Upgrade', req = rowReq, xp = xp, gp = item2.trimmedGPCost})
end
          break
table.insert(useArray, {item = {id = upgradeItem.id, name = upgradeItem.name}, qty = (upgrade.quantity or 1), mats = upgrade.itemCosts, skill = 'Upgrade', req = rowReq, xp = 'N/A', gp = upgrade.gpCost, sc = upgrade.scCost})
        end
end
      end
end
    end
end
    if item2.craftReq ~= nil then
      for j, req in pairs(item2.craftReq) do
        if req.id == item.id then
          local mat = item2.craftReq
          local xp = item2.craftingXP
          local rowReq = item2.craftingLevel
          local qty = item2.craftQty
          table.insert(useArray, {item = item2, qty = qty, mats = mat, skill = 'Crafting', req = rowReq, xp = xp})
          break
        end
      end
    end
    if item2.fletchReq ~= nil then
      for j, req in pairs(item2.fletchReq) do
        if req.id == item.id then
          local xp = item2.fletchingXP
          local rowReq = item2.fletchingLevel
          --Arrow Shafts are special and have to be treated specially
          local qty = item2.fletchQty
          local mat = item2.fletchReq
          if item2.name == 'Arrow Shafts' then
            mat = {{id = item.id, qty = 1}}
            qty =  qty + (qty * item.id)
          end
          table.insert(useArray, {item = item2, qty = qty, mats = mat, skill = 'Fletching', req = rowReq, xp = xp})
          break
        end
      end
    end
    if item2.smithReq ~= nil then
      for j, req in pairs(item2.smithReq) do
        if req.id == item.id then
          local mat = item2.smithReq
          local xp = item2.smithingXP
          local rowReq = item2.smithingLevel
          local qty = item2.smithingQty
          table.insert(useArray, {item = item2, qty = qty, mats = mat, skill = 'Smithing', req = rowReq, xp = xp})
          break
        end
      end
    end
    if item2.runecraftReq ~= nil then
      for j, req in pairs(item2.runecraftReq) do
        if req.id == item.id then
          local mat = item2.runecraftReq
          local xp = item2.runecraftingXP
          local rowReq = item2.runecraftingLevel
          local qty = item2.runecraftQty
          table.insert(useArray, {item = item2, qty = qty, mats = mat, skill = 'Runecrafting', req = rowReq, xp = xp})
          break
        end
      end
    end
    if item2.herbloreReq ~= nil then
      for j, req in pairs(item2.herbloreReq) do
        if req.id == item.id then
          local potionData = SkillData.Herblore.ItemData[item2.masteryID[2] + 1]
          local mat = item2.herbloreReq
          local xp = potionData.herbloreXP
          --Potions do have upgrade requirements though
          local rowReq = Icons._SkillReq('Herblore', potionData.herbloreLevel)
          local masteryLvl = potTierMastery[item2.potionTier]
          if masteryLvl > 0 then
            rowReq = rowReq..'<br/>'..Icons._MasteryReq(item2.name, masteryLvl)
          end
          local reqVal = potionData.herbloreLevel + (masteryLvl * 0.01)
          table.insert(useArray, {item = item2, qty = 1, mats = mat, skill = 'Herblore', reqVal = reqVal, req = rowReq, xp = xp})
          break
        end
      end
    end


    if item2.summoningReq ~= nil then
-- Cooking, Smithing, Fletching, Crafting, Runecrafting, Herblore
      for j, reqSet in pairs(item2.summoningReq) do
-- All have somewhat consistent recipe data structures
        for k, req in pairs(reqSet) do
local recipeSkillIDs = {
          if req.id == item.id then
'melvorD:Cooking',
            local mat = Shared.clone(reqSet)
'melvorD:Smithing',
            mat[k].qty = math.max(math.floor(1000 / math.max(item.sellsFor, 20)), 1)
'melvorD:Fletching',
            local xp = 5 + 2 * math.floor(item2.summoningLevel * 0.2)
'melvorD:Crafting',
            local rowReq = item2.summoningLevel
'melvorD:Runecrafting',
            table.insert(useArray, {item = item2, qty = 25, mats = mat, skill = 'Summoning', req = rowReq, xp = xp})
'melvorD:Herblore'
          end
}
        end
for i, recipeSkillID in ipairs(recipeSkillIDs) do
      end
local skillName = Constants.getSkillName(recipeSkillID)
    end
local _, localSkillID = GameData.getLocalID(recipeSkillID)
-- Iterate over all recipes for the current skill
for j, recipe in ipairs(SkillData[localSkillID].recipes) do
local costLists = {recipe.alternativeCosts or {}, {{["itemCosts"] = recipe.itemCosts}}}
for k, costList in pairs(costLists) do
for m, costDef in pairs(costList) do
for n, itemCost in ipairs(costDef.itemCosts) do
if itemCost.id == item.id then
local recipeItemIDs = nil
if recipeSkillID == 'melvorD:Herblore' then
recipeItemIDs = recipe.potionIDs
elseif recipeSkillID == 'melvorD:Cooking' then
recipeItemIDs = {recipe.productID, recipe.perfectCookID}
else
recipeItemIDs = {recipe.productID}
end
for o, recipeItemID in ipairs(recipeItemIDs) do
local recipeItem = Items.getItemByID(recipeItemID)
if recipeItem ~= nil then
local itemDef = {id = recipe.itemID, name = recipeItem.name}
local qty = (recipe.baseQuantity or 1) * (costDef.quantityMultiplier or 1)
local rowReq, isAbyssal = Skills.getRecipeLevelRealm(recipeSkillID, recipe)
local reqVal = nil
local xp = recipe.baseAbyssalExperience or recipe.baseExperience
if recipeSkillID == 'melvorD:Herblore' then
-- Herblore may also have a mastery requirement
local levelUnlock = GameData.getEntityByProperty(SkillData.Herblore.masteryLevelUnlocks, 'descriptionID', recipeItem.tier + 1)
if levelUnlock ~= nil and levelUnlock.level > 1 then
local masteryReq = Icons._MasteryReq(recipeItem.name, levelUnlock.level)
reqVal = rowReq + levelUnlock.level * 0.01
rowReq = Icons._SkillReq(skillName, rowReq, false, (isAbyssal and "melvorItA:Abyssal" or nil)) .. '<br/>' .. masteryReq
end
end
table.insert(useArray, {item = itemDef, qty = qty, mats = costDef.itemCosts, gp = recipe.gpCost, sc = recipe.scCost, skill = skillName, reqVal = reqVal, req = rowReq, isAbyssal = isAbyssal, xp = xp})
end
end
break
end
end
end
end
end
end


  end
-- Farming
  if item.grownItemID ~= nil then
for i, recipe in ipairs(SkillData.Farming.recipes) do
    local item2 = Items.getItemByID(item.grownItemID)
if recipe.seedCost.id == item.id then
    local mat = {{id = item.id, qty = item.seedsRequired}}
local product = Items.getItemByID(recipe.productId)
    local xp = item.farmingXP
local mat = {{id = recipe.seedCost.id, quantity = recipe.seedCost.quantity}}
    local rowReq = item.farmingLevel
local rowReq, isAbyssal = Skills.getRecipeLevelRealm('melvorD:Farming', recipe)
    local qty = 5
local category = GameData.getEntityByID(SkillData.Farming.categories, recipe.categoryID)
    table.insert(useArray, {item = item2, qty = qty, mats = mat, skill = 'Farming', req = rowReq, xp = xp})
local qty = 5 * category.harvestMultiplier
  end
local xp = recipe.baseAbyssalExperience or recipe.baseExperience
  if item.cookedItemID ~= nil then
table.insert(useArray, {item = {id = product.id, name = product.name}, qty = qty, mats = mat, skill = 'Farming', req = rowReq, isAbyssal = isAbyssal, xp = xp})
    local item2 = Items.getItemByID(item.cookedItemID)
end
    local mat = {{id = item.id, qty = 1}}
end
    local xp = item.cookingXP
    local rowReq = item.cookingLevel
    local qty = 1
    table.insert(useArray, {item = item2, qty = qty, mats = mat, skill = 'Cooking', req = rowReq, xp = xp})
  end
  if item.burntItemID ~= nil then
    local item2 = Items.getItemByID(item.burntItemID)
    local mat = {{id = item.id, qty = 1}}
    local xp = 1
    local rowReq = item.cookingLevel
    local qty = 1
    table.insert(useArray, {item = item2, qty = qty, mats = mat, skill = 'Cooking', req = rowReq, xp = xp})
  end


  --Handle shop purchases using Module:Shop
-- Agility
  local shopUses = Shop.getItemCostArray(item.id)
local obstacles = Agility.getObstaclesForItem(item.id)
  for i, purchase in Shared.skpairs(shopUses) do
for i, obstacle in ipairs(obstacles) do
    local rowReq = Shop.getRequirementString(purchase.unlockRequirements)
local itemCosts = {}
    local iconType = (purchase.contains.items ~= nil and Shared.tableCount(purchase.contains.items) > 0) and 'item' or 'upgrade'
for j, itemDef in ipairs(obstacle.itemCosts) do
    table.insert(useArray, {item = {name = purchase.name}, qty = 1, mats = purchase.cost.items, skill = 'Shop', req = rowReq, xp = 'N/A', gp = purchase.cost.gp, type = iconType})
table.insert(itemCosts, {id = itemDef.id, quantity = itemDef.quantity})
  end
end
local req = Agility._getObstacleRequirements(obstacle)
--local objType = (obstacle.category == nil and 'Pillar') or 'Obstacle'
table.insert(useArray, {item = {id = obstacle.id, name = obstacle.name}, qty = 1, mats = itemCosts, gp = obstacle.gpCost, sc = obstacle.scCost, skill = 'Agility', req = req, type = 'skill'})
end


  --Finally build the table using what we've learned
-- Summoning
  table.sort(useArray, function(a, b)
for i, recipe in ipairs(SkillData.Summoning.recipes) do
                        local aReqVal = a.reqVal ~= nil and a.reqVal or a.req
local recipeCost = 0
                        local bReqVal = b.reqVal ~= nil and b.reqVal or b.req
if recipe.abyssalLevel ~= nil then
                        if a.skill ~= b.skill then
recipeCost = SkillData.Summoning.recipeAPCost
                          return a.skill < b.skill
else
                        elseif type(aReqVal) ~= type(bReqVal) then
recipeCost = SkillData.Summoning.recipeGPCost
                          return tostring(aReqVal) < tostring(bReqVal)
end
                        elseif aReqVal ~= bReqVal then
local useShards = false
                          return aReqVal < bReqVal
local recipeItem = nil
                        else
for j, itemCost in ipairs(recipe.itemCosts) do
                          return a.item.name < b.item.name
if itemCost.id == item.id then
                        end end)
useShards = true
break
end
end
-- Non-shard items
-- Familiar recipes may also have a currency cost without any non-shard
-- items, so account for this with a dummy ID such that one iteration
-- of the below loop always occurs
local nonShardItemIDs = (Shared.tableIsEmpty(recipe.nonShardItemCosts) and {''} or recipe.nonShardItemCosts)
for j, nonShardItemID in ipairs(nonShardItemIDs) do
if useShards or nonShardItemID == item.id then
-- Item is used in this particular synergy recipe
if recipeItem == nil then
recipeItem = Items.getItemByID(recipe.productID)
end
local nonShardItem = Items.getItemByID(nonShardItemID)
local recipeCosts = Shared.clone(recipe.itemCosts)
local xp = recipe.baseAbyssalExperience or recipe.baseExperience
local req, isAbyssal = Skills.getRecipeLevelRealm('melvorD:Summoning', recipe)
local recipeCosts = {}
for k, itemCost in ipairs(recipe.itemCosts) do
table.insert(recipeCosts, {id = itemCost.id, quantity = itemCost.quantity})
end
if nonShardItem ~= nil then
-- Item ID can be nil for recipes such as Leprechaun or Cyclops
local itemValue = math.max(nonShardItem.sellsFor, 20)
local nonShardQty = math.max(1, math.ceil(recipeCost / itemValue))
table.insert(recipeCosts, {id = nonShardItemID, quantity = nonShardQty})
end
table.insert(useArray, {item = {id = recipeItem.id, name = recipeItem.name}, qty = recipe.baseQuantity, mats = recipeCosts, gp = recipe.gpCost, sc = recipe.scCost, skill = 'Summoning', req = req, isAbyssal = isAbyssal, xp = xp})
end
end
end


  local obstacles = Agility.getObstaclesForItem(item.id)
--Handle shop purchases using Module:Shop
local shopUses = Shop.getItemCostArray(item.id)
for i, shopUse in ipairs(shopUses) do
local purchase = shopUse.purchase
local rowReq = Shop.getRequirementString(purchase.purchaseRequirements)
local iconType = Common.getPurchaseIconType(purchase)
local gpCost = Shop.getCurrencyCostString(purchase.cost, 'gp')
local scCost = Shop.getCurrencyCostString(purchase.cost, 'slayerCoins')
local rcCost = Shop.getCurrencyCostString(purchase.cost, 'raidCoins')
table.insert(useArray, {item = {name = Shop._getPurchaseName(purchase)}, qty = 1, mats = purchase.cost.items, skill = 'Shop', req = rowReq, xp = 'N/A', gp = gpCost, sc = scCost, rc = rcCost, type = iconType})
end


  local spellUseTable = p._getSpellUseTable(item)
--Finally build the table using what we've learned
  local resultPart = {}
table.sort(useArray, function(a, b)
  if Shared.tableCount(useArray) == 0 and Shared.tableCount(obstacles) == 0 then
local aReqVal = a.reqVal ~= nil and a.reqVal or a.req
    if string.len(spellUseTable) > 0 then
local bReqVal = b.reqVal ~= nil and b.reqVal or b.req
      return '==Uses==\r\n==='..Icons.Icon({'Magic', type='skill', size='30'})..'===\r\n'..spellUseTable
if a.skill ~= b.skill then
    else
return a.skill < b.skill
      return ''
elseif type(aReqVal) ~= type(bReqVal) then
    end
return tostring(aReqVal) < tostring(bReqVal)
  end
elseif aReqVal ~= bReqVal then
  table.insert(resultPart, '{| class="wikitable sortable"')
return aReqVal < bReqVal
  table.insert(resultPart, '\r\n!colspan=2|Item Created!!Type!!Requirements!!XP!!Ingredients')
else
  for i, row in pairs(useArray) do
return a.item.name < b.item.name
    local qty = row.qty ~= nil and row.qty or 1
end
    local iconType = row.type ~= nil and row.type or 'item'
end)
    table.insert(resultPart, '\r\n|-\r\n|data-sort-value="'..row.item.name..'"|')
    table.insert(resultPart, Icons.Icon({row.item.name, type=iconType, notext=true, size=50})..'||')
    if qty > 1 then table.insert(resultPart, "'''"..qty.."x''' ") end
    table.insert(resultPart, '[['..row.item.name..']]')
    if row.skill == 'Upgrade' then
      table.insert(resultPart, '||data-sort-value="Upgrade"|[[Upgrading Items|Upgrade]]')
    elseif row.skill == 'Shop' then
      table.insert(resultPart, '||data-sort-value="Shop"|'..Icons.Icon({'Shop'}))
    else
      table.insert(resultPart, '||data-sort-value="'..row.skill..'"|'..Icons.Icon({row.skill, type='skill'}))
    end
    if type(row.req) == 'number' then
      table.insert(resultPart, '|| style="text-align:right" data-sort-value="'..row.req..'"|'..Icons._SkillReq(row.skill, row.req))
    elseif row.reqVal ~= nil then
      table.insert(resultPart, '|| style="text-align:right" data-sort-value="'..row.reqVal..'"|'..row.req)
    else
      table.insert(resultPart, '||'..row.req)
    end
    if type(row.xp) == 'string' then
      table.insert(resultPart, '||style="text-align:right" data-sort-value="0"|'..row.xp)
    else
      table.insert(resultPart, '||style="text-align:right" data-sort-value="'..row.xp..'"|'..row.xp..' '..Icons.Icon({row.skill, type='skill', notext=true})..' XP')
    end
    table.insert(resultPart, '||')
    for i, mat in Shared.skpairs(row.mats) do
      local matID = mat.id ~= nil and mat.id or mat[1]
      local matQty = mat.qty ~= nil and mat.qty or mat[2]
      local matText = ''


      if i > 1 then table.insert(resultPart, '<br/>') end
      if matID >= 0 then
        -- Item
        local matItem = Items.getItemByID(matID)
        if matItem == nil then
          matText = 'ERROR: Failed to find item with ID ' .. matID .. '[[Category:Pages with Script Errors]]'
        else
          matText = Icons.Icon({matItem.name, type='item', qty=matQty})
        end
      elseif matID == -4 then
        -- GP
        matText = Icons.GP(SkillData.Summoning.Settings.recipeGPCost)
      elseif matID == -5 then
        -- Slayer Coins
        matText = Icons.SC(SkillData.Summoning.Settings.recipeGPCost)
      else
        matText = 'ERROR: Unknown item ID: ' .. matID .. ' [[Category:Pages with Script Errors]]'
      end
      table.insert(resultPart, matText)
    end
    if row.gp ~= nil then table.insert(resultPart, '<br/>'..Icons.GP(row.gp)) end
  end


  --Agility obstacles are weird and get their own section
local resultPart = {}
  for i, obst in Shared.skpairs(obstacles) do
if not Shared.tableIsEmpty(useArray) then
    table.insert(resultPart, '\r\n|-\r\n|')
local typeTextList = {
    table.insert(resultPart, Icons.Icon({"Agility", type="skill", size="50", notext=true}))
["Shop"] = Icons.Icon({'Shop'}),
    table.insert(resultPart, '||[[Agility#Obstacles|'..obst.name..']]')
["Upgrade"] = '[[Upgrading Items|Upgrade]]'
    table.insert(resultPart, '||'..Icons.Icon({"Agility", type="skill"}))
}


    --Adding the requirements for the Agility Obstacle
-- Header
    local reqArray = {}
table.insert(resultPart, '{| class="wikitable stickyHeader sortable col-1-img"')
    if obst.category == nil then --nil category means this is a passive pillar
table.insert(resultPart, '\r\n|- class="headerRow-0"')
      table.insert(reqArray, Icons._SkillReq('Agility', 99))
table.insert(resultPart, '\r\n!colspan=2|Item Created!!Type!!Requirements!!XP!!Ingredients')
    elseif obst.category > 0 then --Otherwise it's category * 10
      table.insert(reqArray, Icons._SkillReq('Agility', obst.category * 10))
    end
    --Then the other skill levels if any are added
    if obst.requirements ~= nil and obst.requirements.skillLevel ~= nil then
      for j, req in Shared.skpairs(obst.requirements.skillLevel) do
        table.insert(reqArray, Icons._SkillReq(Constants.getSkillName(req[1]), req[2]))
      end
    end
    table.insert(resultPart, '||style="text-align:right"|'..table.concat(reqArray, '<br/>'))


    --Just including 'N/A' for XP since it doesn't really apply for Agility Obstacles
-- Rows
    table.insert(resultPart, '||style="text-align:right"|N/A')
for i, row in ipairs(useArray) do
 
local qty = row.qty ~= nil and row.qty or 1
    --Finally the cost
local iconType = row.type ~= nil and row.type or 'item'
    local cost = obst.cost
local iconName = row.item.name
    local costArray = {}
if row.skill == 'Agility' then
    if cost.gp ~= nil and cost.gp > 0 then
iconType = 'agility'
      table.insert(costArray, Icons.GP(cost.gp))
end
    end
local typeName = row.skill ~= nil and row.skill or ''
    if cost.slayerCoins ~= nil and cost.slayerCoins > 0 then
local typeText = typeTextList[typeName] or Icons.Icon({typeName, type='skill'}) or ''
      table.insert(costArray, Icons.SC(cost.slayerCoins))
local reqVal, reqText = row.reqVal, 'None'
    end
if type(row.req) == 'number' then
    for j, mat in Shared.skpairs(cost.items) do
reqVal = row.req
      local item = Items.getItemByID(mat[1])
reqText = Icons._SkillReq(typeName, row.req, false, (row.isAbyssal and "melvorItA:Abyssal" or nil))
      table.insert(costArray, Icons.Icon({item.name, type="item", qty=mat[2]}))
elseif type(row.req) == 'string' then
    end
reqText = row.req
 
end
    table.insert(resultPart, '||'..table.concat(costArray, '<br/>'))
local xpVal, xpText = 0, 'N/A'
 
if type(row.xp) == 'string' then
  end
xpText = row.xp
 
elseif type(row.xp) == 'number' then
  table.insert(resultPart, '\r\n|}')
xpVal = row.xp
  if string.len(spellUseTable) > 0 then
xpText = Num.formatnum(row.xp) .. ' ' .. Icons.Icon({typeName, type='skill', notext=true}) .. ' XP'
    table.insert(resultPart, '\r\n==='..Icons.Icon({'Magic', type='skill', size='30'})..'===\r\n'..spellUseTable)
end
  end
local matRow = {}
  return '==Uses==\r\n'..table.concat(resultPart)
if type(row.mats) == 'table' then
for j, itemCost in ipairs(row.mats) do
local matItemID = itemCost.id or itemCost[1] or -1
local matItem = Items.getItemByID(matItemID)
local matQty = itemCost.quantity or itemCost[2] or 1
if matItem == nil then
table.insert(matRow, Shared.printError('Failed to find item with ID "' .. itemCost.id .. '"'))
elseif type(matQty) == 'number' then
table.insert(matRow, Icons.Icon({matItem.name, type='item', qty=matQty}))
else
table.insert(matRow, Icons.Icon({matItem.name, type='item'}))
end
end
end
if row.gp ~= nil then
local gpText = nil
if type(row.gp) == 'number' and row.gp > 0 then
gpText = Icons._Currency('melvorD:GP', row.gp)
elseif type(row.gp) == 'string' then
gpText = row.gp
end
table.insert(matRow, gpText)
end
if row.sc ~= nil then
local scText = nil
if type(row.sc) == 'number' and row.sc > 0 then
scText = Icons._Currency('melvorD:SlayerCoins', row.sc)
elseif type(row.sc) == 'string' then
scText = row.sc
end
table.insert(matRow, scText)
end
if row.rc ~= nil then
local rcText = nil
if type(row.rc) == 'number' and row.rc > 0 then
rcText = Icons._Currency('melvorD:RaidCoins', row.rc)
elseif type(row.rc) == 'string' then
rcText = row.rc
end
table.insert(matRow, rcText)
end
-- Item created
table.insert(resultPart, '\r\n|-\r\n|data-sort-value="' .. row.item.name .. '"| ')
table.insert(resultPart, Icons.Icon({iconName, row.item.name, type=iconType, notext=true, size=50}))
table.insert(resultPart, '\r\n| ')
if qty > 1 then
table.insert(resultPart, "'''" .. Num.formatnum(qty) .. "x''' ")
end
table.insert(resultPart, Icons.Icon({iconName, row.item.name, type=iconType, noicon=true}))
-- Type
table.insert(resultPart, '\r\n|data-sort-value="' .. typeName .. '"| ' .. typeText)
-- Requirements
table.insert(resultPart, '\r\n|style="text-align:right;"')
if row.reqVal ~= nil then
table.insert(resultPart, ' data-sort-value="' .. reqVal .. '"')
end
table.insert(resultPart, '| ' .. reqText)
-- XP
table.insert(resultPart, '\r\n|style="text-align:right;" data-sort-value="' .. xpVal .. '"| ' .. xpText)
-- Ingredients
table.insert(resultPart, '\r\n| ' .. table.concat(matRow, '<br/>'))
end
table.insert(resultPart, '\r\n|}')
end
local spellUseTable = p._getSpellUseTable(item)
if spellUseTable ~= nil and spellUseTable ~= '' then
table.insert(resultPart, '\r\n===' .. Icons.Icon({'Magic', type='skill', size=30}) .. '===\r\n' .. spellUseTable)
end
if Shared.tableIsEmpty(resultPart) then
return ''
else
return '==Uses==\r\n' .. table.concat(resultPart)
end
end
end


function p.getItemUseTable(frame)
function p.getItemUseTable(frame)
  local itemName = frame.args ~= nil and frame.args[1] or frame
local itemName = frame.args ~= nil and frame.args[1] or frame
  local item = Items.getItem(itemName)
local item = Items.getItem(itemName)
  if item == nil then
if item == nil then
    return "ERROR: No item named "..itemName.." exists in the data module"
return Shared.printError('No item named "' .. itemName .. '" exists in the data module')
  end
end


  return p._getItemUseTable(item)
return p._getItemUseTable(item)
end
end


function p._getSpellUseTable(item)
function p._getSpellUseTable(item)
  local spellList = Magic.getSpellsForRune(item.id)
local spellList = Magic.getSpellsUsingItem(item.id, true)
  --Bail immediately if no spells are found
--Bail immediately if no spells are found
  if Shared.tableCount(spellList) == 0 then
if Shared.tableIsEmpty(spellList) then
    return ''
return ''
  end
end
--Adding a check for if the Items column is needed
local hasItems = false
for i, spell in pairs(spellList) do
if Magic._getSpellItems(spell) ~= '' then
hasItems = true
break
end
end


  local resultPart = {}
local resultPart = {}
  table.insert(resultPart, '{|class="wikitable sortable"\r\n!colspan="2"|Spell')
table.insert(resultPart, '{|class="wikitable sortable"\r\n!colspan="2"|Spell')
  table.insert(resultPart, '!!Requirements')
table.insert(resultPart, '!!Requirements')
  table.insert(resultPart, '!!Type!!style="width:275px"|Description')
table.insert(resultPart, '!!Type!!style="width:275px"|Description')
  table.insert(resultPart, '!!Runes')
table.insert(resultPart, '!!Runes')
  for i, spell in pairs(spellList) do
if hasItems then
    local rowPart = {}
table.insert(resultPart, '!!Item Cost')
    table.insert(rowPart, '\r\n|-\r\n|data-sort-value="'..spell.name..'"|')
end
    local iconType = (spell.type == 'Auroras' and 'aurora') or (spell.type == 'Curses' and 'curse') or 'spell'
    table.insert(rowPart, Icons.Icon({spell.name, type=iconType, notext=true, size=50}))
    table.insert(rowPart, '||[['..spell.name..']]')
for i, spell in pairs(spellList) do
    table.insert(rowPart, '||data-sort-value="'..spell.magicLevelRequired..'"|'..Icons._SkillReq('Magic', spell.magicLevelRequired))
local spellBook = Magic.getSpellBookFromSpell(spell)
    --Handle required items/dungeon clears
local rowPart = {}
    if spell.requiredItem ~= nil and spell.requiredItem >= 0 then
table.insert(rowPart, '\r\n|-\r\n|data-sort-value="'..spell.name..'"|')
      local reqItem = Items.getItemByID(spell.requiredItem)
local iconType = Magic._getSpellIconType(spell)
      table.insert(rowPart, '<br/>'..Icons.Icon({reqItem.name, type='item', notext=true})..' equipped')
table.insert(rowPart, Icons.Icon({spell.name, type=iconType, notext=true, size=50}))
    end
table.insert(rowPart, '||'..Icons.Icon({spell.name, type=iconType, noicon=true}))
    if spell.requiredDungeonCompletion ~= nil then
table.insert(rowPart, '||data-sort-value="'..Skills.getRecipeLevel('melvorD:Summoning', spell)..'"|'..Magic._getSpellRequirements(spell))
      local dung = Areas.getAreaByID('dungeon', spell.requiredDungeonCompletion[1])
table.insert(rowPart, '||data-sort-value="'.. spellBook.id ..'"|')
      table.insert(rowPart, '<br/>'..Icons.Icon({dung.name, type='dungeon', notext=true, qty=spell.requiredDungeonCompletion[2]})..' Clears')
table.insert(rowPart, Magic.getSpellTypeLink(spellBook.id))
    end
table.insert(rowPart, '||'..Magic._getSpellStat(spell, 'description'))
    table.insert(rowPart, '||data-sort-value="'..Magic.getSpellTypeIndex(spell.type)..'"|')
table.insert(rowPart, '||style="text-align:center"|')
    table.insert(rowPart, Magic.getSpellTypeLink(spell.type))
table.insert(rowPart, Magic._getSpellRunes(spell))
    table.insert(rowPart, '||'..Magic._getSpellStat(spell, 'description'))
if hasItems then
    table.insert(rowPart, '||style="text-align:center"|')
table.insert(rowPart, '||style="text-align:right"|')
    table.insert(rowPart, Magic._getSpellRunes(spell))
table.insert(rowPart, Magic._getSpellItems(spell))
    table.insert(resultPart, table.concat(rowPart))
end
  end
table.insert(resultPart, table.concat(rowPart))
  --Add the table end and add the table to the result string
end
  table.insert(resultPart, '\r\n|}')
--Add the table end and add the table to the result string
  return table.concat(resultPart)
table.insert(resultPart, '\r\n|}')
return table.concat(resultPart)
end
end


function p.getSpellUseTable(frame)
function p.getSpellUseTable(frame)
  local itemName = frame.args ~= nil and frame.args[1] or frame
local itemName = frame.args ~= nil and frame.args[1] or frame
  local item = Items.getItem(itemName)
local item = Items.getItem(itemName)
  if item == nil then
if item == nil then
    return "ERROR: No item named "..itemName.." exists in the data module"
return Shared.printError('No item named "' .. itemName .. '" exists in the data module')
  end
end
 
return p._getSpellUseTable(item)
end


  return p._getSpellUseTable(item)
--[==[
-- Uncomment this block and execute 'p.test()' within the debug console
-- to test after making changes
function p.test()
local checkItems = {
'Gold Bar',
'Raw Shrimp',
'Coal Ore',
'Rune Platebody',
'Arrow Shafts',
'Garum Seeds',
'Rune Essence',
'Runite Bar',
'Water Rune',
'Steam Rune',
'Controlled Heat Potion II',
'Wolf',
'Cyclops',
'Leprechaun',
'Redwood Logs',
'Carrot Cake',
'Carrot Cake (Perfect)',
'Mantalyme Herb',
'Carrot',
'Topaz',
'Rune Essence',
'Infernal Claw',
'Chapeau Noir',
'Stardust',
'Rope',
'Ancient Ring of Mastery',
'Mysterious Stone',
'Mastery Token (Cooking)',
'Gem Gloves',
'Basic Bag',
'Bird Nest',
'Abyssal Stone',
'Withered Ash',
'Wrath Rune'
}
local checkFuncs = {
p.getItemUses,
p.getItemUseTable
}
local errCount = 0
for i, item in ipairs(checkItems) do
local param = {args={item}}
mw.log('=' .. item .. '=')
for j, func in ipairs(checkFuncs) do
local callSuccess, retVal = pcall(func, param)
if not callSuccess then
errCount = errCount + 1
mw.log('Error with item "' .. item .. '": ' .. retVal)
else
mw.log(retVal)
end
end
end
if errCount == 0 then
mw.log('Test successful')
else
mw.log('Test failed with ' .. errCount .. ' failures')
end
end
end
--]==]


return p
return p
Retrieved from "https://testwiki.melvoridle.com/w/Special:MobileDiff/46480...82451"