Anonymous

Module:Attacks/Tables: Difference between revisions

From Melvor Idle

Module:Attacks/Tables (view source)

Revision as of 22:06, 31 January 2022

5,566 bytes added ,  31 January 2022
Fix for unknown items
(Initial creation)
 
(Fix for unknown items)
(10 intermediate revisions by 2 users not shown)
Line 1: Line 1:
local p = {}
local p = {}


local Constants require('Module:Constants')
local Constants = require('Module:Constants')
local Shared = require('Module:Shared')
local Shared = require('Module:Shared')
local Icons = require('Module:Icons')
local Icons = require('Module:Icons')
local Items = require('Module:Items')
local Items = require('Module:Items')
local Monsters = require('Module:Monsters')
local Monsters = require('Module:Monsters')
local Magic = require('Module:Magic')
local Attacks = require('Module:Attacks')
local Attacks = require('Module:Attacks')


function p._getMonsterSpecialAttackTable(effectDefn)
function p._getSpecialAttackTable(effectDefn, categories, sourceHeaderLabel, includeSource)
    local spAttTable = {}
local spAttTable = {}
    local attacks = Attacks.getAttacks(function(attack)
local attacks = Attacks.getAttacks(function(attack)
                                          if effectDefn == nil then
if effectDefn == nil then
                                              return true
return true
                                          else
else
                                              return Attacks.attackHasEffect(attack, effectDefn)
return Attacks.attackHasEffect(attack, effectDefn)
                                          end
end
                                      end)
end)
local includeCat = {}
for i, category in ipairs(categories) do
includeCat[category] = true
end


    -- Compile table of monsters & chances for each attack
-- Compile a list of monsters, items, spells, etc. for each included attack
    for i, spAtt in ipairs(attacks) do
for i, spAtt in ipairs(attacks) do
        if Shared.tableCount(spAtt.monsters) > 0 then
-- Monsters
            spAttTable[i] = {}
if includeCat['Monster'] then
for j, monsterID in ipairs(spAtt.monsters) do
local monster = Monsters.getMonsterByID(monsterID)
local overrideChance = (monster.overrideSpecialChances ~= nil and Shared.tableCount(monster.overrideSpecialChances) > 0)
local attChance = spAtt.defaultChance
if overrideChance then
local attIdx = nil
for k, monsterAttack in ipairs(monster.specialAttacks) do
local attID = (type(monsterAttack) == 'table' and monsterAttack.id) or monsterAttack
if spAtt.id == attID then
attIdx = k
break
end
end
if attIdx ~= nil then
attChance = monster.overrideSpecialChances[attIdx]
end
end


            for j, monsterID in ipairs(spAtt.monsters) do
table.insert(spAttTable, { idx = i, source = 'Monster', sourceSort = monster.name, sourceText = Icons.Icon({ monster.name, type = 'monster' }), chance = attChance, descType = 'monster' })
                local monster = Monsters.getMonsterByID(monsterID)
end
                local overrideChance = (monster.overrideSpecialChances ~= nil and Shared.tableCount(monster.overrideSpecialChances) > 0)
end
                local attChance = spAtt.defaultChance
                if overrideChance then
                    local attIdx = nil
                    for k, monsterAttack in ipairs(monster.specialAttacks) do
                        local attID = (type(monsterAttack) == 'table' and monsterAttack.id) or monsterAttack
                        if spAtt.id == attID then
                            attIdx = k
                            break
                        end
                    end
                    if attIdx ~= nil then
                        attChance = monster.overrideSpecialChances[attIdx]
                    end
                end


                if spAttTable[i][attChance] == nil then
-- Items/Weapons
                    spAttTable[i][attChance] = {}
if includeCat['Item'] then
                end
for j, itemID in ipairs(spAtt.items) do
                table.insert(spAttTable[i][attChance], Icons.Icon({ monster.name, type = 'monster' }))
local item = Items.getItemByID(itemID)
            end
if item ~= nil then
        end
