Melvor Idle

Module:Attacks/Tables: Difference between revisions

Module Discussion

Module:Attacks/Tables (view source)

Revision as of 21:42, 23 March 2023

786 bytes removed ,  23 March 2023
_getSpecialAttackTable: Fix ancient magicks being unintentionally excluded from output
m (typing is hard.)
(_getSpecialAttackTable: Fix ancient magicks being unintentionally excluded from output)
 
(9 intermediate revisions by the same user not shown)
Line 3: Line 3:
local Constants = require('Module:Constants')
local Constants = require('Module:Constants')
local Shared = require('Module:Shared')
local Shared = require('Module:Shared')
local GameData = require('Module:GameData')
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 Magic = require('Module:Magic')
local Attacks = require('Module:Attacks')
local Attacks = require('Module:Attacks')


function p._getSpecialAttackTable(effectDefn, categories, sourceHeaderLabel, includeSource)
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 = {}
local includeCat = {}
    for i, category in ipairs(categories) do
for i, category in ipairs(categories) do
        includeCat[category] = true
includeCat[category] = true
end
 
    -- Build index so we can tell which to include later
    local includedAttacks = {}
    for i, attack in ipairs(attacks) do
        includedAttacks[attack.id] = true
     end
     end


    -- Compile a list of monsters, items, spells, etc. for each included attack
-- Compile a list of monsters, items, spells, etc. for each included attack
     for i, spAtt in ipairs(attacks) do
     -- Monsters
        -- Monsters
    if includeCat['Monster'] then
        if includeCat['Monster'] then
        for i, monster in ipairs(GameData.rawData.monsters) do
            for j, monsterID in ipairs(spAtt.monsters) do
            if monster.specialAttacks ~= nil and not Shared.tableIsEmpty(monster.specialAttacks) then
                local monster = Monsters.getMonsterByID(monsterID)
                 local overrideChance = (monster.overrideSpecialChances ~= nil and not Shared.tableIsEmpty(monster.overrideSpecialChances))
                 local overrideChance = (monster.overrideSpecialChances ~= nil and Shared.tableCount(monster.overrideSpecialChances) > 0)
                 for j, spAttID in ipairs(monster.specialAttacks) do
                 local attChance = spAtt.defaultChance
                    if includedAttacks[spAttID] then
                if overrideChance then
                         local spAtt = GameData.getEntityByID('attacks', spAttID)
                    local attIdx = nil
                         if spAtt ~= nil then
                    for k, monsterAttack in ipairs(monster.specialAttacks) do
                             local attChance = (overrideChance and monster.overrideSpecialChances[j]) or spAtt.defaultChance
                         local attID = (type(monsterAttack) == 'table' and monsterAttack.id) or monsterAttack
                             table.insert(spAttTable, { id = spAttID, source = 'Monster', sourceSort = monster.name, sourceText = Icons.Icon({ monster.name, type = 'monster' }), chance = attChance, descType = 'monster' })
                         if spAtt.id == attID then
                             attIdx = k
                             break
                         end
                         end
                    end
                    if attIdx ~= nil then
                        attChance = monster.overrideSpecialChances[attIdx]
                     end
                     end
                 end
                 end
                table.insert(spAttTable, { idx = i, source = 'Monster', sourceSort = monster.name, sourceText = Icons.Icon({ monster.name, type = 'monster' }), chance = attChance, descType = 'monster' })
             end
             end
         end
         end
    end


        -- Items/Weapons
    -- Items/Weapons
        if includeCat['Item'] then
    if includeCat['Item'] then
            for j, itemID in ipairs(spAtt.items) do
        for i, item in ipairs(GameData.rawData.items) do
                 local item = Items.getItemByID(itemID)
            if item.specialAttacks ~= nil and not item.golbinRaidExclusive and not Shared.tableIsEmpty(item.specialAttacks) then
                 table.insert(spAttTable, { idx = i, source = 'Weapon', sourceSort = item.name, sourceText = Icons.Icon({ item.name, type = 'item' }), chance = spAtt.defaultChance, descType = 'player' })
                 local overrideChance = (item.overrideSpecialChances ~= nil and not Shared.tableIsEmpty(item.overrideSpecialChances))
                 for j, spAttID in ipairs(item.specialAttacks) do
                    if includedAttacks[spAttID] then
                        local spAtt = GameData.getEntityByID('attacks', spAttID)
                        if spAtt ~= nil then
                            local attChance = (overrideChance and item.overrideSpecialChances[j]) or spAtt.defaultChance
                            table.insert(spAttTable, { id = spAttID, source = 'Weapon', sourceSort = item.name, sourceText = Icons.Icon({ item.name, type = 'item' }), chance = attChance, descType = 'player' })
                        end
                    end
                end
             end
             end
         end
         end
    end


        -- Spells
    -- Spells
        if includeCat['Spell'] then
    if includeCat['Spell'] then
             for j, spellID in ipairs(spAtt.spells) do
        local spellCats = { 'ancientSpells', 'archaicSpells' }
                 local spell = Magic.getSpellByID(spellID[1], spellID[2])
        for i, spellCat in ipairs(spellCats) do
                table.insert(spAttTable, { idx = i, source = 'Spell', sourceSort = spell.name, sourceText = Icons.Icon({ spell.name, type = 'spell' }), chance = spAtt.defaultChance, descType = 'player' })
             for j, spell in ipairs(GameData.rawData[spellCat]) do
            local spAttID = spell.specialAttack or spell.specialAttackID
                 if spAttID ~= nil and includedAttacks[spAttID] then
                    local spAtt = GameData.getEntityByID('attacks', spAttID)
                    if spAtt ~= nil then
                        table.insert(spAttTable, {id = spAtt.id, source = 'Spell', sourceSort = spell.name, sourceText = Icons.Icon({ spell.name, type = 'spell' }), chance = spAtt.defaultChance, descType = 'player' })
                    end
                end
             end
             end
         end
         end
     end
     end


    -- Summoning familiars. Any effects inflicted by combat familiars aren't actually special
