Module:BoostedDropsLine/Sandbox: Difference between revisions
		
		
		
		Jump to navigation
		Jump to search
		
Content added Content deleted
No edit summary Tag: Reverted  | 
				No edit summary Tags: Manual revert Reverted  | 
				||
| Line 1: | Line 1: | ||
local p = {};  | 
|||
-- <nowiki>  | 
  |||
local p = {}  | 
  |||
local params = require('Module:Paramtest')  | 
  |||
local lang = mw.language.getContentLanguage()  | 
  local lang = mw.language.getContentLanguage()  | 
||
local coins_image = require('Module:Coins image')  | 
  |||
local curr_image = require('Module:Currency Image')  | 
  |||
local exchange = require('Module:Exchange')   | 
  |||
local yesno = require('Module:Yesno')  | 
  |||
local var = mw.ext.VariablesLua  | 
  |||
-- precalculated cached data  | 
  |||
local droppeditem_data = mw.loadJsonData('Module:DropsLine/itemData.json')  | 
  |||
local geprices_data = mw.loadJsonData('Module:GEPrices/data.json')  | 
  |||
local highalch_data = mw.loadJsonData('Module:GEHighAlchs/data.json')  | 
  |||
local geprice = exchange._price  | 
  |||
local f_gealch = exchange._highalch  | 
  |||
local ptitle = mw.title.getCurrentTitle()  | 
  |||
local ns = ptitle.nsText  | 
  |||
local title = ptitle.fullText  | 
  |||
local pgTitle = ptitle.text  | 
  |||
local _noted = ' <span class="dropsline-noted">(noted)</span>'  | 
  |||
local coins_priceString = "%s coin%s"  | 
  |||
local other_priceString = "%s coin%s"  | 
  |||
local smwData = nil  | 
  |||
function getSMWInfo(item)  | 
  |||
    if smwData ~= nil then  | 
  |||
        return smwData  | 
  |||
    end  | 
  |||
    local smw = mw.smw.ask({  | 
  |||
        '[['..item..']]',  | 
  |||
        '?High Alchemy value'  | 
  |||
    })  | 
  |||
    if smw and smw[1] then  | 
  |||
        smwData = {  | 
  |||
            alch = smw[1]['High Alchemy value']  | 
  |||
        }  | 
  |||
    else  | 
  |||
        smwData = false  | 
  |||
    end  | 
  |||
    return smwData  | 
  |||
end  | 
  |||
local rarity_class = {  | 
|||
--bg, txt, sort; acceptable non-quantity rarity names  | 
  |||
	{ 1, 'table-bg-blue' },  | 
|||
local rarities = {  | 
  |||
	{ 1/25, 'table-bg-green' },  | 
|||
	{ 1/99.99, 'table-bg-yellow' },  | 
|||
	{ 1/999.99, 'table-bg-orange' },  | 
|||
	{ 1/9999999, 'table-bg-red' }  | 
|||
    ['very rare'] = { 'table-bg-red', 1024 },  | 
  |||
    random = { 'table-bg-pink', 4096 },  | 
  |||
    varies = { 'table-bg-pink', 4096 },  | 
  |||
    once = { 'table-bg-pink', 65536 },  | 
  |||
    conditional = { 'table-bg-pink', 65536 },  | 
  |||
    _default = { 'table-bg-grey', 65536 }  | 
  |||
}  | 
  |||
-- colour-code  | 
  |||
local rarities_class = {  | 
  |||
    { 1, 'table-bg-blue' },  | 
  |||
    { 1/25, 'table-bg-green' },  | 
  |||
    { 1/99.99, 'table-bg-yellow' },  | 
  |||
    { 1/999.99, 'table-bg-orange' },  | 
  |||
    { 1/9999999, 'table-bg-red' }  | 
  |||
}  | 
  }  | 
||
function get_rarity_class(val)  | 
  function get_rarity_class(val)  | 
||
	for i,v in ipairs(rarity_class) do  | 
|||
		curr = v  | 
|||
		if val >= v[1] then  | 
|||
			break  | 
|||
		end  | 
|||
	end  | 
|||
	return curr[2]  | 
|||
end  | 
|||
function sigfig(n, f)  | 
|||
	f = math.floor(f-1)  | 
|||
	if n == 0 then return 0 end  | 
|||
	local m = math.floor(math.log10(n))  | 
|||
	local v = n / (10^(m-f))  | 
|||
	v = math.floor(v) * 10^(m-f)  | 
|||
	return v  | 
|||
end  | 
  end  | 
||
function commas(n)  | 
  function commas(n)  | 
||
	if tonumber(n) then  | 
|||
		return lang:formatNum(tonumber(n))  | 
|||
	else  | 
|||
		return n  | 
|||
	end  | 
|||
end  | 
  end  | 
||
p.commas = commas  | 
|||
function expr(t)  | 
  function expr(t)  | 
||
	t = t:gsub(',', '')  | 
|||
    local noerr, val = pcall(mw.ext.ParserFunctions.expr, t)  | 
  |||
	local err, val = pcall(mw.ext.ParserFunctions.expr, t)  | 
|||
    if noerr then  | 
  |||
	if err then  | 
|||
        return tonumber(val)  | 
  |||
		return tonumber(val)  | 
|||
    else  | 
  |||
	else  | 
|||
        return false  | 
  |||
		return false  | 
|||
    end  | 
  |||
	end  | 
|||
end  | 
  end  | 
||
function sigfig(n, f)  | 
  |||
    f = math.floor(f-1)  | 
  |||
    if n == 0 then return 0 end  | 
  |||
    local m = math.floor(math.log10(n))  | 
  |||
    f = math.max(m, f)  | 
  |||
    local v = n / (10^(m-f))  | 
  |||
    v = math.floor(v + 0.5) * 10^(m-f)  | 
  |||
    -- floor(x + 0.5) is standard rounding to one decimal place  | 
  |||
    return v  | 
  |||
end  | 
  |||