table.insert(spAttTable, { idx = i, source = 'Weapon', sourceSort = item.name, sourceText = Icons.Icon({ item.name, type = 'item' }), chance = spAtt.defaultChance, descType = 'player' })
    end
end
end
end


    -- Generate output table
-- Spells
    local resultPart = {}
if includeCat['Spell'] then
    table.insert(resultPart, '{|class="wikitable sortable stickyHeader"')
for j, spellID in ipairs(spAtt.spells) do
    table.insert(resultPart, '\r\n|- class="headerRow-0"')
local spell = Magic.getSpellByID(spellID[1], spellID[2])
    table.insert(resultPart, '\r\n!Name!!style="min-width:225px"|Monsters!!Chance!!Effect')
table.insert(spAttTable, { idx = i, source = 'Spell', sourceSort = spell.name, sourceText = Icons.Icon({ spell.name, type = 'spell' }), chance = spAtt.defaultChance, descType = 'player' })
end
end
end


    for i, spAttData in Shared.skpairs(spAttTable) do
-- Summoning familiars. Any effects inflicted by combat familiars aren't actually special
        local spAtt = attacks[i]
-- attacks, therefore the handling here is a bit different and outside of the above attack loop
        local firstRow = true
if includeCat['Familiar'] then
        local rowsSpanned = Shared.tableCount(spAttData)
local famIdx = Shared.tableCount(attacks) + 1
        local rowSuffix = ''
local familiars = Items.getItems(function(item)
        if rowsSpanned > 1 then
if item.type == 'Familiar' and Items._getItemStat(item, 'summoningMaxhit') ~= nil and item.modifiers ~= nil then
            rowSuffix = '|rowspan="' .. rowsSpanned .. '"'
local famAttack = { prehitEffects = {}, onhitEffects = { { type = 'Modifier', subtype = 'Familiar', modifiers = item.modifiers } } }
        end
if effectDefn == nil then
        for chance, iconList in Shared.skpairs(spAttData) do
return Shared.tableCount(Attacks.getAttackEffects(famAttack)) > 0
            table.insert(resultPart, '\r\n|-')
else
            if firstRow then
return Attacks.attackHasEffect(famAttack, effectDefn)
                table.insert(resultPart, '\r\n' .. rowSuffix .. '| ' .. spAtt.name)
end
            end
end
            table.insert(resultPart, '\r\n|data-sort-value="' .. spAtt.name .. '"| ' .. table.concat(iconList, '<br/>'))
return false
            table.insert(resultPart, '\r\n|data-sort-value="' .. chance .. '"| ' .. Shared.round(chance, 2, 0) .. '%')
end)
            if firstRow then
for j, familiar in ipairs(familiars) do
                table.insert(resultPart, '\r\n' .. rowSuffix .. '| ' .. spAtt.description.monster)
-- For chance, assume the first modifier we come across has the chance, which is pretty lazy
                firstRow = false
local famChance, famDesc = 0, ''
            end
for modName, modVal in pairs(familiar.modifiers) do
        end
if type(modVal) == 'table' and type(modVal[1]) == 'number' then
    end
famChance = modVal[1]
    table.insert(resultPart, '\r\n|}')
elseif type(modVal) == 'number' then
famChance = modVal
else
famChance = 0
end
famDesc = Constants._getModifierText(modName, modVal, false)
break
end


    return table.concat(resultPart)
table.insert(spAttTable, { idx = famIdx, source = 'Familiar', sourceSort = familiar.name, sourceText = Icons.Icon({ familiar.name, type = 'item' }), chance = famChance or 0, descType = 'player' })
end
-- Slap a dummy entry into the attacks table for this familiar
 
attacks[famIdx] = { name = familiar.name .. ' (Familiar)', description = { player = famDesc } }
function p._getItemSpecialAttackTable(effectDefn)
famIdx = famIdx + 1
  local spAttTable = {}
end
  local attacks = Attacks.getAttacks(function(attack)
end
                                        if effectDefn == nil then
                                            return true
                                        else
                                            return Attacks.attackHasEffect(attack, effectDefn)
                                        end
                                    end)


    -- Compile table of items for each attack