-- Summoning familiars. Any effects inflicted by combat familiars aren't actually special
    -- attacks, therefore the handling here is a bit different and outside of the above attack loop
-- attacks, therefore the handling here is a bit different
    if includeCat['Familiar'] then
if includeCat['Familiar'] then
        local famIdx = Shared.tableCount(attacks) + 1
local famIdx = Shared.tableCount(attacks) + 1
        local familiars = Items.getItems(function(item)
local familiars = Items.getItems(
                                            if item.type == 'Familiar' and Items._getItemStat(item, 'summoningMaxhit') ~= nil and item.modifiers ~= nil then
            function(item)
                                                local famAttack = { prehitEffects = {}, onhitEffects = { { type = 'Modifier', subtype = 'Familiar', modifiers = item.modifiers } } }
                if item.type == 'Familiar' and item.modifiers ~= nil and Items._getItemStat(item, 'summoningMaxhit') ~= nil then
                                                if effectDefn == nil then
                    local famAttack = { prehitEffects = {}, onhitEffects = { { type = 'Modifier', subtype = 'Familiar', modifiers = item.modifiers } } }
                                                    return Shared.tableCount(Attacks.getAttackEffects(famAttack)) > 0
                    if effectDefn == nil then
                                                else
                        return Shared.tableIsEmpty(Attacks.getAttackEffects(famAttack))
                                                    return Attacks.attackHasEffect(famAttack, effectDefn)
                    else
                                                end
                        return Attacks.attackHasEffect(famAttack, effectDefn)
                                            end
                    end
                                            return false
                                        end)
        for j, familiar in ipairs(familiars) do
            -- For chance, assume the first modifier we come across has the chance, which is pretty lazy
            local famChance, famDesc = 0, ''
            for modName, modVal in pairs(familiar.modifiers) do
                if type(modVal) == 'table' and type(modVal[1]) == 'number' then
                    famChance = modVal[1]
                elseif type(modVal) == 'number' then
                    famChance = modVal
                else
                    famChance = 0
                 end
                 end
                 famDesc = Constants._getModifierText(modName, modVal, false)
                 return false
                break
            end)
            end
