Module:Tombs of Amascut loot
Module documentation
This documentation is transcluded from Module:Tombs of Amascut loot/doc. [edit] [history] [purge]
Module:Tombs of Amascut loot's function main is invoked by Calculator:Tombs of Amascut loot.
Module:Tombs of Amascut loot requires Module:Exchange.
Module:Tombs of Amascut loot requires Module:Less Stupid Coins.
Module:Tombs of Amascut loot requires Module:Tables.
local gePrice = require('Module:Exchange')._price
local coins = require('Module:Less Stupid Coins')._amount
local tables = require('Module:Tables')
local lang = mw.language.getContentLanguage()
local p = {}
local PATH_INVOCATIONS = {None = 0, Pathseeker = 1, Pathfinder = 2, Pathmaster = 3}
local NORMAL_LOOT = {
{item = "Coins", divisor = 1},
{item = "Death rune", divisor = 20},
{item = "Soul rune", divisor = 40},
{item = "Gold ore", divisor = 90},
{item = "Dragon dart tip", divisor = 100},
{item = "Mahogany logs", divisor = 180},
{item = "Sapphire", divisor = 200},
{item = "Emerald", divisor = 250},
{item = "Gold bar", divisor = 250},
{item = "Potato cactus", divisor = 250},
{item = "Raw shark", divisor = 250},
{item = "Ruby", divisor = 300},
{item = "Diamond", divisor = 400},
{item = "Raw manta ray", divisor = 450},
{item = "Cactus spine", divisor = 600},
{item = "Dragonstone", divisor = 600},
{item = "Battlestaff", divisor = 1100},
{item = "Coconut milk", divisor = 1100},
{item = "Lily of the sands", divisor = 1100},
{item = "Toadflax seed", divisor = 1400},
{item = "Ranarr seed", divisor = 1800},
{item = "Torstol seed", divisor = 2200},
{item = "Snapdragon seed", divisor = 2200},
{item = "Dragon med helm", divisor = 4000},
{item = "Magic seed", divisor = 6500},
{item = "Blood essence", divisor = 7500},
{item = "Cache of runes", divisor = 999999}
}
local PURPLES = {
{item = "Tumeken's shadow (uncharged)", weight = 1, level = 150},
{item = "Masori mask", weight = 2, level = 150},
{item = "Masori body", weight = 2, level = 150},
{item = "Masori chaps", weight = 2, level = 150},
{item = "Elidinis' ward", weight = 3, level = 150},
{item = "Osmumten's fang", weight = 7, level = 50},
{item = "Lightbearer", weight = 7, level = 50}
}
local TEAM_SIZE_SCALE = {
[1] = 1.0,
[2] = 1.9,
[3] = 2.8,
[4] = 3.4,
[5] = 4.0,
[6] = 4.6,
[7] = 5.2,
[8] = 5.8
}
function p.main(frame)
local frame = frame or {}
local args = frame.args or {}
local raid_level = tonumber(args.raid_level) or 550
local team_size = tonumber(args.team_size) or 8
local path_invocation = PATH_INVOCATIONS[args.path_invocation or 'None'] or 0
local walk_the_path = args.walk_the_path == 'yes'
local leagues_harder_mode = args.leagues_harder_mode == 'yes'
out = p.calculator(raid_level, team_size, path_invocation, walk_the_path, leagues_harder_mode)
mw.log(out)
return out
end
function scale_hp(base, raid_level, team_size, path_level)
local path_multiplier = 1.0
if path_level > 0 then
-- this isn't perfectly accurate because 0, 8, 13, 18... isn't linear, but it's close enough
path_multiplier = 1.03 + path_level * 0.05
end
-- this seems to round to the nearest 5 or 10, but the exact rounding semantics aren't clear (and we're already doing some averaging with WTP)
return math.floor(base * (1 + raid_level / 250) * TEAM_SIZE_SCALE[team_size] * path_multiplier)
end
function p.estimate_points(raid_level, team_size, path_invocation, walk_the_path)
-- to keep inputs simple, for WTP we assume the order is Ba-Ba, Kephri, Zebak, Akkha
-- it doesn't make a significant difference if the order is shuffled, as the bosses
-- generally have similar total point contributions
local AVERAGE_WTP_LEVEL = {[0] = 0, [1] = 0, [2] = 0, [3] = 0}
if walk_the_path then
AVERAGE_WTP_LEVEL = {[0] = 0, [1] = 4/6, [2] = 7/6, [3] = 13/6}
end
local points_table = {
{name = "Akkha", hp = scale_hp(480, raid_level, team_size, path_invocation + AVERAGE_WTP_LEVEL[3]), mult = 1.0, approx = walk_the_path},
{name = "Akkha's Shadow", hp = scale_hp(70, raid_level, team_size, path_invocation + AVERAGE_WTP_LEVEL[3]), mult = 1.0, count = 4}, -- path levels affect hp
{name = "Baboons", hp = scale_hp(300, raid_level, team_size, 0), mult = 1.2, approx = true},
{name = "Ba-Ba", hp = scale_hp(380, raid_level, team_size, path_invocation + AVERAGE_WTP_LEVEL[0]), mult = 2.0, approx = walk_the_path},
{name = "Zebak", hp = scale_hp(580, raid_level, team_size, path_invocation + AVERAGE_WTP_LEVEL[2]), mult = 1.5, approx = walk_the_path},
{name = "Scarab Swarms", hp = 200, mult = 1.0, approx = true},
{name = "Scarabs", hp = 200, mult = 0.5, approx = true},
{name = "Kephri's Shield", hp = scale_hp(375, raid_level, team_size, path_invocation + AVERAGE_WTP_LEVEL[1]), mult = 1.0, approx = true}, -- assuming the shield regenerates a total of 150% across two regen cycles - probably less in good groups
{name = "Kephri", hp = scale_hp(130, raid_level, team_size, path_invocation + AVERAGE_WTP_LEVEL[1]), mult = 1.0, approx = walk_the_path},
{name = "P1 Obelisk", hp = scale_hp(260, raid_level, team_size, 0), mult = 1.5},
{name = "P2 Warden", hp = scale_hp(140, raid_level, team_size, 0), mult = 2.0, count = 2},
{name = "P3 Warden", hp = scale_hp(880, raid_level, team_size, 0), mult = 2.5},
{name = "Misc. damage", hp = 80 * team_size, mult = 1.0, approx = true},
{name = "Het - seal mining", hp = 130 + math.floor(95.81 * (team_size - 1)), mult = 2.5}, -- not sure why this is the scaling, but it matches at 1, 2, 3, 4, 7
{name = "Scabaras - puzzles", points = 300 * team_size, approx = true}, -- assuming 3 puzzles per person
{name = "Apmeken - traps", points = 450 * team_size, approx = true}, -- assuming 6 fix-trap cycles, 75 points each
{name = "Crondis - palm watering", points = 400 * team_size}, -- 2 points per health, 200 health per person
{name = "MVP", points = 2700 * team_size}, -- 9 rooms, 300 per person
}
local total_points = 0
for _, v in ipairs(points_table) do
if v.points then
total_points = total_points + v.points
else
total_points = total_points + math.floor(v.hp * v.mult * (v.count or 1))
end
end
return {total = total_points, points_table = points_table}
end
function p.get_rewards(points, raid_level, team_size, leagues_harder_mode)
local adjusted_raid_level = raid_level
if raid_level > 400 then
adjusted_raid_level = 400 + math.floor((raid_level - 400) / 3)
end
local purple_denominator = 100 * (10500 - 20 * adjusted_raid_level)
local pet_denominator
if leagues_harder_mode then -- leagues none sense
purple_denominator = math.max(purple_denominator, points) -- no cap fr fr
pet_denominator = 100 * (350000 - 700 * math.min(adjusted_raid_level, 466)) -- we dont know if this is correct
else
purple_denominator = math.max(purple_denominator, 150000) -- caps at 1500
pet_denominator = 100 * (350000 - 700 * adjusted_raid_level)
end
local elite_clue_denominator = 200000
local scale = 1
local description = ""
if raid_level < 150 then
scale = 0.75
description = "decreased by '''25%'''"
elseif raid_level >= 300 then
local percent = math.floor((raid_level - 300) / 5) + 15
scale = 1 + percent / 100
description = string.format("increased by '''%d%%'''", percent)
end
if description ~= "" then
description = string.format("With a raid level of '''%d''', normal loot is %s from the baseline.", raid_level, description)
end
description = "Normal loot always gives 3 rolls, and each of the 27 items is equally likely. " .. description
normal_loot = {}
for _, v in ipairs(NORMAL_LOOT) do
local quantity = math.floor(points / team_size / v.divisor)
quantity = math.floor(quantity * scale)
quantity = math.max(quantity, 1)
local price = 0
if v.item == "Cache of runes" then
price = 1700 / 3 * (gePrice("Blood rune") + gePrice("Soul rune") + gePrice("Death rune"))
elseif v.item == "Coins" then
price = 1
else
price = gePrice(v.item)
end
table.insert(normal_loot, {item = v.item, quantity = quantity, price = price})
end
local base_purple_rate = math.min(points / purple_denominator, 0.55)
local unique_loot = {}
local true_purple_rate = 0.0
for _, v in ipairs(PURPLES) do
local true_rate = base_purple_rate * v.weight / 24
if raid_level < v.level then
true_rate = true_rate / 50
end
true_purple_rate = true_purple_rate + true_rate
table.insert(unique_loot, {item = v.item, chance = true_rate / team_size, price = gePrice(v.item)})
end
table.insert(unique_loot, {item = "Tumeken's guardian", chance = points / pet_denominator / team_size, price = nil})
table.insert(unique_loot, {item = "Clue scroll (elite)", chance = points / elite_clue_denominator / team_size, price = nil})
return {
purple = true_purple_rate,
pet = points / pet_denominator,
unique_loot = unique_loot,
normal_loot = normal_loot,
normal_loot_description = description
}
end
function p.calculator(raid_level, team_size, path_invocation, walk_the_path, leagues_harder_mode)
if raid_level > 600 and not leagues_harder_mode then
return "What? How are you doing a level " .. tostring(raid_level) .." raid?\n\nHow is that possible? Is this bug abuse?"
end
local points_breakdown = p.estimate_points(raid_level, team_size, path_invocation, walk_the_path)
local rewards_breakdown = p.get_rewards(points_breakdown.total, raid_level, team_size, leagues_harder_mode)
preamble = string.format(
[[With no deaths, this raid will give approximately '''%s''' contribution points%s. With a raid level of '''%s''', this equates to a '''%.4f%%''' chance of receiving a purple drop%s, and a '''%.4f%%''' chance of receiving the pet%s.
This estimate is not exact, and may not match your true point total for various reasons, including:
* Deaths (the penalty for deaths cannot feasibly be estimated because it depends on how far you've gotten in the raid)
* Walk the Path levelling order (this assumes the order is Ba-Ba, Kephri, Zebak, Akkha – different orders may result in very marginally different average points)
* Higher or lower healing from Kephri's shields than estimated (this assumes that the shields mostly regenerate both times, but in good teams they may not, resulting in faster kills but ~2%% fewer total points)
* Additional P2 Warden cycles (this assumes "2-down", but "3-down" results in about 3%% more total points)
* Challenge room trap failures
* Precision loss due to integer truncation in RuneScript (estimated 0.5-1%% point loss)
%s
If you are doing this type of raid repeatedly, try comparing the estimated normal loot to the amount you actually tend to receive. For example, if you are consistently getting 10%% fewer coins than predicted here, your purple chance and pet chance will also be 10%% lower than predicted.]],
lang:formatNum(points_breakdown.total),
(team_size > 1) and " for the entire team" or "",
raid_level,
100 * rewards_breakdown.purple,
(team_size > 1) and " across the entire team" or "",
100 * rewards_breakdown.pet,
(team_size > 1) and " across the entire team" or "",
(team_size > 1) and "\nFor computing average loot in the sections, group raids assume that all contribution is split evenly among the team, and chances are shown '''per person'''.\n" or ""
)
local reward_table = mw.html.create('table'):addClass('wikitable')
local reward_table_data = {}
local total_value = 0
table.insert(reward_table_data, {{tag='th', text="Item", attr={colspan=2}}, {tag = 'th', text = "Chance"}, {tag = 'th', text = "Value"}})
for _, v in ipairs(rewards_breakdown.unique_loot) do
total_value = total_value + v.chance * (v.price or 0)
table.insert(reward_table_data, {
{text = string.format("[[File:%s.png|center|link=%s]]", v.item, v.item)},
{text = string.format("[[%s]]", v.item)},
{text = string.format("%.4f%%", 100 * v.chance)},
{text = v.price and coins(v.price) or "N/A", class=v.price and "" or "table-na", css={["text-align"] = "center"}}
})
end
table.insert(reward_table_data, {{attr={colspan=3}, text="Expected value", tag='th'}, {text=coins(math.floor(total_value)), tag='th'}})
tables._table(reward_table, reward_table_data)
local normal_loot_table = mw.html.create('table'):addClass('wikitable')
local normal_loot_table_data = {}
total_value = 0
table.insert(normal_loot_table_data, {{tag='th', text="Item", attr={colspan=2}}, {tag = 'th', text = "Quantity"}, {tag = 'th', text = "Value"}})
for _, v in ipairs(rewards_breakdown.normal_loot) do
total_value = total_value + v.price * v.quantity * 3/27
table.insert(normal_loot_table_data, {
{text = string.format("[[File:%s.png|center|link=%s]]", v.item, v.item)},
{text = string.format("[[%s]]", v.item)},
{text = lang:formatNum(v.quantity)},
{text = coins(math.floor(v.quantity * v.price))}
})
end
table.insert(normal_loot_table_data, {{attr={colspan=3}, text="Expected value (3 rolls)", tag='th'}, {text=coins(math.floor(total_value)), tag='th'}})
tables._table(normal_loot_table, normal_loot_table_data)
local points_table = mw.html.create('table'):addClass('wikitable')
local points_table_data = {}
table.insert(points_table_data, {{tag='th', text="Type"}, {tag = 'th', text = "Est. damage"}, {tag = 'th', text = "Multiplier"}, {tag = 'th', text = "Est. points"}})
for _, v in ipairs(points_breakdown.points_table) do
local name = v.name
if v.count then
name = string.format("%s (%sx)", name, v.count)
end
local row = {{text = name}}
if v.hp then
local damage = lang:formatNum(v.hp)
if v.approx then
damage = string.format("~%s", damage)
end
table.insert(row, {text = damage})
table.insert(row, {text = v.mult})
else
table.insert(row, {text = "N/A", attr={colspan=2}, class="table-na", css={["text-align"] = "center"}})
end
local points = 0
if v.points then
points = v.points
else
points = math.floor(v.hp * v.mult * (v.count or 1))
end
table.insert(row, {text = lang:formatNum(points)})
table.insert(points_table_data, row)
end
local label = "Est. total points"
if team_size > 1 then
label = "Est. total points (entire team)"
end
table.insert(points_table_data, {{attr={colspan=3}, text=label, tag='th'}, {text=lang:formatNum(points_breakdown.total), tag='th'}})
tables._table(points_table, points_table_data)
return preamble
.. "\n==Average rewards per person==\n" .. tostring(reward_table)
.. "\n===Normal loot===\n" .. rewards_breakdown.normal_loot_description .. "\n" .. tostring(normal_loot_table)
.. "\n==Point estimation==\n" .. tostring(points_table)
end
return p