-- Nothing to output if there are no row definitions
    for i, spAtt in ipairs(attacks) do
if Shared.tableCount(spAttTable) == 0 then
        if Shared.tableCount(spAtt.items) > 0 then
return ''
            spAttTable[i] = { Icons = {} }
end


            for j, itemID in ipairs(spAtt.items) do
-- Sort entries into desired order and generate stats to determine row spans:
                local item = Items.getItemByID(itemID)
-- By attack index, description type (monster/player), chance, source, then source name (weapon/item/etc.)
                if spAttTable[i]['sortName'] == nil then
table.sort(spAttTable, function (a, b)
                    spAttTable[i]['sortName'] = item.name
local sortKeys = { 'idx', 'descType', 'chance', 'source', 'sourceSort' }
                end
for i, key in ipairs(sortKeys) do
                table.insert(spAttTable[i]['Icons'], Icons.Icon({ item.name, type = 'item' }))
if a[key] ~= b[key] then
            end
return a[key] < b[key]
        end
end
    end
end
return false
end)
-- Determine row counts for grouping/rowspans
local rowCounts = {}
for i, rowDefn in ipairs(spAttTable) do
local idx, dt, chance = rowDefn.idx, rowDefn.descType, rowDefn.chance
if rowCounts[idx] == nil then
rowCounts[idx] = { rows = 0 }
end
if rowCounts[idx][dt] == nil then
rowCounts[idx][dt] = { rows = 0 }
end
if rowCounts[idx][dt][chance] == nil then
rowCounts[idx][dt][chance] = 0
end
rowCounts[idx]['rows'] = rowCounts[idx]['rows'] + 1
rowCounts[idx][dt]['rows'] = rowCounts[idx][dt]['rows'] + 1
rowCounts[idx][dt][chance] = rowCounts[idx][dt][chance] + 1
end


    -- Generate output table
-- Generate output table
    local resultPart = {}
local resultPart = {}
    table.insert(resultPart, '{|class="wikitable sortable stickyHeader"')
table.insert(resultPart, '{|class="wikitable sortable stickyHeader"')
    table.insert(resultPart, '\r\n|- class="headerRow-0"')
table.insert(resultPart, '\r\n|- class="headerRow-0"')
    table.insert(resultPart, '\r\n!style="min-width:100px"|Name!!style="min-width:180px"|Weapon(s)!!Chance!!Effect')
table.insert(resultPart, '\r\n!Name!!style="min-width:225px"| ' .. sourceHeaderLabel .. (includeSource and '!!Type' or '') .. '!!Chance!!Effect')


    for i, spAttData in Shared.skpairs(spAttTable) do
local firstRow = { idx = true, descType = true, chance = true }
        local spAtt = attacks[i]
local prevRowVal = { idx = 0, descType = '', chance = 0 }
        table.sort(spAttData.Icons, function(a, b) return a < b end)
local resetOnChange = {
idx = { 'idx', 'descType', 'chance' },
descType = { 'descType', 'chance' },
chance = { 'chance' }
}
local rowSuffix = ''
for i, spAttRow in ipairs(spAttTable) do
local spIdx = spAttRow.idx
local spAtt = attacks[spIdx]
-- Determine if it's the first row for any of our groupings
local resetKeys = {}
for key, val in pairs(prevRowVal) do
if spAttRow[key] ~= prevRowVal[key] then
for j, keyName in ipairs(resetOnChange[key]) do
resetKeys[keyName] = true
end
end
prevRowVal[key] = spAttRow[key]
end
for key, val in pairs(firstRow) do
firstRow[key] = (resetKeys[key] ~= nil)
end


        table.insert(resultPart, '\r\n|-')
table.insert(resultPart, '\r\n|-')
        table.insert(resultPart, '\r\n| ' .. spAtt.name)
if firstRow.idx then
        table.insert(resultPart, '\r\n|data-sort-value="' .. spAttData.sortName .. '"| ' .. table.concat(spAttData.Icons, '<br/>'))