for i, familiar in ipairs(familiars) do
-- For chance, assume the first modifier we come across has the chance, which is pretty lazy
local famChance, famDesc = 0, ''
for modName, modVal in pairs(familiar.modifiers) do
if type(modVal) == 'table' and type(modVal[1]) == 'number' then
famChance = modVal[1]
elseif type(modVal) == 'number' then
famChance = modVal
else
famChance = 0
end
famDesc = Constants._getModifierText(modName, modVal, false)
break
end


            table.insert(spAttTable, { idx = famIdx, source = 'Familiar', sourceSort = familiar.name, sourceText = Icons.Icon({ familiar.name, type = 'item' }), chance = famChance or 0, descType = 'player' })
table.insert(spAttTable, { id = familiar.id, source = 'Familiar', sourceSort = familiar.name, sourceText = Icons.Icon({ familiar.name, type = 'item' }), chance = famChance or 0, descType = 'player' })
            -- Slap a dummy entry into the attacks table for this familiar
-- Slap a dummy entry into the attacks table for this familiar
            attacks[famIdx] = { name = familiar.name .. ' (Familiar)', description = { player = famDesc } }
attacks[famIdx] = { id = familiar.id, name = familiar.name .. ' (Familiar)', description = famDesc }
            famIdx = famIdx + 1
famIdx = famIdx + 1
        end
end
    end
end


    -- Nothing to output if there are no row definitions
-- Nothing to output if there are no row definitions
    if Shared.tableCount(spAttTable) == 0 then
if Shared.tableIsEmpty(spAttTable) then
    return ''
return ''
    end
end


    -- Sort entries into desired order and generate stats to determine row spans:
-- Sort entries into desired order and generate stats to determine row spans:
    -- By attack index, description type (monster/player), chance, source, then source name (weapon/item/etc.)
-- By attack index, description type (monster/player), chance, source, then source name (weapon/item/etc.)
    table.sort(spAttTable, function (a, b)
table.sort(spAttTable, function (a, b)
                              local sortKeys = { 'idx', 'descType', 'chance', 'source', 'sourceSort' }
local sortKeys = { 'id', 'descType', 'chance', 'source', 'sourceSort' }
                              for i, key in ipairs(sortKeys) do
for i, key in ipairs(sortKeys) do
                                  if a[key] ~= b[key] then
if a[key] ~= b[key] then
                                      return a[key] < b[key]
return a[key] < b[key]
                                  end
end
                              end
end
                              return false
return false
                          end)
end)
    -- Determine row counts for grouping/rowspans
-- Determine row counts for grouping/rowspans
    local rowCounts = {}
local rowCounts = {}
    for i, rowDefn in ipairs(spAttTable) do
for i, rowDefn in ipairs(spAttTable) do
        local idx, dt, chance = rowDefn.idx, rowDefn.descType, rowDefn.chance
local id, dt, chance = rowDefn.id, rowDefn.descType, rowDefn.chance
        if rowCounts[idx] == nil then
if rowCounts[id] == nil then
            rowCounts[idx] = { rows = 0 }
rowCounts[id] = { rows = 0 }
        end
end
        if rowCounts[idx][dt] == nil then
if rowCounts[id][dt] == nil then
            rowCounts[idx][dt] = { rows = 0 }
rowCounts[id][dt] = { rows = 0 }
        end
end
        if rowCounts[idx][dt][chance] == nil then
if rowCounts[id][dt][chance] == nil then
            rowCounts[idx][dt][chance] = 0
rowCounts[id][dt][chance] = 0
        end
end
        rowCounts[idx]['rows'] = rowCounts[idx]['rows'] + 1
rowCounts[id]['rows'] = rowCounts[id]['rows'] + 1
        rowCounts[idx][dt]['rows'] = rowCounts[idx][dt]['rows'] + 1
rowCounts[id][dt]['rows'] = rowCounts[id][dt]['rows'] + 1
        rowCounts[idx][dt][chance] = rowCounts[idx][dt][chance] + 1
rowCounts[id][dt][chance] = rowCounts[id][dt][chance] + 1
    end
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!Name!!style="min-width:225px"| ' .. sourceHeaderLabel .. (includeSource and '!!Type' or '') .. '!!Chance!!Effect')
table.insert(resultPart, '\r\n!Name!!style="min-width:225px"| ' .. sourceHeaderLabel .. (includeSource and '!!Type' or '') .. '!!Chance!!Effect')


    local firstRow = { idx = true, descType = true, chance = true }
local firstRow = { id = true, descType = true, chance = true }
    local prevRowVal = { idx = 0, descType = '', chance = 0 }