p.sigfig = sigfig  | 
  |||
p.commas = commas  | 
  |||
function p.main(frame)  | 
  function p.main(frame)  | 
||
	local args = frame:getParent().args  | 
|||
	return p._main(args)  | 
|||
    local frameArgs = frame.args  | 
  |||
    -- Params and defaults  | 
  |||
    local name,namenotes,  | 
  |||
        quantity,quantitynotes,  | 
  |||
        rarity,alt_rarity,alt_rarity_endash,  | 
  |||
        raritynotes,citation,rowVersion = params.defaults{  | 
  |||
                    {args.name or args.Name,'Item'},  | 
  |||
                    {args.namenotes or args.Namenotes,''},  | 
  |||
                    {args.quantity or args.Quantity,'Unknown'},  | 
  |||
                    {args.quantitynotes or args.Quantitynotes,''},  | 
  |||
                    {args.rarity or args.Rarity,'Unknown'},  | 
  |||
                    {args.altrarity or args.AltRarity,''},  | 
  |||
                    {args.altraritydash or args.AltRarityDash,''},  | 
  |||
                    {args.raritynotes or args.Raritynotes,''},  | 
  |||
                    {args.citation,''},  | 
  |||
                    {args.version or args.Version,''},  | 
  |||
        }  | 
  |||
        raritynotes = raritynotes .. citation  | 
  |||
    local rolls = tonumber(args.rolls or args.Rolls) or false  | 
  |||
    local rollstext = ''  | 
  |||
    if rolls then  | 
  |||
        rollstext = rolls .. ' × '  | 
  |||
    end  | 
  |||
    local approx = yesno(args.approx or args.Approx or 'no', false)  | 
  |||
    local isCoins = name:lower() == 'coins'  | 
  |||
    local isNothing = name:lower() == 'nothing'  | 
  |||
    local altname = params.default_to(args.alt or args.Alt,name)  | 
  |||
    local smwname = params.default_to(args.smwname,name)  | 
  |||
    local useSmw = true  | 
  |||
    if params.has_content(args.smw) then  | 
  |||
        useSmw = args.smw:lower() ~= 'no'  | 
  |||
    end  | 
  |||
    if params.has_content(frameArgs.smw) then  | 
  |||
        useSmw = frameArgs.smw:lower() ~= 'no'  | 
  |||
    end  | 
  |||
    local rarity_value  | 
  |||
    if rarities[rarity:lower()] then  | 
  |||
        rarity = params.ucflc(rarity)  | 
  |||
    else  | 
  |||
        rarity_value = rarity:gsub(',','') --temp place to put this without overriding rarity  | 
  |||
        local rv1, rv2 = string.match(rarity_value, '([%d%.]+)/([%d%.]+)')  | 
  |||
        if rv1 and rv2 then  | 
  |||
            rarity = commas(rv1) .. '/' .. commas(rv2)  | 
  |||
            rarity_value = rv1/rv2  | 
  |||
        else  | 
  |||
            rarity_value = expr(rarity)  | 
  |||
        end  | 
  |||
    end  | 
  |||
    local alt_rarity_value  | 
  |||
    if rarities[alt_rarity:lower()] then  | 
  |||
        alt_rarity = params.ucflc(alt_rarity)  | 
  |||
    else  | 
  |||
        alt_rarity_value = alt_rarity:gsub(',','') --temp place to put this without overriding rarity  | 
  |||
        local rv1, rv2 = string.match(alt_rarity_value, '([%d%.]+)/([%d%.]+)')  | 
  |||
        if rv1 and rv2 then  | 
  |||
            alt_rarity = commas(rv1) .. '/' .. commas(rv2)  | 
  |||
            alt_rarity_value = rv1/rv2  | 
  |||
        else  | 
  |||
            alt_rarity_value = expr(alt_rarity)  | 
  |||
        end  | 
  |||
    end  | 
  |||
    quantity = mw.ustring.lower(quantity)  | 
  |||
    local gemw = yesno(args.gemw or 'yes', false)  | 
  |||
    local alch = yesno(args.alch or 'yes', false)  | 
  |||
    -- Test for existance of alch value  | 
  |||
    local hasmwalch, smwalchval  | 
  |||
    local valueInfo = {  | 
  |||
        alch = {  | 
  |||
            has = false,  | 
  |||
            value = 0  | 
  |||
        },  | 
  |||
        ge = {  | 
  |||
            has = false,  | 
  |||
            value = 0  | 
  |||
        }  | 
  |||
    }  | 
  |||
    local cached_dropdata = droppeditem_data[smwname]  | 
  |||
    local cached_alch = nil  | 
  |||
    if type(cached_dropdata) == 'table' then  | 
  |||
        if cached_dropdata[1] ~= nil and cached_dropdata[2] ~= nil then  | 
  |||
            cached_alch = cached_dropdata[2]  | 
  |||
        elseif cached_dropdata[1] ~= nil then  | 
  |||
            cached_dropdata = cached_dropdata[1]  | 
  |||
            if type(cached_dropdata) == 'boolean' then  | 
  |||
            elseif type(cached_dropdata) == 'number' then  | 
  |||
                cached_alch = cached_dropdata  | 
  |||
            end  | 
  |||
        end  | 
  |||
    end  | 
  |||
    local geprice_frombulk = geprices_data[smwname]  | 
  |||
    if not (type(geprice_frombulk) == 'number' and geprice_frombulk > 0) then  | 
  |||
        geprice_frombulk = nil  | 
  |||
    end  | 
  |||
    if cached_alch == nil then  | 
  |||
        cached_alch = highalch_data[smwname]  | 
  |||
        if not (type(cached_alch) == 'number' and cached_alch > -1) then  | 
  |||
            cached_alch = nil  | 
  |||
        end  | 
  |||
    end  | 
  |||
    if isNothing then  | 
  |||
        gemw = false  | 
  |||
    elseif isCoins then  | 
  |||
        -- coins override  | 
  |||
        valueInfo = {  | 
  |||
            alch = {  | 
  |||
                has = true,  | 
  |||
                value = 1  | 
  |||
            },  | 
  |||
            ge = {  | 
  |||
                has = true,  | 
  |||
                value = 1  | 
  |||
            }  | 
  |||
        }  | 
  |||
    else  | 
  |||
        -- find alch price  | 
  |||
        if alch then  | 
  |||
            -- first check cache for alch value  | 
  |||
            if cached_alch ~= nil then  | 
  |||
                valueInfo.alch = {  | 
  |||
                    has = true,  | 
  |||
                    value = cached_alch  | 
  |||
                }  | 
  |||
            elseif gemw then  | 
  |||
                -- then check gemw for alch value  | 
  |||
                local hasgealch, gealchval = pcall(f_gealch,smwname)  | 
  |||
                if hasgealch then  | 
  |||
                    if gealchval > -1 then  | 
  |||
                        valueInfo.alch = {  | 
  |||
                            has = true,  | 
  |||
                            value = tonumber(gealchval)  | 
  |||
                        }  | 
  |||
                    end  | 
  |||
                end  | 
  |||
            end  | 
  |||
            if not valueInfo.alch.has then  | 
  |||
                -- failed to find alch in GEMW or is on the no-ge list/override  | 
  |||
                -- lookup in SMW  | 
  |||
                local smwret = getSMWInfo(smwname)  | 
  |||
                if smwret and smwret.alch ~= nil then  | 
  |||
                    -- alch is defined, use it  | 
  |||
                    valueInfo.alch = {  | 
  |||
                        has = true,  | 
  |||
                        value = smwret.alch  | 
  |||
                    }  | 
  |||
                else  | 
  |||
                    alch = false  | 
  |||
                end  | 
  |||
            end  | 
  |||
        end  | 
  |||
        -- find ge price  | 
  |||
        if gemw then  | 
  |||
            if geprice_frombulk ~= nil then  | 
  |||
                valueInfo.ge = {  | 
  |||
                    has = true,  | 
  |||
                    value = geprice_frombulk  | 
  |||
                }  | 
  |||
            else  | 
  |||
                gemw = false  | 
  |||
            end  | 
  |||
        end  | 
  |||
    end  | 
  |||
    -- Use 'File:<name>.png' if no image param  | 
  |||
    -- Use 'File:<image>' if image param; image param will include extension  | 
  |||
    -- Special catch for coins  | 
  |||
    local image,image_n  | 
  |||
    if isCoins then  | 
  |||
        image_n = coins_image(quantity)  | 
  |||
    else  | 
  |||
        image_n = params.default_to(args.image or args.Image, name .. '.png')  | 
  |||
        image_n = mw.ustring.gsub(image_n, '#.+$', '.png')  | 
  |||
    end  | 
  |||
    if image_n:lower() == 'no' or params.is_empty(args.name or args.Name) then  | 
  |||
        image = ''  | 
  |||
    elseif isNothing then  | 
  |||
        image = '[[File:Bank filler.png|link=Nothing|alt=This does not exist.]]'  | 
  |||
    else  | 
  |||
        image = mw.ustring.format('[[File:%s|link=%s|alt=%s: %s drops %s with rarity %s%s in quantity %s]]', image_n, name, image_n, title, name, rollstext, rarity, quantity)  | 
  |||
    end  | 
  |||
    -- this only affects the JSON  | 
  |||
    local rdt = string.lower(args.rdt or '') == 'yes'  | 
  |||
    -- Table row  | 
  |||
    local ret =  p._main(name,  | 
  |||
            altname,namenotes,  | 
  |||
            quantity,quantitynotes,  | 
  |||
            rarity,rarity_value,alt_rarity,alt_rarity_endash,alt_rarity_value,  | 
  |||
            raritynotes,image,  | 
  |||
            valueInfo,gemw,alch,alt,  | 
  |||
            isCoins,  | 
  |||
            isNothing,  | 
  |||
            frameArgs,rowVersion,  | 
  |||
            smwname,  | 
  |||
            rdt,useSmw,  | 
  |||
            approx,rolls)  | 
  |||
    -- categories for mainspace  | 
  |||
    local cats = ''  | 
  |||
    local onMain = ns == '' or ns == 'RuneScape'  | 
  |||
    if onMain and useSmw then  | 
  |||
        cats = categories{name,quantity,rarity}  | 
  |||
    end  | 
  |||
    return ret..cats  | 
  |||
