12,883
edits
(_getItemLootSourceTable: Amend display of very small chances) |
(Alt Magic -> Alt. Magic for consistency) |
||
(15 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 | 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 | ||
Line 37: | Line 39: | ||
local tables = {} | local tables = {} | ||
--First figure out what skill is used to make this... | --First figure out what skill is used to make this... | ||
if item. | 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 | ||
end | end | ||
if item. | |||
for i, | -- 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 | ||
end | end | ||
if item. | -- 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 | ||
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 | |||
if item. | |||
-- | |||
--Logs might mean farming or might not. Depends on the | |||
for i, | |||
if | |||
skill = 'Farming' | skill = 'Farming' | ||
lvl = | lvl = seed.farmingLevel | ||
xp = | xp = seed.farmingXP | ||
time = | time = seed.timeToGrow | ||
if item.type == 'Logs' then | if item.type == 'Logs' then | ||
qty = 35 | qty = 35 | ||
Line 145: | Line 218: | ||
qty = 15 | qty = 15 | ||
end | end | ||
req = {{id = | req = {{id = seed.id, qty = (seed.seedsRequired ~= nil and seed.seedsRequired or 1)}} | ||
table.insert(tables, p.buildCreationTable(skill, lvl, xp, req, qty, time)) | table.insert(tables, p.buildCreationTable(skill, lvl, xp, req, qty, time)) | ||
break | break | ||
end | end | ||
end | 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 | end | ||
Line 223: | Line 241: | ||
end | end | ||
function p. | function p.getAltMagicTable(frame) | ||
local spellName = frame.args ~= nil and frame.args[1] or frame | |||
local spell = Magic.getSpell(spellName, 'AltMagic') | 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 | |||
function p._buildAltMagicTable(spell) | |||
local resultPart = {} | local resultPart = {} | ||
table.insert(resultPart, '{|class="wikitable"\r\n|-') | table.insert(resultPart, '{|class="wikitable"\r\n|-') | ||
Line 230: | Line 257: | ||
table.insert(resultPart, '\r\n|-\r\n!style="text-align:right;"|Requirements') | table.insert(resultPart, '\r\n|-\r\n!style="text-align:right;"|Requirements') | ||
table.insert(resultPart, '\r\n|'..Icons._SkillReq('Magic', spell.level)) | table.insert(resultPart, '\r\n|'..Icons._SkillReq('Magic', spell.level)) | ||
-- 1 | |||
-- - | -- The produces property of Alt. Magic spells is as follows: | ||
if spell. | -- -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 | end | ||
--Add runes | --Add runes | ||
table.insert(resultPart, '\r\n|-\r\n!style="text-align:right;"|Runes\r\n|' | 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) | --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. | 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. | 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|-\r\n!style="text-align:right;"|Cast Time\r\n|2s') | ||
table.insert(resultPart, '\r\n|}') | table.insert(resultPart, '\r\n|}') | ||
Line 260: | Line 301: | ||
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 | if qty == nil then qty = 1 end | ||
local resultPart = {} | local resultPart = {} | ||
Line 288: | Line 329: | ||
table.insert(resultPart, '<br/>') | table.insert(resultPart, '<br/>') | ||
table.insert(resultPart, Icons.GP(gpCost)) | 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 | end | ||
else | else | ||
Line 299: | Line 344: | ||
table.insert(resultPart, '\r\n|-\r\n!style="text-align:right;"|Base Creation Time') | 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') | table.insert(resultPart, '\r\n|'..Shared.formatnum(Shared.round(time, 2, 0))..'s') | ||
if maxTime ~= nil then table.insert(resultPart, ' - '..Shared.formatnum(Shared.round(maxTime, 2, 0))..'s') end | if maxTime ~= nil and maxTime > time then table.insert(resultPart, ' - '..Shared.formatnum(Shared.round(maxTime, 2, 0))..'s') end | ||
table.insert(resultPart, '\r\n|}') | table.insert(resultPart, '\r\n|}') | ||
Line 324: | Line 369: | ||
for i, monster in ipairs(MonsterData.Monsters) do | for i, monster in ipairs(MonsterData.Monsters) do | ||
local isDrop = false | local isDrop = false | ||
if monster.bones == item.id and Monsters. | 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 | -- 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 | isDrop = true | ||
Line 341: | Line 386: | ||
if isDrop then | if isDrop then | ||
-- Item drops when the monster is killed | -- Item drops when the monster is killed | ||
table.insert(killStrPart, Icons.Icon({monster.name, type='monster', notext=true})) | table.insert(killStrPart, Icons.Icon({monster.name, type='monster', notext=true})) | ||
end | end | ||
end | end | ||
Line 360: | Line 405: | ||
end | end | ||
end | end | ||
-- Special exceptions for | -- Special exceptions for lore books | ||
if sourceOverrides['Dungeon'][item.id] ~= nil then | if sourceOverrides['Dungeon'][item.id] ~= nil then | ||
table.insert(dungeonStrPart, Icons.Icon({sourceOverrides['Dungeon'][item.id], type='dungeon', notext=true})) | table.insert(dungeonStrPart, Icons.Icon({sourceOverrides['Dungeon'][item.id], type='dungeon', notext=true})) | ||
Line 373: | Line 418: | ||
--Next: Can we find it in a box? | --Next: Can we find it in a box? | ||
--While we're here, check for upgrades | --While we're here, check for upgrades, and growing | ||
local | local lootPart, upgradePart, growPart = {}, {}, {} | ||
for i, item2 in pairs(ItemData.Items) do | for i, item2 in pairs(ItemData.Items) do | ||
if item2.dropTable ~= nil then | if item2.dropTable ~= nil then | ||
for j, loot in | for j, loot in ipairs(item2.dropTable) do | ||
if loot[1] == item.id then | if loot[1] == item.id then | ||
table.insert(lootPart, Icons.Icon({item2.name, type='item', notext=true})) | |||
break | |||
end | end | ||
end | end | ||
end | end | ||
if item2.trimmedItemID == item.id then | if item2.trimmedItemID ~= nil and item2.trimmedItemID == item.id then | ||
table.insert(upgradePart, Icons.Icon({item2.name, type='item', notext=true})) | |||
end | end | ||
if item2.grownItemID == item.id then | if item2.grownItemID == item.id then | ||
-- Farming | |||
table.insert(growPart, Icons.Icon({item2.name, type='item', notext=true})) | |||
end | end | ||
end | end | ||
if | if #lootPart > 0 then | ||
if | table.insert(lineArray, 'Opening: ' .. table.concat(lootPart, ',')) | ||
if | 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? | --Next: Can we take it from somebody else -without- killing them? | ||
local thiefItems = | local thiefItems = Skills.getThievingSourcesForItem(item.id) | ||
if type(thiefItems) == 'table' then | |||
if | local thiefPart = {} | ||
for i, thiefRow in ipairs(thiefItems) do | |||
for i, thiefRow in | |||
if thiefRow.npc == 'all' then | if thiefRow.npc == 'all' then | ||
--if ' | --if 'all' is the npc, this is a rare item so just say 'Thieving level 1' | ||
table.insert(lineArray, Icons._SkillReq('Thieving', 1)) | |||
else | else | ||
table.insert(thiefPart, Icons.Icon({thiefRow.npc, type='thieving', notext=true})) | |||
end | end | ||
end | |||
if #thiefPart > 0 then | |||
table.insert(lineArray, 'Pickpocketing: ' .. table.concat(thiefPart, ',')) | |||
end | end | ||
end | end | ||
-- | --Check if we can make it ourselves | ||
--AstrologyCheck | --AstrologyCheck (Just a brute force for now because only two items) | ||
if Shared.contains({'Stardust', 'Golden Stardust'}, item.name) then | |||
if | table.insert(lineArray, Icons.Icon({'Astrology', type='skill'})) | ||
table.insert(lineArray, Icons.Icon({ | |||
end | end | ||
-- | -- Sources discoverable through mastery IDs | ||
if item. | -- 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 | end | ||
-- | -- Woodcutting | ||
if item. | 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 | end | ||
-- | -- Woodcutting: Nests | ||
if item. | if item.name == 'Bird Nest' then | ||
table.insert(lineArray, Icons._SkillReq( | table.insert(lineArray, Icons._SkillReq('Woodcutting', 1)) | ||
end | end | ||
-- | -- Fishing: Junk & Specials | ||
if | if Shared.contains(SkillData.Fishing.JunkItems, item.id) then | ||
table.insert(lineArray, Icons. | 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 | end | ||
-- | -- Cooking | ||
if item. | 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 | end | ||
-- | -- Alt. Magic | ||
if ( | 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 | end | ||
Line 508: | Line 568: | ||
end | end | ||
--Gems can be acquired from | --Gems can be acquired from Mining | ||
if item.type == 'Gem' and item.name ~= 'Jadestone' then | if item.type == 'Gem' and item.name ~= 'Jadestone' then | ||
table.insert(lineArray, Icons.Icon({"Mining", type='skill', notext=true})..' [[Mining#Gems|Gem]]') | table.insert(lineArray, Icons.Icon({"Mining", type='skill', notext=true})..' [[Mining#Gems|Gem]]') | ||
end | end | ||
Line 526: | Line 579: | ||
Jewel = {'Firemaking', 'Cooking', 'Smithing', 'Fletching', 'Crafting', 'Runecrafting', 'Herblore', 'Summoning'} | Jewel = {'Firemaking', 'Cooking', 'Smithing', 'Fletching', 'Crafting', 'Runecrafting', 'Herblore', 'Summoning'} | ||
} | } | ||
local rhaSkList = | local rhaSkList, subText = nil, '' | ||
if item.name == 'Circlet of Rhaelyx' then | if item.name == 'Circlet of Rhaelyx' then | ||
rhaSkList = rhaSkills.Circlet | rhaSkList = {rhaSkills.Circlet} | ||
elseif item.name == 'Jewel of Rhaelyx' then | elseif item.name == 'Jewel of Rhaelyx' then | ||
rhaSkList = rhaSkills.Jewel | rhaSkList = {rhaSkills.Jewel} | ||
elseif item.name == 'Mysterious Stone' then | elseif item.name == 'Mysterious Stone' then | ||
rhaSkList = rhaSkills.Jewel | rhaSkList = {rhaSkills.Jewel, rhaSkills.Circlet} | ||
subText = '<br/>after finding ' .. Icons.Icon({'Crown of Rhaelyx', type='item'}) | |||
end | end | ||
local rhaStrPart = {} | local rhaStrPart = {} | ||
for i, | for i, skillList in ipairs(rhaSkList) do | ||
table.insert(rhaStrPart, Icons.Icon({skillName, type='skill', notext=true})) | for j, skillName in ipairs(skillList) do | ||
table.insert(rhaStrPart, Icons.Icon({skillName, type='skill', notext=true})) | |||
end | |||
end | end | ||
table.insert(lineArray, 'Any action in: ' .. table.concat(rhaStrPart, ', ') .. subText) | |||
end | end | ||
Line 550: | Line 601: | ||
if item.isToken and item.skill ~= nil then | if item.isToken and item.skill ~= nil then | ||
table.insert(lineArray, Icons._SkillReq(Constants.getSkillName(item.skill), 1)) | 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 | end | ||
Line 566: | Line 622: | ||
table.insert(lineArray, '[[Events]]') | table.insert(lineArray, '[[Events]]') | ||
end | end | ||
--Gold Topaz Ring drops from any action (when not wearing a Gold Topaz Ring) | --Gold Topaz Ring drops from any action (when not wearing a Gold Topaz Ring) | ||
--Also handling Signet Ring things here | --Also handling Signet Ring things here | ||
Line 618: | Line 674: | ||
table.insert(rowPart, '\r\n|style="text-align: left;"|'..type) | table.insert(rowPart, '\r\n|style="text-align: left;"|'..type) | ||
table.insert(rowPart, '\r\n|style="text-align: right;" data-sort-value="'..qty..'"|'..minqty) | table.insert(rowPart, '\r\n|style="text-align: right;" data-sort-value="'..qty..'"|'..Shared.formatnum(minqty)) | ||
if qty ~= minqty then table.insert(rowPart, ' - '..qty) end | if qty ~= minqty then table.insert(rowPart, ' - '..Shared.formatnum(qty)) end | ||
local chance = weight / totalWeight * 100 | local chance = weight / totalWeight * 100 | ||
-- If chance is less than 0.10% then show 2 significant figures, otherwise 2 decimal places | -- If chance is less than 0.10% then show 2 significant figures, otherwise 2 decimal places | ||
Line 657: | Line 713: | ||
--Only add bones if this monster has loot (ie appears outside a dungeon) and isn't a boss | --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 | --... 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. | if monster.bones == item.id and Monsters._getMonsterBones(monster) ~= nil then | ||
qty = monster.boneQty ~= nil and monster.boneQty or 1 | qty = monster.boneQty ~= nil and monster.boneQty or 1 | ||
minqty = qty | minqty = qty | ||
Line 704: | Line 760: | ||
--Next: Can we find it by rummaging around in another item? | --Next: Can we find it by rummaging around in another item? | ||
for i, item2 in | for i, item2 in ipairs(ItemData.Items) do | ||
if item2.dropTable ~= nil then | if item2.dropTable ~= nil then | ||
local qty = 1 | local qty = 1 | ||
Line 726: | Line 782: | ||
--Finally, let's try just stealing it | --Finally, let's try just stealing it | ||
local thiefType = Icons.Icon({"Thieving", type='skill'}) | local thiefType = Icons.Icon({"Thieving", type='skill'}) | ||
local thiefItems = | local thiefItems = Skills.getThievingSourcesForItem(item.id) | ||
for i, thiefRow in | for i, thiefRow in ipairs(thiefItems) do | ||
local sourceTxt = '' | local sourceTxt = '' | ||
if thiefRow.npc == 'all' then | if thiefRow.npc == 'all' then | ||
Line 738: | Line 794: | ||
--Bonus overtime: Special Fishing table & mining gem table. Also Rags to Riches | --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 | --Jadestone is special and doesn't count | ||
if item.type == 'Gem' and item.name ~= 'Jadestone' then | if item.type == 'Gem' and item.name ~= 'Jadestone' then | ||
Line 748: | Line 823: | ||
table.insert(dropRows, {source = '[[Mining#Gems|Gem]]', type = mineType, minqty = 1, qty = 1, weight = thisGemChance, totalWeight = totalGemChance}) | table.insert(dropRows, {source = '[[Mining#Gems|Gem]]', type = mineType, minqty = 1, qty = 1, weight = thisGemChance, totalWeight = totalGemChance}) | ||
local magicType = Icons.Icon({'Magic', type = 'skill'}) | 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 | end | ||
Line 769: | Line 835: | ||
table.sort(dropRows, function(a, b) | table.sort(dropRows, function(a, b) | ||
if a.weight / a.totalWeight == b.weight / b.totalWeight then | if a.weight / a.totalWeight == b.weight / b.totalWeight then | ||
return a.minqty + a.qty > b.minqty + b.qty | 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 | else | ||
return a.weight / a.totalWeight > b.weight / b.totalWeight | return a.weight / a.totalWeight > b.weight / b.totalWeight | ||
Line 806: | Line 876: | ||
table.insert(materials, Icons.Icon({mat.name, type='item', qty=row[2]})) | table.insert(materials, Icons.Icon({mat.name, type='item', qty=row[2]})) | ||
end | end | ||
if item.trimmedGPCost | if type(item.trimmedGPCost) == 'number' and item.trimmedGPCost > 0 then | ||
table.insert(materials, Icons.GP(item.trimmedGPCost)) | table.insert(materials, Icons.GP(item.trimmedGPCost)) | ||
end | end | ||
Line 831: | Line 901: | ||
function p._getItemSuperheatTable(item) | function p._getItemSuperheatTable(item) | ||
--Manually build the Superheat Item table | --Manually build the Superheat Item table | ||
local | -- Validate that the item can be superheated | ||
local coalString = '' | local canSuperheat, smithRecipe = true, nil | ||
for i, mat in | 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) | local thisMat = Items.getItemByID(mat.id) | ||
if thisMat.name == 'Coal Ore' then | if thisMat.name == 'Coal Ore' then | ||
coalString = | coalString = Icons.Icon({thisMat.name, type='item', notext='true', qty=mat.qty}) | ||
else | else | ||
table.insert(oreStringPart, Icons.Icon({thisMat.name, type='item', notext='true', qty=mat.qty})) | |||
end | end | ||
end | end | ||
Line 854: | Line 938: | ||
for i, sName in pairs(spellNames) do | for i, sName in pairs(spellNames) do | ||
local spell = Magic.getSpell(sName, 'AltMagic') | 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( | table.insert(superheatTable, '||'..Icons.Icon({spell.name, type='spell', noicon=true})..'||style="text-align:right;"|'..smithRecipe.level) | ||
table.insert( | table.insert(superheatTable, '||style="text-align:right;"|'..spell.level..'||style="text-align:right;"|'..spell.baseExperience) | ||
table.insert( | table.insert(superheatTable, '||style="text-align:right;"|'..spell.productionRatio) | ||
table.insert( | table.insert(superheatTable, '|| '..table.concat(oreStringPart, ', ')) | ||
if spell. | 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 | end | ||
table.insert( | table.insert(superheatTable, '||style="text-align:center"| ' .. Magic._getSpellRunes(spell)) | ||
end | end | ||
--Add the table end and add the table to the result string | --Add the table end and add the table to the result string | ||
Line 909: | Line 984: | ||
end | end | ||
if item. | if type(item.masteryID) == 'table' and item.masteryID[1] == SkillEnum.Smithing then | ||
table.insert(resultPart, '\r\n==='..Icons.Icon({'Alt Magic', type='skill'})..'===\r\n'..p._getItemSuperheatTable(item)) | 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 | end | ||
Line 951: | Line 1,029: | ||
return table.concat(resultPart) | return table.concat(resultPart) | ||
end | end | ||
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 | |||
--]==] | |||
return p | return p |