local prevRowVal = { id = 0, descType = '', chance = 0 }
    local resetOnChange = {
local resetOnChange = {
        idx = { 'idx', 'descType', 'chance' },
id = { 'id', 'descType', 'chance' },
        descType = { 'descType', 'chance' },
descType = { 'descType', 'chance' },
        chance = { 'chance' }
chance = { 'chance' }
    }
}
    local rowSuffix = ''
local rowSuffix = ''
    for i, spAttRow in ipairs(spAttTable) do
for i, spAttRow in ipairs(spAttTable) do
        local spIdx = spAttRow.idx
local spIdx = spAttRow.id
        local spAtt = attacks[spIdx]
local spAtt = GameData.getEntityByID(attacks, spIdx)
        -- Determine if it's the first row for any of our groupings
-- Determine if it's the first row for any of our groupings
        local resetKeys = {}
local resetKeys = {}
        for key, val in pairs(prevRowVal) do
for key, val in pairs(prevRowVal) do
            if spAttRow[key] ~= prevRowVal[key] then
if spAttRow[key] ~= prevRowVal[key] then
                for j, keyName in ipairs(resetOnChange[key]) do
for j, keyName in ipairs(resetOnChange[key]) do
                    resetKeys[keyName] = true
resetKeys[keyName] = true
                end
end
            end
end
            prevRowVal[key] = spAttRow[key]
prevRowVal[key] = spAttRow[key]
        end
end
        for key, val in pairs(firstRow) do
for key, val in pairs(firstRow) do
            firstRow[key] = (resetKeys[key] ~= nil)
firstRow[key] = (resetKeys[key] ~= nil)
        end
end


        table.insert(resultPart, '\r\n|-')
table.insert(resultPart, '\r\n|-')
        if firstRow.idx then
if firstRow.id then
            rowSuffix = (rowCounts[spIdx]['rows'] > 1 and '|rowspan="' .. rowCounts[spIdx]['rows'] .. '"') or ''
rowSuffix = (rowCounts[spIdx]['rows'] > 1 and '|rowspan="' .. rowCounts[spIdx]['rows'] .. '"') or ''
            table.insert(resultPart, '\r\n' .. rowSuffix .. '| ' .. spAtt.name)
table.insert(resultPart, '\r\n' .. rowSuffix .. '| ' .. spAtt.name)
        end
end
        table.insert(resultPart, '\r\n|data-sort-value="' .. spAttRow.sourceSort .. '"| ' .. spAttRow.sourceText)
table.insert(resultPart, '\r\n|data-sort-value="' .. spAttRow.sourceSort .. '"| ' .. spAttRow.sourceText)
        if includeSource then
if includeSource then
            table.insert(resultPart, '\r\n| ' .. spAttRow.source)
table.insert(resultPart, '\r\n| ' .. spAttRow.source)
        end
end
        if firstRow.chance then
if firstRow.chance then
            rowSuffix = (rowCounts[spIdx][spAttRow.descType][spAttRow.chance] > 1 and 'rowspan="' .. rowCounts[spIdx][spAttRow.descType][spAttRow.chance] .. '" ') or ''
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) .. '%')
table.insert(resultPart, '\r\n|' .. rowSuffix .. 'data-sort-value="' .. spAttRow.chance .. '" style="text-align:right;"| ' .. Shared.round(spAttRow.chance, 2, 0) .. '%')
        end
end
        if firstRow.descType then
if firstRow.descType then
            rowSuffix = (rowCounts[spIdx][spAttRow.descType]['rows'] > 1 and '|rowspan="' .. rowCounts[spIdx][spAttRow.descType]['rows'] .. '"') or ''
rowSuffix = (rowCounts[spIdx][spAttRow.descType]['rows'] > 1 and '|rowspan="' .. rowCounts[spIdx][spAttRow.descType]['rows'] .. '"') or ''
            local spAttDesc = spAtt['description'][spAttRow.descType]
local spAttDesc = spAtt.description
            --Adding the time between hits and total duration as a note at the end of the special attack description
--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
local spAttInterval = spAtt.attackInterval ~= nil and spAtt.attackInterval or -1
            if(spAttInterval ~= -1 and spAtt.damage ~= nil and Shared.tableCount(spAtt.damage) > 0) then