end  | 
  end  | 
||
function p._main(args)  | 
|||
	local Image = args['Image']  | 
|||
function p._main(name,  | 
  |||
	local Name = args['Name']  | 
|||
        altname,namenotes,  | 
  |||
	local AltName = args['AltName'] --intended to be used when links are formatted differently, e.x. when they are multiple sources  | 
|||
        quantity,quantitynotes,  | 
  |||
	local Source = args['Source']  | 
|||
        rarity,rarity_value,alt_rarity,alt_rarity_endash,alt_rarity_value,  | 
  |||
	local AltSource = args['AltSource'] --intended to be used when links are formatted differently, e.x. when they are multiple sources  | 
|||
        raritynotes,image,  | 
  |||
	local Rarity = args['Rarity']  | 
|||
        valueInfo,gemw,alch,alt,  | 
  |||
        isCoins,  | 
  |||
        isNothing,  | 
  |||
        frameArgs,rowVersion,  | 
  |||
        smwname,  | 
  |||
        rdt,useSmw,  | 
  |||
        approx, rolls)  | 
  |||
    -- GE value, alch value, quantity cell contents  | 
  |||
    local total, alchtotal, vsort, vasort, _h, _l  | 
  |||
    quantity, _h, _l = qty(quantity, isNothing)  | 
  |||
    if valueInfo.ge.has then  | 
  |||
        total, vsort, totalavg = get_total(valueInfo.ge.value,_h,_l)  | 
  |||
        total = total or 'Not sold'  | 
  |||
    end  | 
  |||
    if valueInfo.alch.has then  | 
  |||
        alchtotal, vasort, alchtotalavg = get_total(valueInfo.alch.value,_h,_l)  | 
  |||
        alchtotal = alchtotal or 'N/A'  | 
  |||
    end  | 
  |||
    -- value sorts  | 
  |||
    if type(vsort) ~= 'number' then  | 
  |||
        vsort = 0  | 
  |||
    end  | 
  |||
    if type(vasort) ~= 'number' then  | 
  |||
        vasort = 0  | 
  |||
    end  | 
  |||
	rarity_value = Rarity:gsub(',','') --temp place to put this without overriding rarity  | 