rowSuffix = (rowCounts[spIdx]['rows'] > 1 and '|rowspan="' .. rowCounts[spIdx]['rows'] .. '"') or ''
        table.insert(resultPart, '\r\n|data-sort-value="' .. spAtt.defaultChance .. '"| ' .. spAtt.defaultChance .. '%')
table.insert(resultPart, '\r\n' .. rowSuffix .. '| ' .. spAtt.name)
        table.insert(resultPart, '\r\n| ' .. spAtt.description.player)
end
    end
table.insert(resultPart, '\r\n|data-sort-value="' .. spAttRow.sourceSort .. '"| ' .. spAttRow.sourceText)
    table.insert(resultPart, '\r\n|}')
if includeSource then
table.insert(resultPart, '\r\n| ' .. spAttRow.source)
end
if firstRow.chance then
rowSuffix = (rowCounts[spIdx][spAttRow.descType][spAttRow.chance] > 1 and 'rowspan="' .. rowCounts[spIdx][spAttRow.descType][spAttRow.chance] .. '" ') or ''
table.insert(resultPart, '\r\n|' .. rowSuffix .. 'data-sort-value="' .. spAttRow.chance .. '" style="text-align:right;"| ' .. Shared.round(spAttRow.chance, 2, 0) .. '%')
end
if firstRow.descType then
rowSuffix = (rowCounts[spIdx][spAttRow.descType]['rows'] > 1 and '|rowspan="' .. rowCounts[spIdx][spAttRow.descType]['rows'] .. '"') or ''
local spAttDesc = spAtt['description'][spAttRow.descType]
--Adding the time between hits and total duration as a note at the end of the special attack description
local spAttInterval = spAtt.attackInterval ~= nil and spAtt.attackInterval or -1
if(spAttInterval ~= -1 and spAtt.damage ~= nil and Shared.tableCount(spAtt.damage) > 0) then
spAttDesc = spAttDesc..'<br/>('
local spAttDuration = spAttInterval * (spAtt.attackCount - 1)
spAttDesc = spAttDesc..Shared.round(spAttInterval / 1000, 2, 2)..'s delay between attacks.'
if spAtt.attackCount ~= nil and spAtt.attackCount > 2 then
spAttDesc = spAttDesc..' '..Shared.round(spAttDuration / 1000, 2, 2)..'s total duration'
end
spAttDesc = spAttDesc..')'
end
table.insert(resultPart, '\r\n' .. rowSuffix .. '| ' .. spAttDesc)
end
end
table.insert(resultPart, '\r\n|}')


    return table.concat(resultPart)
return table.concat(resultPart)
end
end


function p.getSpecialAttackTable(frame)
function p.getSpecialAttackTable(frame)
    local args = frame.args ~= nil and frame.args or frame
local args = frame.args ~= nil and frame.args or frame
    local tableType = args[1]
local tableCategories = {'Monster', 'Item', 'Spell', 'Familiar'}
    local effectName = args[2]
if args[1] ~= nil and args[1] ~= '' then
    local effectDefn = nil
tableCategories = Shared.splitString(args[1], ',')
end
local effectName = args['effect']
local sourceHeaderLabel = (args['sourceHeader'] ~= '' and args['sourceHeader']) or 'Source'
local includeSource = true
if args['includeSource'] ~= nil and string.lower(args['includeSource']) == 'false' then
includeSource = false
end
local effectDefn = nil
 
if effectName ~= nil and effectName ~= '' then
effectDefn = Attacks.effectDefinition[effectName]
if effectDefn == nil then
local validEffectNames = {}
for k, v in pairs(Attacks.effectDefinition) do
table.insert(validEffectNames, k)
end
table.sort(validEffectNames, function(a, b) return a < b end)


    if effectName ~= nil then
return 'ERROR: Invalid effect name "' .. effectName .. '", must be one of: ' .. table.concat(validEffectNames, ', ') .. '[[Category:Pages with script errors]]'
        effectDefn = Attacks.effectDefinition[effectName]
end
        if effectDefn == nil then
