Module:Items/UseTables: Difference between revisions

local ItemData = mw.loadData('Module:Items/data')

local SkillData = mw.loadData('Module:Skills/data')

local Shared = require('Module:Shared')

local Magic = require('Module:Magic')

local Items = require('Module:Items')

local Icons = require('Module:Icons')

--Brute forcing some item uses to make things easier

local itemUseArray = {

   Combat = {},

   Cooking = {'Cooking Gloves', 'Crown of Rhaelyx'},

   Slayer = {},

   Smithing = {'Smithing Gloves', 'Crown of Rhaelyx'},

   Woodcutting = {},

   }

   [22] = 'Combat',

   [23] = 'Combat',

}

   local useArray = {}

   local categoryArray = {}

   --Another fun one. This time getting all the different possible ways an item can be used

       --table.insert(categoryArray, '[[Category:'..Items.getEquipmentSlotName(item.equipmentSlot)..' Slot Items]]')  

     end

   end

   if item.healsFor ~= nil then

     table.insert(categoryArray, '[[Category:Food Items]]')

   end

   if item.dropTable ~= nil then

     table.insert(categoryArray, '[[Category:Openable Items]]')

   end

   local canRunecraft = false

   local canHerblore = false

   if item.trimmedItemID ~= nil then

     canUpgrade = true

     end

   end

   if canUpgrade then

     if item.canUpgrade or (item.type == 'Armour' and item.canUpgrade == nil) then

       table.insert(categoryArray, '[[Category:Upgradeable Items]]')

     end

   end

   --Cooking

   if item.cookedItemID ~= nil or Shared.contains(itemUseArray.Cooking, item.name) then

   end

   --Crafting

   if canCraft or Shared.contains(itemUseArray.Crafting, item.name) then

   end

   --Farming

   if item.grownItemID ~= nil or Shared.contains(itemUseArray.Farming, item.name) then

   end

   --Firemaking

   end

   --Fishing

   if Shared.contains(itemUseArray.Fishing, item.name) then

   end

   --Fletching

   if canFletch or Shared.contains(itemUseArray.Fletching, item.name) then

   end

   --Herblore

   if canHerblore or Shared.contains(itemUseArray.Herblore, item.name) then

   end

   --Mining

   if Shared.contains(itemUseArray.Mining, item.name) then

   end

   --Prayer

   if item.prayerPoints ~= nil or Shared.contains(itemUseArray.Prayer, item.name) then

     if item.prayerPoints ~= nil then table.insert(categoryArray, '[[Category:Buriable Items]]') end

   end

   --Runecrafting

   if canRunecraft or Shared.contains(itemUseArray.Runecrafting, item.name) then

   end

   --Slayer

   if item.slayerCost ~= nil or Shared.contains(itemUseArray.Slayer, item.name) then

   end

   --Smithing

   if item.type == 'Bar' or item.type == 'Ore' or Shared.contains(itemUseArray.Smithing, item.name) then

   end

   --Thieving

   if Shared.contains(itemUseArray.Thieving, item.name) then

   end

   --Woodcutting

   if Shared.contains(itemUseArray.Woodcutting, item.name) then

   end

    

   --Other odds and ends:

   --Mastery Tokens are tied to 'Mastery'

   if item.type == 'Token' then

   end

   local ignoreCapes = {'Ranged Skillcape', 'Attack Skillcape', 'Strength Skillcape', 'Hitpoints Skillcape', 'Defence Skillcape'}

   if item.name == 'Max Skillcape' or item.name == 'Aorpheat's Signet Ring' or item.name == 'Cape of Completion' then

   elseif item.name == 'Magic Skillcape' then

   elseif Shared.contains(item.name, 'Skillcape') and not Shared.contains(ignoreCapes, item.name) then

     local skillName = Shared.splitString(item.name, ' ')[1]

   end

   --Special note for Charge Stone of Rhaelyx

   if item.name == 'Charge Stone of Rhaelyx' then

   end

   if addCategories then result = result..table.concat(categoryArray, '') end

   return result

   local item = Items.getItem(itemName)

   local addCategories = false

   if frame.args ~= nil then  

     addCategories = frame.args.addCategories ~= nil and frame.args.addCategories ~= '' and frame.args.addCategories ~= 'false'

   end

   if item == nil then

   end

end

           end

           table.insert(useArray, {item = item2, qty = 1, mats = mat, skill = 'Upgrade', req = rowReq, xp = xp, gp = item2.trimmedGPCost})

           break

         end

     local qty = 1

     table.insert(useArray, {item = item2, qty = qty, mats = mat, skill = 'Cooking', req = rowReq, xp = xp})

   end

                           return a.item.name < b.item.name

                         end end)

   local spellUseTable = p._getSpellUseTable(item)

   local result = ''

     if string.len(spellUseTable) > 0 then

       return '==Uses==\r\n==='..Icons.Icon({'Magic', type='skill', size='30'})..'===\r\n'..spellUseTable

   for i, row in pairs(useArray) do

     local qty = row.qty ~= nil and row.qty or 1

     result = result..'\r\n|-\r\n|data-sort-value="'..row.item.name..'"|'

     if qty > 1 then result = result.."'''"..qty.."x''' " end

     result = result..'[['..row.item.name..']]'

       result = result..'||data-sort-value="Upgrade"|[[Upgrading Items|Upgrade]]'

     elseif row.skill == 'Shop' then

     else

       result = result..'||data-sort-value="'..row.skill..'"|'..Icons.Icon({row.skill, type='skill'})

     end

     result = result..'||'

       local matID = mat.id ~= nil and mat.id or mat[1]

       local matQty = mat.qty ~= nil and mat.qty or mat[2]

       matItem = Items.getItemByID(matID)

       result = result..Icons.Icon({matItem.name, type='item', qty=matQty})

     end

     if row.gp ~= nil then result = result..'<br/>'..Icons.GP(row.gp) end

   end

   local result = '{|class="wikitable sortable"\r\n!colspan="2"|Spell'

   result = result..'!!Type!!style="width:275px"|Description'

   result = result..'!!Runes'

       rowTxt = rowTxt..Icons.Icon({spell.name, type='spell', notext=true, size=50})

     end

     rowTxt = rowTxt..'||data-sort-value="'..spell.magicLevelRequired..'"|'..Icons._SkillReq('Magic', spell.magicLevelRequired)

     --Handle required items/dungeon clears

     end

     rowTxt = rowTxt..'||style="text-align:center"|'

     result = result..rowTxt

   end