|||
    -- quantity notes  | 
  |||
	local rv1, rv2 = string.match(rarity_value, '([%d%.]+)/([%d%.]+)')  | 
|||
    if #quantitynotes > 3 then  | 
  |||
	if rv1 and rv2 then  | 
|||
        quantity = quantity..quantitynotes  | 
  |||
		Rarity = commas(rv1) .. '/' .. commas(rv2)  | 
|||
    end  | 
  |||
		Rarity = rv1/rv2  | 
|||
	else  | 
|||
    -- rarity cell contents  | 
  |||
		Rarity = expr(Rarity)  | 
|||
    local rare_class, rare_sort  | 
  |||
	end  | 
|||
    if rarity_value == undefined then  | 
  |||
        rare_class, rare_sort = unpack(rarities[rarity:lower()] or rarities._default)  | 
  |||
    elseif rarity_value == false then  | 
  |||
        rare_class, rare_sort = unpack(rarities._default)  | 
  |||
    else  | 
  |||
        rare_sort = 1/rarity_value  | 
  |||
        rare_class = get_rarity_class(rarity_value)  | 
  |||
    end  | 
  |||
    local rollstext = ''  | 
  |||
    if rolls then  | 
  |||
        rollstext = rolls .. ' × '  | 
  |||
        rare_sort = rare_sort / rolls  | 
  |||
        rare_class = get_rarity_class(math.min(1/rare_sort,0.99))  | 
  |||
    end  | 
  |||
    local tilde = ''  | 
  |||
    if approx and type(rarity_value) == 'number' then  | 
  |||
        tilde = '~'  | 
  |||
    end  | 
  |||
    local _r = rarity  | 
  |||
    -- drop versions  | 
  |||
    local versionKey = 'DEFAULT'  | 
  |||
    local tableVersion = frameArgs.version  | 
  |||
    if params.has_content(tableVersion) then  | 
  |||
        -- versions applied to the entire table  | 
  |||
       versionKey = tableVersion  | 
  |||
    end  | 
  |||
    if params.has_content(rowVersion) then  | 
  |||
        -- versions applied to this row  | 
  |||
        versionKey = rowVersion  | 
  |||
    end  | 
  |||
    local quantityClassOverride = isNothing and 'table-na' or nil  | 
  |||
    -- Table row creation  | 
  |||
    local ret = mw.html.create('tr')  | 
  |||
            -- row-wide things  | 
  |||
            :css('text-align','center')  | 
  |||
            -- inventory image  | 
  |||
            :tag('td')  | 
  |||
                :addClass('inventory-image')  | 
  |||
                :wikitext(image)  | 
  |||
            :done()  | 
  |||
            -- item name  | 
  |||
            :tag('td')  | 
  |||
                :css('text-align','left')  | 
  |||
                :addClass('item-col')  | 
  |||
                :wikitext(string.format('[[%s|%s]]%s',name,altname,#namenotes > 3 and namenotes or ''))  | 
  |||
            :done()  | 
  |||
            -- quantity  | 
  |||
            :tag('td')  | 
  |||
                :addClass(quantityClassOverride)  | 
  |||
                :attr('data-sort-value',_h)  | 
  |||
                :wikitext(quantity)  | 
  |||
            :done()  | 
  |||
    -- rarity  | 
  |||
    local rarity_cell = ret:tag('td')  | 
  |||
    local rarity_span = rarity_cell:tag('span')  | 
  |||
    rarity_span:wikitext(rollstext .. tilde .. rarity)  | 
  |||
    rarity_cell:attr('data-sort-value',rare_sort)  | 
  |||
                :addClass(rare_class)  | 
  |||
    if type(rarity_value) == 'number' then  | 
  |||
        rarity_cell:attr('title', rollstext .. tilde .. string.format('%.3g%%', 100 * rarity_value))  | 
  |||
        rarity_span:attr({  | 
  |||
            ['data-drop-fraction'] = rollstext .. tilde .. rarity,  | 
  |||
            ['data-drop-oneover'] = rollstext .. tilde .. '1/' .. commas(sigfig(1/rarity_value, 4)),  | 
  |||
            ['data-drop-percent'] = rollstext .. tilde .. sigfig(100 * rarity_value, 3),  | 
  |||
            ['data-drop-permil'] = rollstext .. tilde .. sigfig(1000 * rarity_value, 3),  | 
  |||
            ['data-drop-permyriad'] = rollstext .. tilde .. sigfig(10000 * rarity_value, 3),  | 
  |||
        })  | 
  |||
    end  | 
  |||
    if alt_rarity ~= '' then  | 
  |||
        if alt_rarity_endash  ~= '' then  | 
  |||
            rarity_cell:tag('span'):wikitext('–')  | 
  |||
        else  | 
  |||
            rarity_cell:tag('span'):wikitext('; ')  | 
  |||
        end  | 
  |||
        local alt_rarity_span = rarity_cell:tag('span')  | 
  |||
        alt_rarity_span:wikitext(alt_rarity)  | 
  |||
        if type(alt_rarity_value) == 'number' then  | 
  |||
            alt_rarity_span:attr({  | 
  |||
                ['data-drop-fraction'] = alt_rarity,  | 
  |||
                ['data-drop-oneover'] = '1/' .. commas(sigfig(1/alt_rarity_value, 3)),  | 
  |||
                ['data-drop-percent'] = sigfig(100 * alt_rarity_value, 3),  | 
  |||
                ['data-drop-permil'] = sigfig(1000 * alt_rarity_value, 3),  | 
  |||
                ['data-drop-permyriad'] = sigfig(10000 * alt_rarity_value, 3),  | 
  |||
            })  | 
  |||
        end  | 
  |||
    end  | 
  |||
	local Rarity2 = Rarity * 2  | 
|||
    if #raritynotes > 3 then  | 
  |||
	local Rarity3 = Rarity * 3  | 
|||
        rarity_cell:wikitext(raritynotes)  | 
  |||
	local rare1_class, rare2_class, rare3_class  | 
|||
    end  | 
  |||
	local rare1_text, rare2_text, rare3_text  | 
|||
	rare1_class = get_rarity_class(Rarity)  | 
|||
	rare2_class = get_rarity_class(Rarity2)  | 
|||
	rare3_class = get_rarity_class(Rarity3)  | 
|||
	rare1_text = '1/' .. commas(sigfig(1/Rarity, 3))  | 
|||
	rare2_text = '1/' .. commas(sigfig((math.floor(1/Rarity2)), 4))  | 
|||
	rare3_text = '1/' .. commas(sigfig((math.floor(1/Rarity3)), 4))  | 
|||
		--Use name as link, or altname exactly as written  | 
|||
	if Image == isNothing then  | 
|||
		image = mw.ustring.format('[[File:%s.png]]', Name)  | 
|||
		else  | 
|||
		image = Image  | 
|||
	end  | 
|||
    -- setup GE and alch cells  | 
  |||
	--Use name as link, or altname exactly as written  | 
|||
    local ge_td = ret:tag('td')  | 
  |||
	if Name == isNothing then  | 
|||
    local alch_td = ret:tag('td')  | 
  |||
		Name = AltName  | 
|||
		else  | 
|||
    -- common attributes  | 
  |||
		Name = mw.ustring.format('[[%s]]', Name)  | 
|||
    ge_td   :attr('data-sort-value',vsort)  | 
  |||
	end  | 
|||
        :addClass('ge-column')  | 
  |||
        :css({  | 
  |||
	--Use single monster source as link, or altsource if Source is empty  | 
|||
            ['text-align'] = 'right',  | 
  |||
	if Source == isNothing then  | 
|||
            cursor = 'help'  | 
  |||
		Source = AltSource  | 
|||
        })  | 
  |||
		else  | 
|||
    alch_td :attr('data-sort-value',vasort)  | 
  |||
            :addClass('alch-column')  | 
  |||
		Source = mw.ustring.format('[[%s]]', Source)  | 
|||
            :css({  | 
  |||
	end  | 
|||
                ['text-align'] = 'right',  | 
  |||
                cursor = 'help'  | 
  |||
	--create rows for table	  | 
|||
            })  | 
  |||
	local ret = mw.html.create('tr')  | 
|||
		:tag('td')  | 
|||
    local ge_td_title, ge_td_content, alch_td_title, alch_td_content  | 
  |||
			:addClass('inventory-image')  | 
|||
    --Cases for the GE, alch values, and isNothing handling  | 
  |||
			:wikitext(image)  | 
|||
    if isNothing then  | 
  |||
		:done()  | 
|||
        ge_td_content = 'N/A'  | 
  |||
		:tag('td')  | 
|||
        ge_td_title = 'This does not exist.'  | 
  |||
			:css('text-align','left')  | 
|||
			:addClass('item-col')  | 
|||
        alch_td_content = 'N/A'  | 
  |||
			:wikitext(Name)  | 
|||
        alch_td_title = 'This does not exist.'  | 
  |||
		:done()  | 
|||
        alch_td:addClass('table-na'):css('text-decoration', 'underline dotted')  | 
  |||
		:tag('td')  | 
|||
    elseif isCoins then  | 
  |||
			:css('text-align','center')  | 
|||
        local coinsStr = lang:plural(vsort, '', 's')  | 
  |||
			:addClass('source-col')  | 
|||
        ge_td_title = mw.ustring.format(coins_priceString, total, coinsStr)  | 
  |||
			:wikitext(Source)  | 
|||
        ge_td_content = total  | 
  |||
		:done()  | 
|||
        alch_td_title = mw.ustring.format(coins_priceString, total, coinsStr)  | 
  |||
		:tag('td')  | 
|||
        alch_td_content = total  | 
  |||
			:addClass(rare1_class)  | 
|||
    else  | 
  |||
			:wikitext(rare1_text)  | 
|||
        if valueInfo.ge.has then  | 
  |||
		:done()  | 
|||
            ge_td_title = mw.ustring.format(other_priceString, commas(valueInfo.ge.value), lang:plural(valueInfo.ge.value, '', 's'))  | 
  |||
		:tag('td')  | 
|||
            ge_td_content = total  | 
  |||
			:addClass(rare2_class)  | 
|||
        end  | 
  |||
			:wikitext(rare2_text)  | 
|||
        if valueInfo.alch.has then  | 
  |||
		:done()  | 
|||
            alch_td_title = mw.ustring.format(other_priceString, commas(valueInfo.alch.value), lang:plural(valueInfo.alch.value, '', 's'))  | 
  |||
		:tag('td')  | 
|||
            alch_td_content = alchtotal  | 
  |||
			:addClass(rare3_class)  | 
|||
        end  | 
  |||
			:wikitext(rare3_text)  | 
|||
		:done()  | 
|||
        if ge_td_content == nil then  | 
  |||
            ge_td_content = 'Not sold'  | 
  |||
            ge_td_title = 'This item cannot be traded on the Grand Exchange.'  | 
  |||
            ge_td:addClass('table-na'):css('text-decoration', 'underline dotted')  | 
  |||
        end  | 
  |||
        if alch_td_content == nil then  | 
  |||
            -- nothing else triggered  | 
  |||
            alch_td_content = 'N/A'  | 
  |||
            alch_td_title = 'This item cannot be alchemised.'  | 
  |||
            alch_td:addClass('table-na'):css('text-decoration', 'underline dotted')  | 
  |||
        end  | 
  |||
    end  | 
  |||
    ge_td:wikitext(ge_td_content):attr('title', ge_td_title)  | 
  |||
    alch_td:wikitext(alch_td_content):attr('title', alch_td_title)  | 
  |||
    -- SMW  | 
  |||
    local onMain = ns == '' or ns == 'RuneScape'  | 
  |||
    local unrecognizedDropVersionCategory = ''  | 
  |||
    if onMain and useSmw and isNothing ~= true then  | 
  |||
        local smw_sub = {}  | 
  |||
        -- check if applies to all or only a version  | 
  |||
        --add function to reduce image to File:Some name.png  | 
  |||
        local smwImage = mw.text.encode(image)  | 
  |||
        local smwNameNote = mw.text.killMarkers(namenotes)  | 
  |||
        local smwQuantity = mw.text.killMarkers(quantity)  | 
  |||
        smwQuantity = smwQuantity:gsub('<span class="dropsline%-noted">', '')  | 
  |||
        smwQuantity = smwQuantity:gsub('</span>', '')  | 
  |||
        smwQuantity = smwQuantity:gsub(',', '')  | 
  |||
        smwQuantity = smwQuantity:gsub(' ', ' ')  | 
  |||
        smwQuantity = smwQuantity:gsub(';', ',')  | 
  |||
        local smwRarityNote = mw.text.killMarkers(raritynotes)  | 
  |||
        local smwRolls = rolls or 1  | 
  |||
        local subcount = 1  | 
  |||
        if var.varexists('dropcount') then  | 
  |||
            subcount = var.var('dropcount', 1)  | 
  |||
            subcount = subcount + 1  | 
  |||
            var.vardefine('dropcount', subcount)  | 
  |||
        else  | 
  |||
            var.vardefine('dropcount', 1)  | 
  |||
        end  | 
  |||
        local subname = 'DROP_'..subcount..'_'..smwname..'_'..smwQuantity..'_'..rarity  | 
  |||
        subname = string.gsub(subname,'#','')  | 
  |||
        dropFrom = pgTitle  | 
  |||
        if versionKey ~= 'DEFAULT' then  | 
  |||
            dropFrom = pgTitle .. '#' .. versionKey  | 
  |||
        end  | 
  |||
        local droppedItemName = 'Dropped item'  | 
  |||
        if rdt == true then  | 
  |||
            droppedItemName = 'Dropped item from RDT'  | 
  |||
        end  | 
  |||
        local dropType = frameArgs.dtype or 'combat'  | 
  |||
        local seenLevels = {}  | 
  |||
        for dropVersion in string.gmatch(versionKey, ' *([^,]+) *') do  | 
  |||
            local dropLevelVar = string.format("DropLevel_%s_%s", dropType, dropVersion)  | 
  |||
            if not var.varexists(dropLevelVar) and versionKey ~= 'DEFAULT' and dropType ~= 'reward' then  | 
  |||
                unrecognizedDropVersionCategory = unrecognizedDropVersionCategory..'[[Category:Uses unrecognized drop version]]'  | 
  |||
            end  | 
  |||
            local curDropLevelValues = var.var(dropLevelVar)  | 
  |||
            for curDropLevel in string.gmatch(curDropLevelValues, ' *([^,]+) *') do  | 
  |||
                seenLevels[curDropLevel] = true  | 
  |||
            end  | 
  |||
        end  | 
  |||
        local orderedLevels = {}  | 
  |||
        for level, _ in pairs(seenLevels) do  | 
  |||
            local n = tonumber(level)  | 
  |||
            if n ~= nil then  | 
  |||
                table.insert(orderedLevels, n)  | 
  |||
            end  | 
  |||
        end  | 
  |||
        table.sort(orderedLevels)  | 
  |||
        local dropLevel = table.concat(orderedLevels, ',')  | 
  |||
        local smw_json = {  | 
  |||
            ['Dropped item']=smwname,  | 
  |||
            ['Name Notes']=smwNameNote,  | 
  |||
            ['Drop Quantity']=smwQuantity,  | 
  |||
            ['Quantity High']=_h,  | 
  |||
            ['Quantity Low']=_l,  | 
  |||
            ['Rarity']=rarity,  | 
  |||
            ['Alt Rarity']=alt_rarity,  | 
  |||
            ['Alt Rarity Dash'] = alt_rarity_endash,  | 
  |||
            ['Rarity Notes']=smwRarityNote,  | 
  |||
            ['Rolls']=smwRolls,  | 
  |||
            ['Drop Value'] = valueInfo.alch.value or 0,  | 
  |||
            ['Dropped from'] = dropFrom,  | 
  |||
            ['Drop level'] = dropLevel,  | 
  |||
            ['Drop type'] = dropType,  | 
  |||
            ['Approx'] = approx  | 
  |||
        }  | 
  |||
        local smw_sub = {  | 
  |||
            [droppedItemName] = smwname,  | 
  |||
            ['Dropped item page'] = smwname,  | 
  |||
            ['Dropped from'] = dropFrom,  | 
  |||
            ['Drop JSON'] = mw.text.jsonEncode(smw_json)  | 
  |||
        }  | 
  |||
        mw.smw.subobject(smw_sub, subname)  | 
  |||
    end  | 
  |||
    return tostring(ret) .. unrecognizedDropVersionCategory  | 
  |||
end  | 
  |||
function qty(quantity, isNothing)  | 
  |||
    -- if no quantity is given, return unknown  | 
  |||
    if string.lower(quantity) == 'varies' then  | 
  |||
        return 'Varies'  | 
  |||
    elseif isNothing then  | 
  |||
        return 'N/A'  | 
  |||
    elseif not quantity or string.lower(quantity) == 'unknown' then  | 
  |||
        return 'Unknown'  | 
  |||
    end  | 
  |||
    -- en dashes are the proper dash for number ranges  | 
  |||
    -- replace all hyphens and em dashes with en  | 
  |||
    -- strip *all* whitespace  | 
  |||
    -- change '(noted)' to '$n' for parsing  | 
  |||
    quantity = mw.ustring.gsub(quantity,'[-—]','–')  | 
  |||
        :gsub('%s','')  | 
  |||
        :gsub('%(noted%)','$n')  | 
  |||
    -- split list into table  | 
  |||
    local vals = mw.text.split(quantity,'[,;]')  | 
  |||
    local low = 2147483648  | 
  |||
    local high = 0  | 
  |||
    -- recreate the quantity string to ensure consistent formatting  | 
  |||
    local numstr = {}  | 
  |||
    for i, v in ipairs(vals) do  | 
  |||
        local clean = v:gsub('$n','')  | 
  |||
        -- if list element contains an en dash (indicating range)  | 
  |||
        -- Find the smaller/larger number (just in case)  | 
  |||
        -- Compare them to the current min/max  | 
  |||
        -- put them in order with desired format  | 
  |||
        if mw.ustring.find(v,'–') then  | 
  |||
            local splitvals = mw.text.split(clean,'–')  | 
  |||
            -- assume a is smaller, b is larger  | 
  |||
            local a = tonumber(splitvals[1])  | 
  |||
            local b = tonumber(splitvals[2])  | 
  |||
            -- Just in case  | 
  |||
            if a > b then  | 
  |||
                a,b = b,a  | 
  |||
            end  | 
  |||
            if a < low then  | 
  |||
                low = a  | 
  |||
            end  | 
  |||
            if b > high then  | 
  |||
                high = b  | 
  |||
            end  | 
  |||
            local addx = commas(a)..'–'..commas(b)  | 
  |||
            if v:find('$n') then  | 
  |||
                addx = addx.._noted  | 
  |||
            end  | 
  |||
            table.insert(numstr,addx)  | 
  |||
        else  | 
  |||
            local a = tonumber(clean)  | 
  |||
            if a < low then  | 
  |||
                low = a  | 
  |||
            end  | 
  |||
            if a > high then   | 
  |||
                high = a  | 
  |||
            end  | 
  |||
            local addx = commas(a)  | 
  |||
            if v:find('$n') then  | 
  |||
                addx = addx.._noted  | 
  |||
            end  | 
  |||
            table.insert(numstr,addx)  | 
  |||
        end  | 
  |||
    end  | 
  |||
    -- Add a line break if there are too many elements  | 
  |||
    -- To keep the tables thin  | 
  |||
    if #numstr > 11 then  | 
  |||
        local mid = math.floor(#numstr/2)  | 
  |||
        numstr[mid] = '<br/>'..numstr[mid]  | 
  |||
    end  | 
  |||
    -- To prevent any possible confusion with formatted numbers  | 
  |||
    -- elements should be separated with semicolons followed by a space  | 
  |||
    numstr = table.concat(numstr,'; ')  | 
  |||
    -- If no numbers are found in the string, return unknown  | 
  |||
    if not numstr:find('%d') then  | 
  |||
        return 'Unknown', price  | 
  |||
    end  | 
  |||
    return numstr, high, low  | 
  |||
end  | 
  |||
function get_total(value,qhigh,qlow)  | 
  |||
    -- if no alch value is given, return unknown  | 
  |||
    if not value or string.lower(value) == 'unknown' then  | 
  |||
        return value  | 
  |||
    end  | 
  |||
    -- if value is negative (from smw/ge) it cannot be alched  | 
  |||
    if tonumber(value) and tonumber(value) < 0 then  | 
  |||
        return false  | 
  |||
    end  | 
  |||
    -- if no numbers return not alchemisable  | 
  |||
    if not tonumber(value) and not value:find('%d') then  | 
  |||
        return false  | 
  |||
    end  | 
  |||
    -- en dashes are the proper dash for number ranges  | 
  |||
    -- replace all hyphens and em dashes with en  | 
  |||
    -- strip *all* whitespace  | 
  |||
    value = mw.ustring.gsub(value,'[-—]','–')  | 
  |||
        :gsub('%s','')  | 
  |||
    -- split list into table  | 
  |||
    local vals = mw.text.split(value,'[,;]')  | 
  |||
    -- All value ranges will be a range  | 
  |||
    -- e.g. if items valued at 100 coins are dropped in quantities of 1, 3, 5  | 
  |||
    -- the value returned will be 100–500 rather than 100; 300; 500  | 
  |||
    -- If low and high vars are the same in the end, only 1 value is displayed  | 
  |||
    local low = 2147483648  | 
  |||
    local high = 0  | 
  |||
    -- recreate the alchval string to ensure consistent formatting  | 
  |||
    for i, v in ipairs(vals) do  | 
  |||
        local clean = v:gsub('$n','')  | 
  |||
        -- if list element contains an en dash (indicating range)  | 
  |||
        -- Find the smaller/larger number (just in case)  | 
  |||
        -- Compare them to the current min/max  | 
  |||
        -- put them in order with desired format  | 
  |||
        if mw.ustring.find(v,'–') then  | 
  |||
            local splitvals = mw.text.split(clean,'–')  | 
  |||
            -- assume a is smaller, b is larger  | 
  |||
            local a = tonumber(splitvals[1])  | 
  |||
            local b = tonumber(splitvals[2])  | 
  |||
            -- Just in case  | 
  |||
            if a > b then  | 
  |||
                a,b = b,a  | 
  |||
            end  | 
  |||
            if a < low then  | 
  |||
                low = a  | 
  |||
            end  | 
  |||
            if b > high then  | 
  |||
                high = b  | 
  |||
            end  | 
  |||
        else  | 
  |||
            local a = tonumber(clean)  | 
  |||
            if a < low then  | 
  |||
                low = a  | 
  |||
            end  | 
  |||
            if a > high then   | 
  |||
                high = a  | 
  |||
            end  | 
  |||
        end  | 
  |||
    end  | 
  |||
    local valret, sort, avg  | 
  |||
    if not qhigh or not qlow then  | 
  |||
        sort = high  | 
  |||
        avg = high  | 
  |||
        valret = commas(high)  | 
  |||
    else  | 
  |||
        local lower = qlow * low  | 
  |||
        local higher = qhigh * high  | 
  |||
        if higher == lower then  | 
  |||
            valret = commas(higher)  | 
  |||
            avg = higher  | 
  |||
        else  | 
  |||
            valret = commas(lower)..'–'..commas(higher)  | 
  |||
            avg = (lower+higher)/2  | 
  |||
        end  | 
  |||
        sort = higher  | 
  |||
    end  | 
  |||
    return valret, sort, avg  | 
  |||
end  | 
  |||
	return tostring(ret)  | 
|||
-- adding categories to mainspace  | 
  |||
function categories(...)  | 
  |||
    local name,quantity,rarity = unpack(...)  | 
  |||
    local ret = ''  | 
  |||
    name = name:lower()  | 
  |||
    quantity = quantity:lower()  | 
  |||
    if name:find('clue scroll') then  | 
  |||
        ret = ret .. '[[Category:Monsters that drop clues]]'  | 
  |||
    end  | 
  |||
    if rarity == nil or rarity == '' or rarity:lower() == 'unknown' then  | 
  |||
        ret = ret .. '[[Category:Needs drop rarity added]]'  | 
  |||
    end  | 
  |||
    if quantity:find('Unknown') then  | 
  |||
        ret = ret .. '[[Category:Needs drop quantity added]]'  | 
  |||
    end  | 
  |||
    return ret  | 
  |||
end  | 
  end  | 
||
return p  | 
  return p;  | 
||
-- </nowiki>  | 
  |||
Revision as of 00:11, 17 October 2024
Documentation for this module may be created at Module:BoostedDropsLine/Sandbox/doc
local p = {};
local lang = mw.language.getContentLanguage()
local rarity_class = {
	{ 1, 'table-bg-blue' },
	{ 1/25, 'table-bg-green' },
	{ 1/99.99, 'table-bg-yellow' },
	{ 1/999.99, 'table-bg-orange' },
	{ 1/9999999, 'table-bg-red' }
}
function get_rarity_class(val)
	for i,v in ipairs(rarity_class) do
		curr = v
		if val >= v[1] then
			break
		end
	end
	return curr[2]
end
function sigfig(n, f)
	f = math.floor(f-1)
	if n == 0 then return 0 end
	local m = math.floor(math.log10(n))
	local v = n / (10^(m-f))
	v = math.floor(v) * 10^(m-f)
	return v
end
function commas(n)
	if tonumber(n) then
		return lang:formatNum(tonumber(n))
	else
		return n
	end
end
p.commas = commas
function expr(t)
	t = t:gsub(',', '')
	local err, val = pcall(mw.ext.ParserFunctions.expr, t)
	if err then
		return tonumber(val)
	else
		return false
	end
end
function p.main(frame)
	local args = frame:getParent().args
	return p._main(args)
end
function p._main(args)
	local Image = args['Image']
	local Name = args['Name']
	local AltName = args['AltName'] --intended to be used when links are formatted differently, e.x. when they are multiple sources
	local Source = args['Source']
	local AltSource = args['AltSource'] --intended to be used when links are formatted differently, e.x. when they are multiple sources
	local Rarity = args['Rarity']
	rarity_value = Rarity:gsub(',','') --temp place to put this without overriding rarity
	local rv1, rv2 = string.match(rarity_value, '([%d%.]+)/([%d%.]+)')
	if rv1 and rv2 then
		Rarity = commas(rv1) .. '/' .. commas(rv2)
		Rarity = rv1/rv2
	else
		Rarity = expr(Rarity)
	end
	local Rarity2 = Rarity * 2
	local Rarity3 = Rarity * 3
	local rare1_class, rare2_class, rare3_class
	local rare1_text, rare2_text, rare3_text
	
	rare1_class = get_rarity_class(Rarity)
	rare2_class = get_rarity_class(Rarity2)
	rare3_class = get_rarity_class(Rarity3)
	
	rare1_text = '1/' .. commas(sigfig(1/Rarity, 3))
	rare2_text = '1/' .. commas(sigfig((math.floor(1/Rarity2)), 4))
	rare3_text = '1/' .. commas(sigfig((math.floor(1/Rarity3)), 4))
	
		--Use name as link, or altname exactly as written
	if Image == isNothing then
		image = mw.ustring.format('[[File:%s.png]]', Name)
		else
		image = Image
	end
	
	--Use name as link, or altname exactly as written
	if Name == isNothing then
		Name = AltName
		else
		Name = mw.ustring.format('[[%s]]', Name)
	end
	
	--Use single monster source as link, or altsource if Source is empty
	if Source == isNothing then
		Source = AltSource
		else
		
		Source = mw.ustring.format('[[%s]]', Source)
	end
	
	--create rows for table	
	local ret = mw.html.create('tr')
		:tag('td')
			:addClass('inventory-image')
			:wikitext(image)
		:done()
		:tag('td')
			:css('text-align','left')
			:addClass('item-col')
			:wikitext(Name)
		:done()
		:tag('td')
			:css('text-align','center')
			:addClass('source-col')
			:wikitext(Source)
		:done()
		:tag('td')
			:addClass(rare1_class)
			:wikitext(rare1_text)
		:done()
		:tag('td')
			:addClass(rare2_class)
			:wikitext(rare2_text)
		:done()
		:tag('td')
			:addClass(rare3_class)
			:wikitext(rare3_text)
		:done()
	return tostring(ret)
end
return p;