17,030
edits
(_getItemCategories: Include additional double loot modifiers) |
(Clone Module:Items/UseTables) |
||
Line 1: | Line 1: | ||
local p = {} | local p = {} | ||
local ItemData = mw.loadData('Module: | 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 Shared = require('Module:Shared') | local Shared = require('Module:Shared') | ||
local Magic = require('Module:Magic') | |||
local Areas = require('Module:CombatAreas') | |||
local Items = require('Module:Items') | |||
local Icons = require('Module:Icons') | local Icons = require('Module:Icons') | ||
local Agility = require('Module:Skills/Agility') | |||
local Shop = require('Module:Shop') | |||
--Brute forcing some item uses to make things easier | |||
local itemUseArray = { | |||
Agility = {}, | |||
Attack = {}, | |||
Combat = {'Gold Emerald Ring'}, | |||
Cooking = {'Cooking Gloves', 'Crown of Rhaelyx'}, | |||
Crafting = {'Crown of Rhaelyx'}, | |||
Defence = {}, | |||
Farming = {'Compost', 'Weird Gloop', 'Bob's Rake'}, | |||
Firemaking = {'Crown of Rhaelyx'}, | |||
Fishing = {'Amulet of Fishing', 'Message in a Bottle'}, | |||
Fletching = {'Crown of Rhaelyx'}, | |||
Herblore = {'Crown of Rhaelyx'}, | |||
Hitpoints = {}, | |||
Magic = {}, | |||
Mining = {'Mining Gloves', 'Gem Gloves'}, | |||
Prayer = {}, | |||
Ranged = {}, | |||
Runecrafting = {'Crown of Rhaelyx'}, | |||
Slayer = {}, | |||
Smithing = {'Smithing Gloves', 'Crown of Rhaelyx'}, | |||
Strength = {}, | |||
Summoning = {'Crown of Rhaelyx'}, | |||
Thieving = {'Chapeau Noir', 'Thieving Gloves', 'Gloves of Silence'}, | |||
Woodcutting = {}, | |||
} | |||
local potionUseArray = { | |||
[0] = 'Combat', | |||
[1] = 'Combat', | |||
[2] = 'Combat', | |||
[3] = 'Combat', | |||
[4] = 'Combat', | |||
[5] = 'Combat', | |||
[6] = 'Combat', | |||
[7] = 'Woodcutting', | |||
[8] = 'Fishing', | |||
[9] = 'Firemaking', | |||
[10] = 'Cooking', | |||
[11] = 'Mining', | |||
[12] = 'Smithing', | |||
[13] = 'Thieving', | |||
[14] = 'Farming', | |||
[15] = 'Fletching', | |||
[16] = 'Crafting', | |||
[17] = 'Runecrafting', | |||
[18] = 'Herblore', | |||
[19] = 'Combat', | |||
[20] = 'Combat', | |||
[21] = 'Combat', | |||
[22] = 'Combat', | |||
[23] = 'Combat', | |||
[24] = 'Agility', | |||
[25] = 'Summoning' | |||
} | |||
p. | function p._getItemUses(item, asList, addCategories) | ||
local useArray = {} | |||
local categoryArray = {} | |||
local chr = asList and '* ' or '' | |||
--Another fun one. This time getting all the different possible ways an item can be used | |||
--Before anything else, if this is a potion add it to the appropriate override section | |||
-- | 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 | |||
if item.modifiers ~= nil then | |||
local skillArray = Constants.getModifierSkills(item.modifiers) | |||
table.insert( | for i, skillName in Shared.skpairs(skillArray) do | ||
table.insert(itemUseArray[skillName], item.name) | |||
end | end | ||
end | end | ||
--First things added to the list are non-skill things that are easy to check | |||
if Items.hasCombatStats(item) or Shared.contains(itemUseArray.Combat, item.name) then | |||
table.insert(useArray, chr..Icons.Icon({'Combat'})) | |||
end | end | ||
if item.healsFor ~= nil then | |||
table.insert(categoryArray, '[[Category:Food Items]]') | |||
table.insert(useArray, chr..'[[Food]]') | |||
end | end | ||
if item.dropTable ~= nil then | |||
table.insert(categoryArray, '[[Category:Openable Items]]') | |||
table.insert(useArray, chr..'[[Chest Drop Tables|Can Be Opened]]') | |||
end | end | ||
-- Check if the item is an entry requirement for any Slayer area | |||
local | local isSlayerAreaReq = false | ||
if item.isEquipment then | |||
local slayerAreas = Areas.getAreas(function(area) return area.type == 'slayer' end) | |||
for i, area in pairs(slayerAreas) do | |||
if area.entryRequirements ~= nil and type(area.entryRequirements) == 'table' then | |||
for j, req in pairs(area.entryRequirements) do | |||
if req.type == "SlayerItem" and req.itemID == item.id then | |||
isSlayerAreaReq = true | |||
break | |||
end | |||
end | |||
if isSlayerAreaReq then break end | |||
end | |||
end | end | ||
end | end | ||
--Next, upgrading, crafting, herblore, fletching, and runecrafting since we have to sift through other items for these | |||
local | local canUpgrade = false | ||
local canCraft = false | |||
local canFletch = false | |||
local canRunecraft = false | |||
local canHerblore = false | |||
local canAgile = false | |||
local canSummon = false | |||
if item.trimmedItemID ~= nil then | |||
canUpgrade = true | |||
end | end | ||
for i, item2 in pairs(ItemData.Items) do | |||
if item2.itemsRequired ~= nil then | |||
for j, req in pairs(item2.itemsRequired) do | |||
if req[1] == item.id then | |||
canUpgrade = true | |||
break | |||
end | |||
end | end | ||
end | end | ||
if item2.craftReq ~= nil then | |||
for j, req in pairs(item2.craftReq) do | |||
if req.id == item.id then | |||
canCraft = true | |||
break | |||
end | |||
end | |||
for j, | 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 | end | ||
end | end | ||
if item2.herbloreReq ~= nil then | |||
for j, req in pairs(item2.herbloreReq) do | |||
if req.id == item.id then | |||
canHerblore = true | |||
break | |||
end | |||
end | |||
end | end | ||
if item2.summoningReq ~= nil then | |||
for j, reqSet in pairs(item2.summoningReq) do | |||
for k, req in pairs(reqSet) do | |||
if req.id == item.id then | |||
canSummon = true | |||
break | |||
end | |||
end | |||
end | |||
end | end | ||
end | end | ||
--Check if Agility applies here | |||
canAgile = Shared.tableCount(Agility.getObstaclesForItem(item.id)) > 0 | |||
--Agility | |||
if canAgile or Shared.contains(itemUseArray.Agility, item.name) then | |||
table.insert(useArray, chr..Icons.Icon({'Agility', type='skill'})) | |||
end | |||
if item == | --Cooking | ||
if item.cookedItemID ~= nil or Shared.contains(itemUseArray.Cooking, item.name) then | |||
table.insert(useArray, chr..Icons.Icon({'Cooking', type='skill'})) | |||
end | |||
--Crafting | |||
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 | end | ||
--Woodcutting | |||
if | if Shared.contains(itemUseArray.Woodcutting, item.name) then | ||
table.insert(useArray, chr..Icons.Icon({'Woodcutting', type='skill'})) | |||
end | end | ||
--Other odds and ends: | |||
if item. | --Mastery Tokens are tied to 'Mastery' | ||
if item.isToken and item.skill ~= nil then | |||
table.insert(useArray, chr..Icons.Icon({'Mastery'})) | |||
end | end | ||
if | --Skillcapes are tied to the appropriate skill | ||
--Except Max Skillcape, which is tied to all skills. (And so is the Signet Ring) | |||
--And combat skillcapes, since combat skills don't get special treatment | |||
local ignoreCapes = {'Ranged Skillcape', 'Attack Skillcape', 'Strength Skillcape', 'Hitpoints Skillcape', 'Defence Skillcape'} | |||
if Shared.contains({'Max Skillcape', 'Aorpheat's Signet Ring', 'Cape of Completion'}, item.name) then | |||
table.insert(useArray, chr..'All skills') | |||
elseif item.name == 'Magic Skillcape' then | |||
table.insert(useArray, chr..Icons.Icon({'Magic', type='skill'})) | |||
table.insert(useArray, chr..Icons.Icon({'Alt. Magic', type='skill'})) | |||
elseif Shared.contains(item.name, 'Skillcape') and not Shared.contains(ignoreCapes, item.name) then | |||
local skillName = Shared.splitString(item.name, ' ')[1] | |||
--Avoiding double-listing the same skill twice | |||
if not Shared.contains(itemUseArray[skillName], item.name) then | |||
table.insert(useArray, chr..Icons.Icon({skillName, type='skill'})) | |||
end | end | ||
end | end | ||
if Shared.contains(item.name, 'Skillcape') or item.name == 'Cape of Completion' then table.insert(categoryArray, '[[Category:Skillcapes]]') end | |||
end | |||
--Special note for Charge Stone of Rhaelyx | |||
if item.name == 'Charge Stone of Rhaelyx' then | |||
table.insert(useArray, chr..'Powering '..Icons.Icon({'Crown of Rhaelyx', type='item'})) | |||
end | end | ||
local | --Some items are needed to make shop purchases | ||
if | local shopArray = Shop.getItemCostArray(item.id) | ||
if Shared.tableCount(shopArray) > 0 then | |||
table.insert(useArray, chr..Icons.Icon({'Shop'})) | |||
end | end | ||
if canUpgrade then | |||
if item.canUpgrade or (item.type == 'Armour' and item.canUpgrade == nil) then | |||
table.insert(categoryArray, '[[Category:Upgradeable Items]]') | |||
if | |||
if | |||
end | end | ||
table.insert(useArray, chr..'[[Upgrading Items]]') | |||
end | end | ||
local result = asList and table.concat(useArray,'\r\n') or table.concat(useArray, '<br/>') | |||
if addCategories then result = result..table.concat(categoryArray, '') end | |||
return result | |||
end | end | ||
function p. | 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 = | local item = Items.getItem(itemName) | ||
local addCategories = false | |||
local asList = true | |||
if frame.args ~= nil then | |||
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' | |||
end | |||
if item == nil then | if item == nil then | ||
return "ERROR: No item named ".. | return "ERROR: No item named "..itemName.." exists in the data module" | ||
end | end | ||
return p. | |||
return p._getItemUses(item, asList, addCategories) | |||
end | end | ||
function p. | function p._getItemUseTable(item) | ||
local | local useArray = {} | ||
local | local potTierMastery = {[0] = 0, [1] = 20, [2] = 50, [3] = 90} | ||
local | --First, loop through all items to find anything that can be made or upgraded into using our source | ||
for i, item2 in pairs(ItemData.Items) do | |||
if item2.itemsRequired ~= nil then | |||
for j, req in pairs(item2.itemsRequired) do | |||
if req[1] == item.id then | |||
local mat = item2.itemsRequired | |||
local xp = 'N/A' | |||
local rowReq = 'None' | |||
--Potions do have upgrade requirements though | |||
if item2.potionTier ~= nil then | |||
rowReq = Icons._MasteryReq(item2.name, potTierMastery[item2.potionTier]) | |||
end | |||
table.insert(useArray, {item = item2, qty = 1, mats = mat, skill = 'Upgrade', req = rowReq, xp = xp, gp = item2.trimmedGPCost}) | |||
break | |||
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 | |||
for j, reqSet in pairs(item2.summoningReq) do | |||
for k, req in pairs(reqSet) do | |||
if req.id == item.id then | |||
local mat = Shared.clone(reqSet) | |||
mat[k].qty = math.max(math.floor(1000 / math.max(item.sellsFor, 20)), 1) | |||
local xp = 5 + 2 * math.floor(item2.summoningLevel * 0.2) | |||
local rowReq = item2.summoningLevel | |||
table.insert(useArray, {item = item2, qty = 25, mats = mat, skill = 'Summoning', req = rowReq, xp = xp}) | |||
end | |||
end | |||
end | |||
end | end | ||
end | end | ||
if item.grownItemID ~= nil then | |||
if item. | local item2 = Items.getItemByID(item.grownItemID) | ||
local | local mat = {{id = item.id, qty = item.seedsRequired}} | ||
local xp = item.farmingXP | |||
local rowReq = item.farmingLevel | |||
local qty = 5 | |||
table.insert(useArray, {item = item2, qty = qty, mats = mat, skill = 'Farming', req = rowReq, xp = xp}) | |||
end | end | ||
if item.cookedItemID ~= nil then | |||
if item. | local item2 = Items.getItemByID(item.cookedItemID) | ||
local mat = {{id = item.id, qty = 1}} | |||
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 | end | ||
if item.burntItemID ~= nil then | |||
if item. | 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 | end | ||
-- | |||
--Handle shop purchases using Module:Shop | |||
local shopUses = Shop.getItemCostArray(item.id) | |||
for i, purchase in Shared.skpairs(shopUses) do | |||
local rowReq = Shop.getRequirementString(purchase.unlockRequirements) | |||
local iconType = (purchase.contains.items ~= nil and Shared.tableCount(purchase.contains.items) > 0) and 'item' or 'upgrade' | |||
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}) | |||
end | end | ||
-- | |||
if item. | --Finally build the table using what we've learned | ||
table.sort(useArray, function(a, b) | |||
local aReqVal = a.reqVal ~= nil and a.reqVal or a.req | |||
local bReqVal = b.reqVal ~= nil and b.reqVal or b.req | |||
if a.skill ~= b.skill then | |||
return a.skill < b.skill | |||
elseif type(aReqVal) ~= type(bReqVal) then | |||
return tostring(aReqVal) < tostring(bReqVal) | |||
elseif aReqVal ~= bReqVal then | |||
return aReqVal < bReqVal | |||
else | |||
return a.item.name < b.item.name | |||
end end) | |||
local obstacles = Agility.getObstaclesForItem(item.id) | |||
local spellUseTable = p._getSpellUseTable(item) | |||
local result = '' | |||
if Shared.tableCount(useArray) == 0 and Shared.tableCount(obstacles) == 0 then | |||
if string.len(spellUseTable) > 0 then | |||
return '==Uses==\r\n==='..Icons.Icon({'Magic', type='skill', size='30'})..'===\r\n'..spellUseTable | |||
else | |||
return '' | |||
end | |||
end | end | ||
result = result..'{| class="wikitable sortable"' | |||
end | result = result..'\r\n!colspan=2|Item Created!!Type!!Requirements!!XP!!Ingredients' | ||
for i, row in pairs(useArray) do | |||
local qty = row.qty ~= nil and row.qty or 1 | |||
local iconType = row.type ~= nil and row.type or 'item' | |||
result = result..'\r\n|-\r\n|data-sort-value="'..row.item.name..'"|' | |||
result = result..Icons.Icon({row.item.name, type=iconType, notext=true, size=50})..'||' | |||
if qty > 1 then result = result.."'''"..qty.."x''' " end | |||
result = result..'[['..row.item.name..']]' | |||
if row.skill == 'Upgrade' then | |||
result = result..'||data-sort-value="Upgrade"|[[Upgrading Items|Upgrade]]' | |||
elseif row.skill == 'Shop' then | |||
result = result..'||data-sort-value="Shop"|'..Icons.Icon({'Shop'}) | |||
else | |||
result = result..'||data-sort-value="'..row.skill..'"|'..Icons.Icon({row.skill, type='skill'}) | |||
end | |||
if type(row.req) == 'number' then | |||
result = result..'|| data-sort-value="'..row.req..'"|'..Icons._SkillReq(row.skill, row.req) | |||
elseif row.reqVal ~= nil then | |||
result = result..'|| data-sort-value="'..row.reqVal..'"|'..row.req | |||
else | |||
result = result..'||'..row.req | |||
end | |||
if type(row.xp) == 'string' then | |||
result = result..'||data-sort-value="0"|'..row.xp | |||
else | |||
result = result..'||data-sort-value="'..row.xp..'"|'..row.xp..' '..Icons.Icon({row.skill, type='skill', notext=true})..' XP' | |||
end | |||
result = result..'||' | |||
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 result = result..'<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 | |||
result = result .. matText | |||
end | |||
if row.gp ~= nil then result = result..'<br/>'..Icons.GP(row.gp) end | |||
end | end | ||
--Agility obstacles are weird and get their own section | |||
for i, obst in Shared.skpairs(obstacles) do | |||
result = result..'\r\n|-\r\n|' | |||
result = result..Icons.Icon({"Agility", type="skill", size="50", notext=true}) | |||
result = result..'||[[Agility#Obstacles|'..obst.name..']]' | |||
result = result..'||'..Icons.Icon({"Agility", type="skill"}) | |||
--Adding the requirements for the Agility Obstacle | |||
local reqArray = {} | |||
if obst.category == nil then --nil category means this is a passive pillar | |||
table.insert(reqArray, Icons._SkillReq('Agility', 99)) | |||
elseif obst.category > 0 then --Otherwise it's category * 10 | |||
table.insert(reqArray, Icons._SkillReq('Agility', obst.category * 10)) | |||
end | 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 | ||
end | end | ||
result = result..'||'..table.concat(reqArray, '<br/>') | |||
--Just including 'N/A' for XP since it doesn't really apply for Agility Obstacles | |||
result = result..'||N/A' | |||
--Finally the cost | |||
local cost = obst.cost | |||
local costArray = {} | |||
if cost.gp ~= nil and cost.gp > 0 then | |||
table.insert(costArray, Icons.GP(cost.gp)) | |||
end | |||
if cost.slayerCoins ~= nil and cost.slayerCoins > 0 then | |||
table.insert(costArray, Icons.SC(cost.slayerCoins)) | |||
end | |||
for j, mat in Shared.skpairs(cost.items) do | |||
local item = Items.getItemByID(mat[1]) | |||
table.insert(costArray, Icons.Icon({item.name, type="item", qty=mat[2]})) | |||
end | |||
result = result..'||'..table.concat(costArray, '<br/>') | |||
end | |||
result = result..'\r\n|}' | |||
if string.len(spellUseTable) > 0 then | |||
result = result..'\r\n==='..Icons.Icon({'Magic', type='skill', size='30'})..'===\r\n'..spellUseTable | |||
end | end | ||
return result | return '==Uses==\r\n'..result | ||
end | end | ||
function p. | 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 = | 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 "ERROR: No item named "..itemName.." exists in the data module" | ||
end | end | ||
return p. | return p._getItemUseTable(item) | ||
end | end | ||
function p. | function p._getSpellUseTable(item) | ||
local | local spellList = Magic.getSpellsForRune(item.id) | ||
--Bail immediately if no spells are found | |||
if Shared.tableCount(spellList) == 0 then | |||
return '' | |||
end | |||
end | |||
local result = '{|class="wikitable sortable"\r\n!colspan="2"|Spell' | |||
result = ' | result = result..'!!Requirements' | ||
for i, | result = result..'!!Type!!style="width:275px"|Description' | ||
result = result..'!!Runes' | |||
for i, spell in pairs(spellList) do | |||
local rowTxt = '\r\n|-\r\n|data-sort-value="'..spell.name..'"|' | |||
if spell.type == 'Auroras' then | |||
rowTxt = rowTxt..Icons.Icon({spell.name, type='aurora', notext=true, size=50}) | |||
elseif spell.type == 'Curses' then | |||
rowTxt = rowTxt..Icons.Icon({spell.name, type='curse', notext=true, size=50}) | |||
else | else | ||
rowTxt = rowTxt..Icons.Icon({spell.name, type='spell', notext=true, size=50}) | |||
end | end | ||
rowTxt = rowTxt..'||[['..spell.name..']]' | |||
rowTxt = rowTxt..'||data-sort-value="'..spell.magicLevelRequired..'"|'..Icons._SkillReq('Magic', spell.magicLevelRequired) | |||
--Handle required items/dungeon clears | |||
if spell.requiredItem ~= nil and spell.requiredItem >= 0 then | |||
local reqItem = Items.getItemByID(spell.requiredItem) | |||
rowTxt = rowTxt..'<br/>'..Icons.Icon({reqItem.name, type='item', notext=true})..' equipped' | |||
end | |||
if spell.requiredDungeonCompletion ~= nil then | |||
local dung = Areas.getAreaByID('dungeon', spell.requiredDungeonCompletion[1]) | |||
rowTxt = rowTxt..'<br/>'..Icons.Icon({dung.name, type='dungeon', notext=true, qty=spell.requiredDungeonCompletion[2]})..' Clears' | |||
end | |||
rowTxt = rowTxt..'||data-sort-value="'..Magic.getSpellTypeIndex(spell.type)..'"|' | |||
rowTxt = rowTxt..Magic.getSpellTypeLink(spell.type) | |||
rowTxt = rowTxt..'||'..Magic._getSpellStat(spell, 'description') | |||
rowTxt = rowTxt..'||style="text-align:center"|' | |||
rowTxt = rowTxt..Magic._getSpellRunes(spell) | |||
result = result..rowTxt | |||
end | end | ||
--Add the table end and add the table to the result string | |||
result = result..'\r\n|}' | result = result..'\r\n|}' | ||
return result | return result | ||
end | end | ||
function p. | function p.getSpellUseTable(frame) | ||
local | local itemName = frame.args ~= nil and frame.args[1] or frame | ||
local item = Items.getItem(itemName) | |||
if item == nil then | |||
return "ERROR: No item named "..itemName.." exists in the data module" | |||
end | end | ||
return p._getSpellUseTable(item) | |||
end | end | ||
return p | return p |