12,868
edits
Falterfire (talk | contribs) (CraftReq now accounts for costs including coins) |
(Alt Magic -> Alt. Magic for consistency) |
||
(37 intermediate revisions by 3 users not shown) | |||
Line 4: | Line 4: | ||
local ItemData = mw.loadData('Module:Items/data') | local ItemData = mw.loadData('Module:Items/data') | ||
local SkillData = mw.loadData('Module:Skills/data') | local SkillData = mw.loadData('Module:Skills/data') | ||
local MagicData = mw.loadData('Module:Magic/data') | |||
local Constants = require('Module:Constants') | local Constants = require('Module:Constants') | ||
Line 13: | Line 14: | ||
local Shop = require('Module:Shop') | local Shop = require('Module:Shop') | ||
local Monsters = require('Module:Monsters') | local Monsters = require('Module:Monsters') | ||
local Skills = require('Module:Skills') | |||
local SkillEnum = mw.loadData('Module:Constants/data').skill | |||
-- Implements overrides for sources which cannot be obtained from game data | -- Implements overrides for sources which cannot be obtained from game data | ||
-- Currently only overrides for dungeon sources are implemented here | -- Currently only overrides for dungeon sources are implemented here | ||
local sourceOverrides = { | local sourceOverrides = { | ||
['Dungeon'] = { | |||
[950] = 'Volcanic Cave', -- A Tale of the Past, a future's prophecy | |||
[951] = 'Fire God Dungeon', -- The First Hero and an Unknown Evil | |||
[1116] = 'Into the Mist' -- Beginning of the End | |||
} | |||
} | } | ||
function p._getCreationTable(item) | function p._getCreationTable(item) | ||
local skill = '' | |||
local specialReq = nil | |||
local time = 0 | |||
local maxTime = nil | |||
local lvl = 0 | |||
local xp = 0 | |||
local qty = nil | |||
local req = nil | |||
local tables = {} | |||
--First figure out what skill is used to make this... | |||
if type(item.masteryID) == 'table' then | |||
local skillID, masteryID = item.masteryID[1], item.masteryID[2] | |||
skill = Constants.getSkillName(skillID) | |||
if skillID == SkillEnum.Fishing then | |||
-- Fishing | |||
local fish = SkillData.Fishing.Fish[masteryID + 1] | |||
if fish ~= nil and fish.itemID == item.id then | |||
lvl = fish.level | |||
xp = fish.baseXP | |||
qty = 1 | |||
time = fish.baseMinInterval / 1000 | |||
maxTime = fish.baseMaxInterval / 1000 | |||
table.insert(tables, p.buildCreationTable(skill, lvl, xp, req, qty, time, maxTime)) | |||
end | |||
elseif skillID == SkillEnum.Mining then | |||
-- Mining | |||
local rock = SkillData.Mining.Rocks[masteryID + 1] | |||
if rock ~= nil then | |||
lvl = rock.levelRequired | |||
xp = rock.baseExperience | |||
qty = rock.baseQuantity | |||
time = 3 | |||
if item.name == 'Dragonite Ore' then | |||
specialReq = Icons.Icon({"Mastery", notext='true'})..' 271 total [[Mining]] [[Mastery]]' | |||
end | |||
table.insert(tables, p.buildCreationTable(skill, lvl, xp, req, qty, time, nil, specialReq)) | |||
end | |||
elseif Shared.contains({SkillEnum.Smithing, SkillEnum.Fletching, SkillEnum.Crafting, | |||
SkillEnum.Runecrafting, SkillEnum.Herblore}, skillID) then | |||
-- Smithing, Fletching, Crafting, Runecrafting, Herblore | |||
-- All have somewhat consistent recipe data structures | |||
local recipeKey = (skillID == SkillEnum.Herblore and 'Potions') or 'Recipes' | |||
local recipe = SkillData[skill][recipeKey][masteryID + 1] | |||
if recipe ~= nil then | |||
local masteryReq = nil | |||
local itemMatch = (recipe.itemID == item.id) | |||
if skillID == SkillEnum.Herblore then | |||
-- For Herblore, we need to check a table of potion IDs & determine the mastery requirement | |||
for i, potionID in ipairs(recipe.potionIDs) do | |||
if potionID == item.id then | |||
itemMatch = true | |||
masteryReq = SkillData.Herblore.TierMasteryLevels[i] | |||
break | |||
end | |||
end | |||
end | |||
if itemMatch then | |||
local baseTime = { | |||
[SkillEnum.Smithing] = 2, | |||
[SkillEnum.Fletching] = 2, | |||
[SkillEnum.Crafting] = 3, | |||
[SkillEnum.Runecrafting] = 2, | |||
[SkillEnum.Herblore] = 2 | |||
} | |||
local baseQty = recipe.baseQuantity or 1 | |||
lvl = recipe.level | |||
xp = recipe.baseXP | |||
time = baseTime[skillID] | |||
if masteryReq ~= nil and masteryReq > 1 then | |||
specialReq = Icons._MasteryReq(item.name, masteryReq, false) | |||
end | |||
-- Some items (such as Arrow shafts) have multiple recipes | |||
if type(recipe.alternativeCosts) == 'table' then | |||
local reqPart, qtyPart = {}, {} | |||
for i, altCost in ipairs(recipe.alternativeCosts) do | |||
local reqSubPart = {} | |||
for j, itemCost in ipairs(altCost.itemCosts) do | |||
local reqItem = Items.getItemByID(itemCost.id) | |||
if reqItem == nil then | |||
table.insert(reqSubPart, itemCost.qty .. 'x ?????') | |||
else | |||
table.insert(reqSubPart, Icons.Icon({reqItem.name, type='item', qty=itemCost.qty})) | |||
end | |||
end | |||
if recipe.gpCost ~= nil and recipe.gpCost > 0 then | |||
table.insert(reqSubPart, Icons.GP(recipe.gpCost)) | |||
end | |||
if recipe.scCost ~= nil and recipe.scCost > 0 then | |||
table.insert(reqSubPart, Icons.GP(recipe.scCost)) | |||
end | |||
table.insert(reqPart, table.concat(reqSubPart, ', ')) | |||
table.insert(qtyPart, Shared.formatnum(baseQty * altCost.quantityMultiplier)) | |||
end | |||
local sep = "<br/>'''OR''' " | |||
req = table.concat(reqPart, sep) | |||
qty = table.concat(qtyPart, sep) | |||
table.insert(tables, p.buildCreationTable(skill, lvl, xp, req, qty, time, maxTime, specialReq)) | |||
elseif type(recipe.itemCosts) == 'table' and Shared.tableCount(recipe.itemCosts) > 0 then | |||
req = recipe.itemCosts | |||
table.insert(tables, p.buildCreationTable(skill, lvl, xp, req, baseQty, time, maxTime, specialReq, recipe.gpCost, recipe.scCost)) | |||
end | |||
end | |||
end | |||
elseif skillID == SkillEnum.Summoning then | |||
-- Summoning | |||
local recipe = SkillData.Summoning.Marks[masteryID + 1] | |||
if recipe ~= nil and recipe.itemID == item.id then | |||
lvl = recipe.level | |||
xp = recipe.baseXP | |||
qty = recipe.baseQuantity | |||
time = 5 | |||
-- Create item requirements text | |||
local ShardCostArray, OtherCostArray = {}, {} | |||
-- Shards | |||
for j, cost in ipairs(recipe.itemCosts) do | |||
local shard = Items.getItemByID(cost.id) | |||
if shard ~= nil then | |||
table.insert(ShardCostArray, Icons.Icon({shard.name, type='item', notext=true, qty=cost.qty})) | |||
end | |||
end | |||
-- Other costs | |||
local recipeGPCost = SkillData.Summoning.RecipeGPCost | |||
if recipe.gpCost > 0 then | |||
table.insert(OtherCostArray, Icons.GP(recipe.gpCost)) | |||
end | |||
if recipe.scCost > 0 then | |||
table.insert(OtherCostArray, Icons.SC(recipe.scCost)) | |||
end | |||
for j, nonShardID in ipairs(recipe.nonShardItemCosts) do | |||
local nonShard = Items.getItemByID(nonShardID) | |||
if nonShard ~= nil then | |||
local itemValue = math.max(nonShard.sellsFor, 20) | |||
local nonShardQty = math.max(1, math.floor(recipeGPCost / itemValue)) | |||
table.insert(OtherCostArray, Icons.Icon({nonShard.name, type='item', notext=true, qty=nonShardQty})) | |||
end | |||
end | |||
req = table.concat(ShardCostArray, ', ') | |||
if #OtherCostArray > 0 then | |||
req = req .. '<br/>and one of the following:<br/>' .. table.concat(OtherCostArray, "<br/>'''OR''' ") | |||
end | |||
table.insert(tables, p.buildCreationTable(skill, lvl, xp, req, qty, time)) | |||
end | |||
end | |||
end | |||
-- Woodcutting | |||
if item.type == 'Logs' then | |||
-- Determine which tree (if any) the log is from | |||
for i, tree in ipairs(SkillData.Woodcutting.Trees) do | |||
if tree.logID == item.id then | |||
skill = 'Woodcutting' | |||
lvl = tree.levelRequired | |||
time = tree.baseInterval / 1000 | |||
xp = tree.baseExperience | |||
table.insert(tables, p.buildCreationTable(skill, lvl, xp, req, qty, time)) | |||
break | |||
end | |||
end | |||
end | |||
-- Cooking | |||
if item.canEat then | |||
for i, recipe in ipairs(SkillData.Cooking.Recipes) do | |||
if recipe.itemID == item.id or recipe.perfectCookID == item.id then | |||
skill = 'Cooking' | |||
lvl = recipe.level | |||
xp = recipe.baseXP | |||
req = recipe.itemCosts | |||
qty = recipe.baseQuantity | |||
time = recipe.baseInterval / 1000 | |||
table.insert(tables, p.buildCreationTable(skill, lvl, xp, req, qty, time)) | |||
break | |||
end | |||
end | |||
end | |||
-- Farming | |||
if item.type == 'Herb' or item.type == 'Logs' or (item.type == 'Food' and item.category ~= 'Cooking') then | |||
-- Herb means farming | |||
-- Logs/Food might mean farming or might not. Depends on the item | |||
for i, seed in ipairs(ItemData.Items) do | |||
if seed.grownItemID ~= nil and seed.grownItemID == item.id then | |||
skill = 'Farming' | |||
lvl = seed.farmingLevel | |||
xp = seed.farmingXP | |||
time = seed.timeToGrow | |||
if item.type == 'Logs' then | |||
qty = 35 | |||
else | |||
qty = 15 | |||
end | |||
req = {{id = seed.id, qty = (seed.seedsRequired ~= nil and seed.seedsRequired or 1)}} | |||
table.insert(tables, p.buildCreationTable(skill, lvl, xp, req, qty, time)) | |||
break | |||
end | |||
end | |||
end | |||
-- Alt. Magic, excludes Gems and Bars | |||
-- Bars are handled by getItemSuperheatTable() | |||
-- Gems are handled by _getItemLootSourceTable() | |||
for i, altSpell in ipairs(MagicData.AltMagic) do | |||
if type(altSpell.produces) == 'number' and altSpell.produces == item.id then | |||
table.insert(tables, p._buildAltMagicTable(altSpell)) | |||
end | end | ||
end | |||
if Shared.tableCount(tables) == 0 then | |||
return "" | |||
else | |||
return table.concat(tables, '\r\n') | |||
end | |||
end | |||
function p.getAltMagicTable(frame) | |||
local spellName = frame.args ~= nil and frame.args[1] or frame | |||
local spell = Magic.getSpell(spellName, 'AltMagic') | |||
if spell == nil then | |||
return 'ERROR: Could not find Alt. Magic spell "' .. spellName .. '"[[Category:Pages with script errors]]' | |||
else | |||
return p._buildAltMagicTable(spell) | |||
end | |||
end | end | ||
function p. | function p._buildAltMagicTable(spell) | ||
local resultPart = {} | |||
table.insert(resultPart, '{|class="wikitable"\r\n|-') | |||
table.insert(resultPart, '\r\n!colspan="2"|'..Icons.Icon({spell.name, type='spell'})) | |||
table.insert(resultPart, '\r\n|-\r\n!style="text-align:right;"|Requirements') | |||
table.insert(resultPart, '\r\n|'..Icons._SkillReq('Magic', spell.level)) | |||
-- The produces property of Alt. Magic spells is as follows: | |||
-- -3 = A random gem, using the same weights as Mining | |||
-- -2 = A bar of the type being created (Superheat) | |||
-- -1 = GP (Alchemy) | |||
-- 0 = Undefined | |||
-- >0 = Item ID of the item being produced | |||
-- The amount produced is determined by the productionRatio property | |||
-- The consumes property of Alt. Magic spells is as follows: | |||
-- 0 = Any item | |||
-- 1 = Junk item | |||
-- 2 = Superheat/ores with Coal | |||
-- 3 = Superheat/ores without Coal | |||
-- 4 = Nothing | |||
-- 5 = Coal ore | |||
-- Superheat (2, 3) is handled by _getItemSuperheatTable() | |||
if spell.consumes ~= nil then | |||
local consumeText = { | |||
'1 of any item', | |||
'1 of any [[Fishing#Junk|Junk]] item', | |||
'1 x required ores for the chosen bar', | |||
'1 x required ores (except ' .. Icons.Icon({'Coal Ore', type='item'}) .. ') for the chosen bar', | |||
nil, | |||
Icons.Icon({'Coal Ore', type='item', qty=1}) | |||
} | |||
local consumeStr = consumeText[spell.consumes + 1] | |||
if consumeStr ~= nil then | |||
table.insert(resultPart, '\r\n|-\r\n!style="text-align:right;"|Materials') | |||
table.insert(resultPart, '\r\n| ' .. consumeStr) | |||
end | |||
end | |||
--Add runes | |||
table.insert(resultPart, '\r\n|-\r\n!style="text-align:right;"|Runes\r\n| ' .. Magic._getSpellRunes(spell)) | |||
--Now just need the output quantity, xp, and casting time (which is always 2) | |||
table.insert(resultPart, '\r\n|-\r\n!style="text-align:right;"|Base Quantity\r\n|' .. spell.productionRatio) | |||
table.insert(resultPart, '\r\n|-\r\n!style="text-align:right;"|Base XP\r\n|' .. spell.baseExperience) | |||
table.insert(resultPart, '\r\n|-\r\n!style="text-align:right;"|Cast Time\r\n|2s') | |||
table.insert(resultPart, '\r\n|}') | |||
return table.concat(resultPart) | |||
end | end | ||
function p.buildCreationTable(skill, lvl, xp, req, qty, time, maxTime, specialReq, gpCost) | function p.buildCreationTable(skill, lvl, xp, req, qty, time, maxTime, specialReq, gpCost, scCost) | ||
if qty == nil then qty = 1 end | |||
local resultPart = {} | |||
table.insert(resultPart, '{|class="wikitable"') | |||
if req ~= nil then | |||
table.insert(resultPart, '\r\n!colspan="2"|Item Creation') | |||
else | |||
table.insert(resultPart, '\r\n!colspan="2"|Item Production') | |||
end | |||
table.insert(resultPart, '\r\n|-\r\n!style="text-align: right;"|Requirements') | |||
table.insert(resultPart, '\r\n|'..Icons._SkillReq(skill, lvl)) | |||
if specialReq ~= nil then table.insert(resultPart, '<br/>'..specialReq) end | |||
if req ~= nil then | |||
table.insert(resultPart, '\r\n|-\r\n!style="text-align: right;"|Materials\r\n|') | |||
if type(req) == 'table' then | |||
for i, mat in pairs(req) do | |||
if i > 1 then table.insert(resultPart, '<br/>') end | |||
local matItem = Items.getItemByID(mat.id) | |||
if matItem == nil then | |||
table.insert(resultPart, mat.qty..'x ?????') | |||
else | |||
table.insert(resultPart, Icons.Icon({matItem.name, type='item', qty=mat.qty})) | |||
end | |||
end | |||
if gpCost ~= nil and gpCost > 0 then | |||
table.insert(resultPart, '<br/>') | |||
table.insert(resultPart, Icons.GP(gpCost)) | |||
end | |||
if scCost ~= nil and scCost > 0 then | |||
table.insert(resultPart, '<br/>') | |||
table.insert(resultPart, Icons.SC(scCost)) | |||
end | |||
else | |||
table.insert(resultPart, req) | |||
end | |||
end | |||
table.insert(resultPart, '\r\n|-\r\n!style="text-align:right;"|Base Quantity') | |||
table.insert(resultPart, '\r\n|'..qty) | |||
table.insert(resultPart, '\r\n|-\r\n!style="text-align:right;"|Base Experience') | |||
table.insert(resultPart, '\r\n|'..Shared.formatnum(xp)..' XP') | |||
table.insert(resultPart, '\r\n|-\r\n!style="text-align:right;"|Base Creation Time') | |||
table.insert(resultPart, '\r\n|'..Shared.formatnum(Shared.round(time, 2, 0))..'s') | |||
if maxTime ~= nil and maxTime > time then table.insert(resultPart, ' - '..Shared.formatnum(Shared.round(maxTime, 2, 0))..'s') end | |||
table.insert(resultPart, '\r\n|}') | |||
return table.concat(resultPart) | |||
end | end | ||
function p.getCreationTable(frame) | function p.getCreationTable(frame) | ||
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[[Category:Pages with script errors]]" | |||
end | |||
return p._getCreationTable(item) | |||
end | end | ||
function p._getItemSources(item, asList, addCategories) | function p._getItemSources(item, asList, addCategories) | ||
local lineArray = {} | |||
local categoryArray = {} | |||
--Alright, time to go through all the ways you can get an item... | |||
--First up: Can we kill somebody and take theirs? | |||
local killStrPart = {} | |||
for i, monster in ipairs(MonsterData.Monsters) do | |||
local isDrop = false | |||
if monster.bones == item.id and Monsters._getMonsterBones(monster) ~= nil then | |||
-- Item is a bone, and is either a shard from God dungeons or dropped by a non-boss monster with a loot table | |||
isDrop = true | |||
elseif monster.lootTable ~= nil then | |||
-- If the monster has a loot table, check if the item we are looking for is in there | |||
-- Dungeon exclusive monsters don't count as they are either: | |||
-- - A monster before the boss, which doesn't drop anything except shards (checked above) | |||
-- - A boss monster, whose drops are accounted for in data from Areas instead | |||
for j, loot in ipairs(monster.lootTable) do | |||
if loot[1] == item.id and not Monsters._isDungeonOnlyMonster(monster) then | |||
isDrop = true | |||
break | |||
end | |||
end | |||
end | |||
if isDrop then | |||
-- Item drops when the monster is killed | |||
table.insert(killStrPart, Icons.Icon({monster.name, type='monster', notext=true})) | |||
end | |||
end | |||
-- Is the item dropped from any dungeon? | |||
local dungeonStrPart = {} | |||
local dungeonList = Areas.getAreas(function(area) return area.type == 'dungeon' and type(area.rewards) == 'table' and Shared.contains(area.rewards, item.id) end) | |||
if dungeonList ~= nil then | |||
for i, dungeon in ipairs(dungeonList) do | |||
table.insert(dungeonStrPart, Icons.Icon({dungeon.name, type='dungeon', notext=true})) | |||
end | |||
end | |||
-- Is the item dropped from a cycle of the Impending Darkness event? | |||
for i, eventItemID in ipairs(Areas.eventData.rewards) do | |||
if item.id == eventItemID then | |||
local dungPrefix = (i == Shared.tableCount(Areas.eventData.rewards) and '' or i .. ' ' .. (i == 1 and 'cycle' or 'cycles') .. ' of ') | |||
table.insert(dungeonStrPart, dungPrefix .. Icons.Icon({'Impending Darkness Event', type='dungeon', notext=true})) | |||
break | |||
end | |||
end | |||
-- Special exceptions for lore books | |||
if sourceOverrides['Dungeon'][item.id] ~= nil then | |||
table.insert(dungeonStrPart, Icons.Icon({sourceOverrides['Dungeon'][item.id], type='dungeon', notext=true})) | |||
end | |||
if Shared.tableCount(dungeonStrPart) > 0 then | |||
table.insert(lineArray, 'Completing: ' .. table.concat(dungeonStrPart, ',')) | |||
end | |||
if Shared.tableCount(killStrPart) > 0 then | |||
table.insert(lineArray, 'Killing: ' .. table.concat(killStrPart, ',')) | |||
end | |||
--Next: Can we find it in a box? | |||
--While we're here, check for upgrades, and growing | |||
local lootPart, upgradePart, growPart = {}, {}, {} | |||
for i, item2 in pairs(ItemData.Items) do | |||
if item2.dropTable ~= nil then | |||
for j, loot in ipairs(item2.dropTable) do | |||
if loot[1] == item.id then | |||
table.insert(lootPart, Icons.Icon({item2.name, type='item', notext=true})) | |||
break | |||
end | |||
end | |||
end | |||
if item2.trimmedItemID ~= nil and item2.trimmedItemID == item.id then | |||
table.insert(upgradePart, Icons.Icon({item2.name, type='item', notext=true})) | |||
end | |||
if item2.grownItemID == item.id then | |||
-- Farming | |||
table.insert(growPart, Icons.Icon({item2.name, type='item', notext=true})) | |||
end | |||
end | |||
if #lootPart > 0 then | |||
table.insert(lineArray, 'Opening: ' .. table.concat(lootPart, ',')) | |||
end | |||
if #upgradePart > 0 then | |||
table.insert(categoryArray, '[[Category:Upgraded Items]]') | |||
table.insert(lineArray, 'Upgrading: ' .. table.concat(upgradePart, ',')) | |||
end | |||
if #growPart > 0 then | |||
table.insert(categoryArray, '[[Category:Harvestable Items]]') | |||
table.insert(lineArray, 'Growing: ' .. table.concat(growPart, ',')) | |||
end | |||
--Next: Can we take it from somebody else -without- killing them? | |||
local thiefItems = Skills.getThievingSourcesForItem(item.id) | |||
if type(thiefItems) == 'table' then | |||
local thiefPart = {} | |||
for i, thiefRow in ipairs(thiefItems) do | |||
if thiefRow.npc == 'all' then | |||
--if 'all' is the npc, this is a rare item so just say 'Thieving level 1' | |||
table.insert(lineArray, Icons._SkillReq('Thieving', 1)) | |||
else | |||
table.insert(thiefPart, Icons.Icon({thiefRow.npc, type='thieving', notext=true})) | |||
end | |||
end | |||
if #thiefPart > 0 then | |||
table.insert(lineArray, 'Pickpocketing: ' .. table.concat(thiefPart, ',')) | |||
end | |||
end | |||
--Check if we can make it ourselves | |||
--AstrologyCheck (Just a brute force for now because only two items) | |||
if Shared.contains({'Stardust', 'Golden Stardust'}, item.name) then | |||
table.insert(lineArray, Icons.Icon({'Astrology', type='skill'})) | |||
end | |||
-- Sources discoverable through mastery IDs | |||
-- Does _not_ handle: | |||
-- Fishing: Junk, special items | |||
-- Cooking: perfect items | |||
if type(item.masteryID) == 'table' then | |||
local skillID, masteryID = item.masteryID[1], item.masteryID[2] | |||
local skill = Constants.getSkillName(skillID) | |||
local keyData = { | |||
[SkillEnum.Fishing] = { ["recipe"] = 'Fish' }, | |||
[SkillEnum.Mining] = { ["recipe"] = 'Rocks', ["level"] = 'levelRequired', ["item"] = 'oreID' }, | |||
[SkillEnum.Smithing] = {}, | |||
[SkillEnum.Fletching] = {}, | |||
[SkillEnum.Crafting] = {}, | |||
[SkillEnum.Runecrafting] = {}, | |||
[SkillEnum.Herblore] = { ["recipe"] = 'Potions', ["item"] = 'potionIDs', ["isItemList"] = true }, | |||
[SkillEnum.Summoning] = { ["recipe"] = 'Marks' } | |||
} | |||
local keys = keyData[skillID] | |||
if type(keys) == 'table' then | |||
if keys.recipe == nil then | |||
keys.recipe = 'Recipes' | |||
end | |||
if keys.level == nil then | |||
keys.level = 'level' | |||
end | |||
if keys.item == nil then | |||
keys.item = 'itemID' | |||
end | |||
if keys.isItemList == nil then | |||
keys.isItemList = false | |||
end | |||
local recipe = SkillData[skill][keys.recipe][masteryID + 1] | |||
if recipe ~= nil and ( | |||
(not keys.isItemList and recipe[keys.item] == item.id) or | |||
(keys.isItemList and Shared.contains(recipe[keys.item], item.id))) then | |||
local levelReq = recipe[keys.level] | |||
if levelReq ~= nil then | |||
table.insert(lineArray, Icons._SkillReq(skill, levelReq)) | |||
end | |||
end | |||
end | |||
end | |||
-- Woodcutting | |||
for i, tree in ipairs(SkillData.Woodcutting.Trees) do | |||
if tree.logID == item.id then | |||
table.insert(lineArray, Icons._SkillReq('Woodcutting', tree.levelRequired)) | |||
break | |||
end | |||
end | |||
-- Woodcutting: Nests | |||
if item.name == 'Bird Nest' then | |||
table.insert(lineArray, Icons._SkillReq('Woodcutting', 1)) | |||
end | |||
-- Fishing: Junk & Specials | |||
if Shared.contains(SkillData.Fishing.JunkItems, item.id) then | |||
table.insert(lineArray, Icons.Icon({'Fishing', type='skill', notext=true}) .. ' [[Fishing#Junk|Junk]]') | |||
else | |||
for i, specialItem in ipairs(SkillData.Fishing.SpecialItems) do | |||
if specialItem[1] == item.id then | |||
table.insert(lineArray, Icons.Icon({'Fishing', type='skill', notext=true}) .. ' [[Fishing#Special|Special]]') | |||
break | |||
end | |||
end | |||
end | |||
-- Cooking | |||
if item.canEat then | |||
for i, recipe in ipairs(SkillData.Cooking.Recipes) do | |||
if recipe.itemID == item.id or recipe.perfectCookID == item.id then | |||
table.insert(lineArray, Icons._SkillReq('Cooking', recipe.level)) | |||
break | |||
end | |||
end | |||
end | |||
-- Alt. Magic | |||
for i, altSpell in ipairs(MagicData.AltMagic) do | |||
if type(altSpell.produces) == 'number' and | |||
((altSpell.produces == -3 and item.type == 'Gem' and item.name ~= 'Jadestone') | |||
or (altSpell.produces == -2 and item.type == 'Bar') | |||
or (altSpell.produces > 0 and altSpell.produces == item.id)) then | |||
table.insert(lineArray, Icons.Icon({"Alt. Magic", type='skill'})) | |||
break | |||
end | |||
end | |||
--Finally there are some weird exceptions: | |||
--Coal can be acquired via firemaking | |||
if item.name == "Coal Ore" then | |||
table.insert(lineArray, Icons._SkillReq("Firemaking", 1)) | |||
end | |||
--Gems can be acquired from Mining | |||
if item.type == 'Gem' and item.name ~= 'Jadestone' then | |||
table.insert(lineArray, Icons.Icon({"Mining", type='skill', notext=true})..' [[Mining#Gems|Gem]]') | |||
end | |||
--Rhaelyx pieces are also special | |||
if Shared.contains({'Circlet of Rhaelyx', 'Jewel of Rhaelyx', 'Mysterious Stone'}, item.name) then | |||
local rhaSkills = { | |||
Circlet = {'Woodcutting', 'Fishing', 'Mining', 'Thieving', 'Farming', 'Agility', 'Astrology'}, | |||
Jewel = {'Firemaking', 'Cooking', 'Smithing', 'Fletching', 'Crafting', 'Runecrafting', 'Herblore', 'Summoning'} | |||
} | |||
local rhaSkList, subText = nil, '' | |||
if item.name == 'Circlet of Rhaelyx' then | |||
rhaSkList = {rhaSkills.Circlet} | |||
elseif item.name == 'Jewel of Rhaelyx' then | |||
rhaSkList = {rhaSkills.Jewel} | |||
elseif item.name == 'Mysterious Stone' then | |||
rhaSkList = {rhaSkills.Jewel, rhaSkills.Circlet} | |||
subText = '<br/>after finding ' .. Icons.Icon({'Crown of Rhaelyx', type='item'}) | |||
end | |||
local rhaStrPart = {} | |||
for i, skillList in ipairs(rhaSkList) do | |||
for j, skillName in ipairs(skillList) do | |||
table.insert(rhaStrPart, Icons.Icon({skillName, type='skill', notext=true})) | |||
end | |||
end | |||
table.insert(lineArray, 'Any action in: ' .. table.concat(rhaStrPart, ', ') .. subText) | |||
end | |||
--Tokens are from the appropriate skill | |||
if item.isToken and item.skill ~= nil then | |||
table.insert(lineArray, Icons._SkillReq(Constants.getSkillName(item.skill), 1)) | |||
end | |||
-- Golbin Raid exclusive items | |||
if item.golbinRaidExclusive then | |||
table.insert(lineArray, Icons.Icon({'Golbin Raid', type='pet', img='Golden Golbin'})) | |||
end | |||
--Shop items (including special items like gloves that aren't otherwise listed) | |||
local shopSources = Shop.getItemSourceArray(item.id) | |||
if Shared.tableCount(shopSources) > 0 then | |||
table.insert(lineArray, Icons.Icon({'Shop'})) | |||
end | |||
--Easter Eggs (manual list 'cause don't have a better way to do that) | |||
if Shared.contains(Items.EasterEggs, item.name) then | |||
table.insert(lineArray, '[[Easter Eggs]]') | |||
end | |||
-- Event exclusive items (also a manual list) | |||
if Shared.contains(Items.EventItems, item.name) then | |||
table.insert(lineArray, '[[Events]]') | |||
end | |||
--Gold Topaz Ring drops from any action (when not wearing a Gold Topaz Ring) | |||
--Also handling Signet Ring things here | |||
if item.name == 'Gold Topaz Ring' then | |||
table.insert(lineArray, 'Any non-combat action if not worn (Instead of '..Icons.Icon({"Signet Ring Half (a)", type="item"})..')') | |||
table.insert(lineArray, 'Killing any monster if not worn (Instead of '..Icons.Icon({"Signet Ring Half (b)", type="item"})..')') | |||
elseif item.name == 'Signet Ring Half (a)' then | |||
table.insert(lineArray, 'Any non-combat action while wearing '..Icons.Icon({'Gold Topaz Ring', type='item'})) | |||
elseif item.name == 'Signet Ring Half (b)' then | |||
table.insert(lineArray, 'Killing any monster while wearing '..Icons.Icon({'Gold Topaz Ring', type='item'})) | |||
end | |||
local resultPart = {} | |||
if asList then | |||
table.insert(resultPart, '* '..table.concat(lineArray, "\r\n* ")) | |||
else | |||
table.insert(resultPart, '<div style="max-width:180px;text-align:right">' .. table.concat(lineArray, "<br/>") .. '</div>') | |||
end | |||
if addCategories then table.insert(resultPart, table.concat(categoryArray, '')) end | |||
return table.concat(resultPart) | |||
end | end | ||
function p.getItemSources(frame) | function p.getItemSources(frame) | ||
local itemName = frame.args ~= nil and frame.args[1] or frame | |||
local item = Items.getItem(itemName) | |||
local asList = false | |||
local addCategories = false | |||
if frame.args ~= nil then | |||
asList = frame.args.asList ~= nil and frame.args.asList ~= '' and frame.args.asList ~= 'false' | |||
addCategories = frame.args.addCategories ~= nil and frame.args.addCategories ~= '' and frame.args.addCategories ~= 'false' | |||
end | |||
if item == nil then | |||
return "ERROR: No item named "..itemName.." exists in the data module[[Category:Pages with script errors]]" | |||
end | |||
return p._getItemSources(item, asList, addCategories) | |||
end | end | ||
function p._getItemLootSourceTable(item) | function p._getItemLootSourceTable(item) | ||
local resultPart = {} | |||
table.insert(resultPart, '{| class="wikitable sortable stickyHeader"') | |||
table.insert(resultPart, '\r\n|- class="headerRow-0"') | |||
table.insert(resultPart, '\r\n!Source!!Source Type!!Quantity!!colspan="2"|Chance') | |||
--Set up function for adding rows | |||
local buildRow = function(source, type, minqty, qty, weight, totalWeight) | |||
if minqty == nil then minqty = 1 end | |||
local rowPart = {} | |||
table.insert(rowPart, '\r\n|-') | |||
table.insert(rowPart, '\r\n|style="text-align: left;"|'..source) | |||
table.insert(rowPart, '\r\n|style="text-align: left;"|'..type) | |||
table.insert(rowPart, '\r\n|style="text-align: right;" data-sort-value="'..qty..'"|'..Shared.formatnum(minqty)) | |||
if qty ~= minqty then table.insert(rowPart, ' - '..Shared.formatnum(qty)) end | |||
local chance = weight / totalWeight * 100 | |||
-- If chance is less than 0.10% then show 2 significant figures, otherwise 2 decimal places | |||
local fmt = (chance < 0.10 and '%.2g') or '%.2f' | |||
chance = string.format(fmt, chance) | |||
if weight >= totalWeight then | |||
-- Fraction would be 1/1, so only show the percentage | |||
chance = 100 | |||
table.insert(rowPart, '\r\n|colspan="2" ') | |||
else | |||
local fraction = Shared.fraction(weight, totalWeight) | |||
if Shared.contains(fraction, '%.') then | |||
--If fraction contains decimals, something screwy happened so just show only percentage | |||
--(happens sometimes with the rare thieving items) | |||
table.insert(rowPart, '\r\n|colspan="2" ') | |||
else | |||
table.insert(rowPart, '\r\n|style="text-align: right;" data-sort-value="' .. chance .. '"| ' .. Shared.fraction(weight, totalWeight) .. '\r\n|') | |||
end | |||
end | |||
if weight == -1 then | |||
--Weight of -1 means this is a weird row that has a variable percentage | |||
table.insert(rowPart, 'style="text-align: right;" data-sort-value="0"|Varies (see Thieving page)') | |||
else | |||
table.insert(rowPart, 'style="text-align: right;" data-sort-value="'.. chance .. '"|'..chance..'%') | |||
end | |||
return table.concat(rowPart) | |||
end | |||
local dropRows = {} | |||
--Alright, time to go through a few ways to get the item | |||
--First up: Can we kill somebody and take theirs? | |||
for i, monster in ipairs(MonsterData.Monsters) do | |||
local minqty = 1 | |||
local qty = 1 | |||
local wt = 0 | |||
local totalWt = 0 | |||
--Only add bones if this monster has loot (ie appears outside a dungeon) and isn't a boss | |||
--... unless we're looking for Shards of course, at which point we'll take any monster with the right bones | |||
if monster.bones == item.id and Monsters._getMonsterBones(monster) ~= nil then | |||
qty = monster.boneQty ~= nil and monster.boneQty or 1 | |||
minqty = qty | |||
wt = 1 | |||
totalWt = 1 | |||
elseif monster.lootTable ~= nil then | |||
-- If the monster has a loot table, check if the item we are looking for is in there | |||
-- Dungeon exclusive monsters don't count as they are either: | |||
-- - A monster before the boss, which doesn't drop anything except shards (checked above) | |||
-- - A boss monster, whose drops are accounted for in data from Areas instead | |||
for j, loot in ipairs(monster.lootTable) do | |||
totalWt = totalWt + loot[2] | |||
if loot[1] == item.id and not Monsters._isDungeonOnlyMonster(monster) then | |||
wt = loot[2] | |||
qty = loot[3] | |||
end | |||
end | |||
end | |||
local lootChance = monster.lootChance ~= nil and monster.bones ~= item.id and monster.lootChance or 100 | |||
if wt > 0 and lootChance > 0 then | |||
-- Item drops when the monster is killed | |||
table.insert(dropRows, {source = Icons.Icon({monster.name, type='monster'}), type = '[[Monster]]', minqty = minqty, qty = qty, weight = wt * lootChance, totalWeight = totalWt * 100}) | |||
end | |||
end | |||
-- Is the item dropped from any dungeon? | |||
local dungeonList = Areas.getAreas(function(area) return area.type == 'dungeon' and type(area.rewards) == 'table' and Shared.contains(area.rewards, item.id) end) | |||
if dungeonList ~= nil then | |||
for i, dungeon in ipairs(dungeonList) do | |||
table.insert(dropRows, {source = Icons.Icon({dungeon.name, type='dungeon'}), type = '[[Dungeon]]', minqty = 1, qty = 1, weight = 1, totalWeight = 1}) | |||
end | |||
end | |||
-- Is the item dropped from a cycle of the Impending Darkness event? | |||
for i, eventItemID in ipairs(Areas.eventData.rewards) do | |||
if item.id == eventItemID then | |||
sourceTxt = Icons.Icon({'Impending Darkness Event', type='dungeon'}) .. (i == Shared.tableCount(Areas.eventData.rewards) and '' or ', Cycle ' .. i) | |||
table.insert(dropRows, {source = sourceTxt, type = '[[Dungeon]]', minqty = 1, qty = 1, weight = 1, totalWeight = 1}) | |||
break | |||
end | |||
end | |||
--Special exception for the Fire/Infernal Cape and first two lore books as bonus dungeon drops | |||
if sourceOverrides['Dungeon'][item.id] ~= nil then | |||
local sourceTxt = Icons.Icon({sourceOverrides['Dungeon'][item.id], type='dungeon'}) | |||
table.insert(dropRows, {source = sourceTxt, type = '[[Dungeon]]', minqty = 1, qty = 1, weight = 1, totalWeight = 1}) | |||
end | |||
--Next: Can we find it by rummaging around in another item? | |||
for i, item2 in ipairs(ItemData.Items) do | |||
if item2.dropTable ~= nil then | |||
local qty = 1 | |||
local wt = 0 | |||
local totalWt = 0 | |||
for j, loot in pairs(item2.dropTable) do | |||
totalWt = totalWt + loot[2] | |||
if loot[1] == item.id then | |||
wt = loot[2] | |||
if item2.dropQty ~= nil then qty = item2.dropQty[j] end | |||
end | |||
end | |||
if wt > 0 then | |||
local sourceTxt = Icons.Icon({item2.name, type='item'}) | |||
table.insert(dropRows, {source = sourceTxt, type = '[[Chest]]', minqty = 1, qty = qty, weight = wt, totalWeight = totalWt}) | |||
end | |||
end | |||
end | |||
--Finally, let's try just stealing it | |||
local thiefType = Icons.Icon({"Thieving", type='skill'}) | |||
local thiefItems = Skills.getThievingSourcesForItem(item.id) | |||
for i, thiefRow in ipairs(thiefItems) do | |||
local sourceTxt = '' | |||
if thiefRow.npc == 'all' then | |||
sourceTxt = "Thieving Rare Drop" | |||
else | |||
sourceTxt = Icons.Icon({thiefRow.npc, type='thieving'}) | |||
end | |||
table.insert(dropRows, {source = sourceTxt, type = thiefType, minqty = thiefRow.minQty, qty = thiefRow.maxQty, weight = thiefRow.wt, totalWeight = thiefRow.totalWt}) | |||
end | |||
--Bonus overtime: Special Fishing table & mining gem table. Also Rags to Riches | |||
if Shared.contains(SkillData.Fishing.JunkItems, item.id) then | |||
local fishSource = '[[Fishing#Junk|Junk]]' | |||
local fishType = Icons.Icon({'Fishing', type='skill'}) | |||
local fishTotWeight = Shared.tableCount(SkillData.Fishing.JunkItems) | |||
table.insert(dropRows, {source = fishSource, type = fishType, minqty = 1, qty = 1, weight = 1, totalWeight = fishTotWeight}) | |||
else | |||
local fishTotWeight, fishItem = 0, nil | |||
for i, specialItem in ipairs(SkillData.Fishing.SpecialItems) do | |||
if specialItem[1] == item.id then | |||
fishItem = specialItem | |||
end | |||
fishTotWeight = fishTotWeight + specialItem[2] | |||
end | |||
if fishItem ~= nil then | |||
local fishSource = '[[Fishing#Special|Special]]' | |||
local fishType = Icons.Icon({'Fishing', type='skill'}) | |||
table.insert(dropRows, {source = fishSource, type = fishType, minqty = fishItem[3], qty = fishItem[3], weight = fishItem[2], totalWeight = fishTotWeight}) | |||
end | |||
end | |||
--Jadestone is special and doesn't count | |||
if item.type == 'Gem' and item.name ~= 'Jadestone' then | |||
local mineType = Icons.Icon({'Mining', type='skill'}) | |||
local thisGemChance = Items.GemTable[item.name].chance | |||
local totalGemChance = 0 | |||
for i, gem in pairs(Items.GemTable) do | |||
totalGemChance = totalGemChance + gem.chance | |||
end | |||
table.insert(dropRows, {source = '[[Mining#Gems|Gem]]', type = mineType, minqty = 1, qty = 1, weight = thisGemChance, totalWeight = totalGemChance}) | |||
local magicType = Icons.Icon({'Magic', type = 'skill'}) | |||
for i, altSpell in ipairs(MagicData.AltMagic) do | |||
if type(altSpell.produces) == 'number' and altSpell.produces == -3 then | |||
table.insert(dropRows, {source = Icons.Icon({altSpell.name, type='spell'}), type = magicType, minqty = 1, qty = 1, weight = thisGemChance, totalWeight = totalGemChance}) | |||
end | |||
end | |||
end | |||
--Make sure to return nothing if there are no drop sources | |||
if Shared.tableCount(dropRows) == 0 then return '' end | |||
table.sort(dropRows, function(a, b) | |||
if a.weight / a.totalWeight == b.weight / b.totalWeight then | |||
if a.minqty + a.qty == b.minqty + b.qty then | |||
return (a.type == b.type and a.source < b.source) or a.type < b.type | |||
else | |||
return a.minqty + a.qty > b.minqty + b.qty | |||
end | |||
else | |||
return a.weight / a.totalWeight > b.weight / b.totalWeight | |||
end | |||
end) | |||
for i, data in pairs(dropRows) do | |||
table.insert(resultPart, buildRow(data.source, data.type, data.minqty, data.qty, data.weight, data.totalWeight)) | |||
end | |||
table.insert(resultPart, '\r\n|}') | |||
return table.concat(resultPart) | |||
end | end | ||
function p.getItemLootSourceTable(frame) | function p.getItemLootSourceTable(frame) | ||
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[[Category:Pages with script errors]]" | |||
end | |||
return p._getItemLootSourceTable(item) | |||
end | end | ||
function p._getItemUpgradeTable(item) | function p._getItemUpgradeTable(item) | ||
local resultPart = {} | |||
if item.itemsRequired ~= nil then | |||
--First, get details on all the required materials | |||
local upgradeFrom = {} | |||
local materials = {} | |||
for i, row in pairs(item.itemsRequired) do | |||
local mat = Items.getItemByID(row[1]) | |||
--Check to see if the source item can trigger the upgrade | |||
if mat.canUpgrade or (mat.type == 'Armour' and mat.canUpgrade == nil) then | |||
table.insert(upgradeFrom, Icons.Icon({mat.name, type='item'})) | |||
end | |||
table.insert(materials, Icons.Icon({mat.name, type='item', qty=row[2]})) | |||
end | |||
if type(item.trimmedGPCost) == 'number' and item.trimmedGPCost > 0 then | |||
table.insert(materials, Icons.GP(item.trimmedGPCost)) | |||
end | |||
table.insert(resultPart, '{| class="wikitable"\r\n|-\r\n!colspan="2"|[[Upgrading Items|Item Upgrade]]') | |||
--[[result = result..'\r\n|-\r\n!style="text-align:right;"|Upgrades From\r\n|' | |||
result = result..table.concat(upgradeFrom, '<br/>')--]] | |||
table.insert(resultPart, '\r\n|-\r\n!style="text-align:right;"|Materials\r\n|') | |||
table.insert(resultPart, table.concat(materials, '<br/>')) | |||
table.insert(resultPart, '\r\n|}') | |||
end | |||
return table.concat(resultPart) | |||
end | end | ||
function p.getItemUpgradeTable(frame) | function p.getItemUpgradeTable(frame) | ||
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[[Category:Pages with script errors]]" | |||
end | |||
return p._getItemUpgradeTable(item) | |||
end | end | ||
function p._getItemSuperheatTable(item) | function p._getItemSuperheatTable(item) | ||
--Manually build the Superheat Item table | |||
-- Validate that the item can be superheated | |||
local canSuperheat, smithRecipe = true, nil | |||
if type(item.masteryID) ~= 'table' then | |||
canSuperheat = false | |||
elseif item.masteryID[1] ~= SkillEnum.Smithing then | |||
canSuperheat = false | |||
else | |||
smithRecipe = SkillData.Smithing.Recipes[item.masteryID[2] + 1] | |||
if smithRecipe == nil or smithRecipe.category ~= 0 then | |||
canSuperheat = false | |||
end | |||
end | |||
if not canSuperheat then | |||
return 'ERROR: The item "' .. item.name .. '" cannot be superheated[[Category:Pages with script errors]]' | |||
end | |||
local oreStringPart, coalString = {}, '' | |||
for i, mat in ipairs(smithRecipe.itemCosts) do | |||
local thisMat = Items.getItemByID(mat.id) | |||
if thisMat.name == 'Coal Ore' then | |||
coalString = Icons.Icon({thisMat.name, type='item', notext='true', qty=mat.qty}) | |||
else | |||
table.insert(oreStringPart, Icons.Icon({thisMat.name, type='item', notext='true', qty=mat.qty})) | |||
end | |||
end | |||
--Set up the header | |||
local superheatTable = {} | |||
table.insert(superheatTable, '{|class="wikitable"\r\n!colspan="2"|Spell') | |||
table.insert(superheatTable, '!!'..Icons.Icon({'Smithing', type='skill', notext='true'})..' Level') | |||
table.insert(superheatTable, '!!'..Icons.Icon({'Magic', type='skill', notext='true'})..' Level') | |||
table.insert(superheatTable, '!!'..Icons.Icon({'Magic', type='skill', notext='true'})..' XP') | |||
table.insert(superheatTable, '!!'..Icons.Icon({item.name, type='item', notext='true'})..' Bars') | |||
table.insert(superheatTable, '!!Ore!!Runes') | |||
--Loop through all the variants | |||
local spellNames = {'Superheat I', 'Superheat II', 'Superheat III', 'Superheat IV'} | |||
for i, sName in pairs(spellNames) do | |||
local spell = Magic.getSpell(sName, 'AltMagic') | |||
table.insert(superheatTable, '\r\n|-\r\n|'..Icons.Icon({spell.name, type='spell', notext=true, size=50})) | |||
table.insert(superheatTable, '||'..Icons.Icon({spell.name, type='spell', noicon=true})..'||style="text-align:right;"|'..smithRecipe.level) | |||
table.insert(superheatTable, '||style="text-align:right;"|'..spell.level..'||style="text-align:right;"|'..spell.baseExperience) | |||
table.insert(superheatTable, '||style="text-align:right;"|'..spell.productionRatio) | |||
table.insert(superheatTable, '|| '..table.concat(oreStringPart, ', ')) | |||
if spell.consumes == 2 and coalString ~= '' then | |||
-- 2 = Superheat with coal, 3 = Superheat without coal | |||
table.insert(superheatTable, (Shared.tableCount(oreStringPart) > 0 and ', ' or '') .. coalString) | |||
end | |||
table.insert(superheatTable, '||style="text-align:center"| ' .. Magic._getSpellRunes(spell)) | |||
end | |||
--Add the table end and add the table to the result string | |||
table.insert(superheatTable, '\r\n|}') | |||
return table.concat(superheatTable) | |||
end | end | ||
function p.getItemSuperheatTable(frame) | function p.getItemSuperheatTable(frame) | ||
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[[Category:Pages with script errors]]" | |||
end | |||
return p._getItemSuperheatTable(item) | |||
end | end | ||
function p._getItemSourceTables(item) | function p._getItemSourceTables(item) | ||
local resultPart = {} | |||
local shopTable = Shop._getItemShopTable(item) | |||
if string.len(shopTable) > 0 then | |||
table.insert(resultPart, '===Shop===\r\n'..shopTable) | |||
end | |||
local creationTable = p._getCreationTable(item) | |||
if string.len(creationTable) > 0 then | |||
if #resultPart > 0 then table.insert(resultPart, '\r\n') end | |||
table.insert(resultPart, '===Creation===\r\n'..creationTable) | |||
end | |||
local upgradeTable = p._getItemUpgradeTable(item) | |||
if string.len(upgradeTable) > 0 then | |||
if #resultPart > 0 then table.insert(resultPart, '\r\n') end | |||
if string.len(creationTable) == 0 then table.insert(resultPart, '===Creation===\r\n') end | |||
table.insert(resultPart, upgradeTable) | |||
end | |||
if type(item.masteryID) == 'table' and item.masteryID[1] == SkillEnum.Smithing then | |||
local recipe = SkillData.Smithing.Recipes[item.masteryID[2] + 1] | |||
if recipe ~= nil and recipe.category == 0 then | |||
table.insert(resultPart, '\r\n==='..Icons.Icon({'Alt. Magic', type='skill'})..'===\r\n'..p._getItemSuperheatTable(item)) | |||
end | |||
end | |||
local lootTable = p._getItemLootSourceTable(item) | |||
if string.len(lootTable) > 0 then | |||
if #resultPart > 0 then table.insert(resultPart, '\r\n') end | |||
table.insert(resultPart, '===Loot===\r\n'..lootTable) | |||
end | |||
return table.concat(resultPart) | |||
end | end | ||
function p.getItemSourceTables(frame) | function p.getItemSourceTables(frame) | ||
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[[Category:Pages with script errors]]" | |||
end | |||
return p._getItemSourceTables(item) | |||
end | end | ||
function p.getCombatPassiveSlotItems(frame) | function p.getCombatPassiveSlotItems(frame) | ||
local resultPart = {} | |||
table.insert(resultPart, '{| class="wikitable"\r\n') | |||
table.insert(resultPart, '|-\r\n') | |||
table.insert(resultPart, '!colspan="2"|Item\r\n! Passive\r\n') | |||
local itemArray = Items.getItems(function(item) return item.validSlots ~= nil and Shared.contains(item.validSlots, 'Passive') end) | |||
table.sort(itemArray, function(a, b) return a.id < b.id end) | |||
for i, item in ipairs(itemArray) do | |||
table.insert(resultPart, '|-\r\n') | |||
table.insert(resultPart, '! '..Icons.Icon({item.name, type='item', notext='true'})..'\r\n! '..Icons.Icon({item.name, type='item', noicon=true})..'\r\n') | |||
table.insert(resultPart, '| '..item.description..'\r\n') | |||
end | |||
table.insert(resultPart, '|}') | |||
return table.concat(resultPart) | |||
end | |||
return | function p._getItemMonsterSources(item) | ||
local resultArray = {} | |||
for i, monster in ipairs(MonsterData.Monsters) do | |||
local chance = 0 | |||
local weight = 0 | |||
local minQty = 1 | |||
local maxQty = 1 | |||
if monster.bones == item.id and Monsters._getMonsterBones(monster) ~= nil then | |||
-- Item is a bone, and is either a shard from God dungeons or dropped by a non-boss monster with a loot table | |||
chance = 1 | |||
weight = 1 | |||
if monster.boneQty ~= nil then | |||
minQty = monster.boneQty | |||
maxQty = monster.boneQty | |||
end | |||
elseif monster.lootTable ~= nil then | |||
-- If the monster has a loot table, check if the item we are looking for is in there | |||
-- Dungeon exclusive monsters don't count as they are either: | |||
-- - A monster before the boss, which doesn't drop anything except shards (checked above) | |||
-- - A boss monster, whose drops are accounted for in data from Areas instead | |||
for j, loot in ipairs(monster.lootTable) do | |||
weight = weight + loot[2] | |||
if loot[1] == item.id and not Monsters._isDungeonOnlyMonster(monster) then | |||
chance = loot[2] | |||
maxQty = loot[3] | |||
end | |||
end | |||
local lootChance = monster.lootChance ~= nil and monster.lootChance or 100 | |||
chance = chance * lootChance | |||
weight = weight * 100 | |||
chance, weight = Shared.fractionpair(chance, weight) | |||
end | |||
if chance > 0 then | |||
-- Item drops when the monster is killed | |||
table.insert(resultArray, {id = monster.id, dropWt = chance, totalWt = weight, minQty = minQty, maxQty = maxQty}) | |||
end | |||
end | |||
return resultArray | |||
end | |||
function p.getItemMonsterSources(itemName) | |||
local item = Items.getItem(itemName) | |||
return p._getItemMonsterSources(item) | |||
end | |||
--[==[ | |||
-- 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', | |||
'Yew Longbow', | |||
'Water Rune', | |||
'Steam Rune', | |||
'Controlled Heat Potion II', | |||
'Wolf', | |||
'Cyclops', | |||
'Leprechaun', | |||
'Redwood Logs', | |||
'Carrot Cake', | |||
'Carrot Cake (Perfect)', | |||
'Mantalyme Herb', | |||
'Carrot', | |||
'Topaz', | |||
'Rune Essence', | |||
'Sanguine Blade', | |||
'Ring of Power', | |||
'Infernal Claw', | |||
'Chapeau Noir', | |||
'Stardust', | |||
'Rope', | |||
'Ancient Ring of Mastery', | |||
'Mysterious Stone', | |||
'Mastery Token (Cooking)', | |||
'Gem Gloves', | |||
"Thief's Moneysack" | |||
} | |||
local checkFuncs = { | |||
p.getItemSourceTables, | |||
--p.getCreationTable, | |||
p.getItemSources, | |||
--p.getItemLootSourceTable, | |||
} | |||
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 |