if(spAttInterval ~= -1 and spAtt.damage ~= nil and Shared.tableCount(spAtt.damage) > 0) then
            spAttDesc = spAttDesc..'<br/>('
spAttDesc = spAttDesc..'<br/>('
            local spAttDuration = spAttInterval * (spAtt.attackCount - 1)
local spAttDuration = spAttInterval * (spAtt.attackCount - 1)
            spAttDesc = spAttDesc..Shared.round(spAttInterval / 1000, 2, 2)..'s delay between attacks.'
spAttDesc = spAttDesc..Shared.round(spAttInterval / 1000, 2, 2)..'s delay between attacks.'
            if spAtt.attackCount ~= nil and spAtt.attackCount > 2 then
if spAtt.attackCount ~= nil and spAtt.attackCount > 2 then
            spAttDesc = spAttDesc..' '..Shared.round(spAttDuration / 1000, 2, 2)..'s total duration'
spAttDesc = spAttDesc..' '..Shared.round(spAttDuration / 1000, 2, 2)..'s total duration'
            end
end
            spAttDesc = spAttDesc..')'
spAttDesc = spAttDesc..')'
            end
end
            table.insert(resultPart, '\r\n' .. rowSuffix .. '| ' .. spAttDesc)
table.insert(resultPart, '\r\n' .. rowSuffix .. '| ' .. spAttDesc)
        end
end
    end
end
    table.insert(resultPart, '\r\n|}')
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 tableCategories = {'Monster', 'Item', 'Spell', 'Familiar'}
local tableCategories = {'Monster', 'Item', 'Spell', 'Familiar'}
    if args[1] ~= nil and args[1] ~= '' then
if args[1] ~= nil and args[1] ~= '' then
        tableCategories = Shared.splitString(args[1], ',')
tableCategories = Shared.splitString(args[1], ',')
    end
end
    local effectName = args['effect']
local effectName = args['effect']
    local sourceHeaderLabel = (args['sourceHeader'] ~= '' and args['sourceHeader']) or 'Source'
local sourceHeaderLabel = (args['sourceHeader'] ~= '' and args['sourceHeader']) or 'Source'
    local includeSource = true
local includeSource = true
    if args['includeSource'] ~= nil and string.lower(args['includeSource']) == 'false' then
if args['includeSource'] ~= nil and string.lower(args['includeSource']) == 'false' then
        includeSource = false
includeSource = false
    end
end
    local effectDefn = nil
local effectDefn = nil


    if effectName ~= nil and effectName ~= '' then
if effectName ~= nil and effectName ~= '' then
        effectDefn = Attacks.effectDefinition[effectName]
effectDefn = Attacks.effectDefinition[effectName]
        if effectDefn == nil then
if effectDefn == nil then
            local validEffectNames = {}
local validEffectNames = {}
            for k, v in pairs(Attacks.effectDefinition) do
for k, v in pairs(Attacks.effectDefinition) do
                table.insert(validEffectNames, k)
table.insert(validEffectNames, k)
            end
end
            table.sort(validEffectNames, function(a, b) return a < b end)
table.sort(validEffectNames, function(a, b) return a < b end)


            return 'ERROR: Invalid effect name "' .. effectName .. '", must be one of: ' .. table.concat(validEffectNames, ', ') .. '[[Category:Pages with script errors]]'
return Shared.printError('Invalid effect name "' .. effectName .. '", must be one of: ' .. table.concat(validEffectNames, ', '))
        end
end
    end
end


    return p._getSpecialAttackTable(effectDefn, tableCategories, sourceHeaderLabel, includeSource)
return p._getSpecialAttackTable(effectDefn, tableCategories, sourceHeaderLabel, includeSource)
end
end


Line 256: Line 272:
}
}
local gameMode = {
local gameMode = {
{ 'Standard', 'Standard' },
{ 'Standard Mode', 'Standard' },
{ 'Hardcore', Icons.Icon({ 'Hardcore' }) }
{ 'Hardcore Mode', Icons.Icon({ 'Hardcore' }) }
}
}
local attrCount = Shared.tableCount(triangleAttributes)
local attrCount = Shared.tableCount(triangleAttributes)
Retrieved from "https://wiki.melvoridle.com/w/Special:MobileDiff/49819...60701"