end
            local validEffectNames = {}
            for k, v in pairs(Attacks.effectDefinition) do
                table.insert(validEffectNames, k)
            end
            table.sort(validEffectNames, function(a, b) return a < b end)


            return 'ERROR: Invalid effect name, must be one of: ' .. table.concat(validEffectNames, ', ') .. '[[Category:Pages with script errors]]'
return p._getSpecialAttackTable(effectDefn, tableCategories, sourceHeaderLabel, includeSource)
        end
end
    end


    if tableType == 'Monster' then
-- Generates a table showing the damage/DR multipliers for each combat triangle
        return p._getMonsterSpecialAttackTable(effectDefn)
function p.getCombatTriangleTable()
    elseif tableType == 'Item' then
local triangleAttributes = {
        return p._getItemSpecialAttackTable(effectDefn)
{
    else
["name"] = 'damageModifier',
        return 'ERROR: Invalid table type, must be one of: Item, Monster[[Category:Pages with script errors]]'
["head"] = 'DMG',
    end
["func"] = function(val)
local outVal = 100 * (val - 1)
return { outVal, (outVal < 0 and '' or '+') .. string.format(outVal, '%.0f') .. '%' }
end
},
{
["name"] = 'reductionModifier',
["head"] = 'DR',
["func"] = function(val) return { (val - 1), string.format('%.2fx', val) } end
}
}
local combatStyles = {
{ 'melee', Icons.Icon({ 'Attack', 'Melee', type = 'skill' }) },
{ 'ranged', Icons.Icon({ 'Ranged', type = 'skill' }) },
{ 'magic', Icons.Icon({ 'Magic', type = 'skill' }) }
}
local gameMode = {
{ 'Standard', 'Standard' },
{ 'Hardcore', Icons.Icon({ 'Hardcore' }) }
}
local attrCount = Shared.tableCount(triangleAttributes)
local styleCount = Shared.tableCount(combatStyles)
local modeCount = Shared.tableCount(gameMode)
local resultPart = {}
-- Generate header
table.insert(resultPart, '{| class="wikitable"\r\n|-')
table.insert(resultPart, '\r\n!rowspan="2"| Player Style')
table.insert(resultPart, '\r\n!rowspan="2"| Game Mode')
for i, style in ipairs(combatStyles) do
table.insert(resultPart, '\r\n!colspan="' .. attrCount .. '"| VS ' .. style[2])
end
local attrHeader = ''
for i, attr in ipairs(triangleAttributes) do
attrHeader = attrHeader .. '\r\n! ' .. attr.head
end
table.insert(resultPart, '\r\n|-' .. string.rep(attrHeader, styleCount))
-- Generate table body
for i, attStyle in ipairs(combatStyles) do
local borderStyle = (i < styleCount and 'style="border-bottom:solid lightgrey"' or '')
for j, mode in ipairs(gameMode) do
table.insert(resultPart, '\r\n|-')
if j == 1 then
table.insert(resultPart, '\r\n|rowspan="' .. modeCount .. '" ' .. borderStyle .. '| ' .. attStyle[2])
elseif j == modeCount and borderStyle ~= '' then
table.insert(resultPart, ' ' .. borderStyle)
end
table.insert(resultPart, '\r\n| ' .. mode[2])
for k, targStyle in ipairs(combatStyles) do
for m, attr in ipairs(triangleAttributes) do
local cellStyle = nil
local attValRaw = Constants.getTriangleAttribute(attr.name, attStyle[1], targStyle[1], mode[1])
local attrVal = attr.func(attValRaw)
if attrVal[1] > 0 then
cellStyle = 'background-color:lightgreen;'
elseif attrVal[1] < 0 then
cellStyle = 'background-color:lightpink;'
end
table.insert(resultPart, '\r\n|' .. (cellStyle ~= nil and 'style="' .. cellStyle .. '"| ' or ' ') .. attrVal[2])
end
end
end
end
table.insert(resultPart, '\r\n|}')
return table.concat(resultPart)
end
end


return p
return p
Retrieved from "https://wiki.melvoridle.com/w/Special:MobileDiff/47233...50460"