Module:Sandbox/AuronTest/SourceTables: Difference between revisions

local Magic = require('Module:Magic')

local Attacks = require('Module:AuronTest')

function p._getSpecialAttackTable(effectDefn, categories, sourceHeaderLabel, includeSource)

    local spAttTable = {}

    local attacks = Attacks.getAttacks(function(attack)

                                          if effectDefn == nil then

                                              return Attacks.attackHasEffect(attack, effectDefn)

    local includeCat = {}

    for i, category in ipairs(categories) do

    end

    -- Compile a list of monsters, items, spells, etc. for each included attack

        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)

                if overrideChance then

                    for k, monsterAttack in ipairs(monster.specialAttacks) do

                        local attID = (type(monsterAttack) == 'table' and monsterAttack.id) or monsterAttack

                        end

                    if attIdx ~= nil then

                        attChance = monster.overrideSpecialChances[attIdx]

                end

                table.insert(spAttTable, { idx = i, source = 'Monster', sourceSort = monster.name, sourceText = Icons.Icon({ monster.name, type = 'monster' }), chance = attChance, descType = 'monster' })

        end

        if includeCat['Item'] then

            for j, itemID in ipairs(spAtt.items) do

                local item = Items.getItemByID(itemID)

                table.insert(spAttTable, { idx = i, source = 'Weapon', sourceSort = item.name, sourceText = Icons.Icon({ item.name, type = 'item' }), chance = spAtt.defaultChance, descType = 'player' })

        end

        if includeCat['Spell'] then

            for j, spellID in ipairs(spAtt.spells) do

                local spell = Magic.getSpellByID(spellID[1], spellID[2])

                table.insert(spAttTable, { idx = i, source = 'Spell', sourceSort = spell.name, sourceText = Icons.Icon({ spell.name, type = 'spell' }), chance = spAtt.defaultChance, descType = 'player' })

            end

    end

        local famIdx = Shared.tableCount(attacks) + 1

        local familiars = Items.getItems(function(item)

                                                    return Attacks.attackHasEffect(famAttack, effectDefn)

        for j, familiar in ipairs(familiars) do

            end

            table.insert(spAttTable, { idx = famIdx, 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

            attacks[famIdx] = { name = familiar.name .. ' (Familiar)', description = { player = famDesc } }

    -- Nothing to output if there are no row definitions

    if Shared.tableCount(spAttTable) == 0 then

    return ''

    -- 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.)

    table.sort(spAttTable, function (a, b)

                              local sortKeys = { 'idx', 'descType', 'chance', 'source', 'sourceSort' }

                              for i, key in ipairs(sortKeys) do

                                  if a[key] ~= b[key] then

    -- 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

            rowCounts[idx] = { rows = 0 }

        if rowCounts[idx][dt] == nil then

        end

        if rowCounts[idx][dt][chance] == nil then

            rowCounts[idx][dt][chance] = 0

        rowCounts[idx]['rows'] = rowCounts[idx]['rows'] + 1

        rowCounts[idx][dt]['rows'] = rowCounts[idx][dt]['rows'] + 1

    end

    -- Generate output table

    local resultPart = {}

    table.insert(resultPart, '{|class="wikitable sortable stickyHeader"')

    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')

    local firstRow = { idx = true, descType = true, chance = true }

    local prevRowVal = { idx = 0, descType = '', chance = 0 }

    local resetOnChange = {

        idx = { 'idx', 'descType', 'chance' },

        descType = { 'descType', 'chance' },

        chance = { 'chance' }

    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

        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]

        for key, val in pairs(firstRow) do

            firstRow[key] = (resetKeys[key] ~= nil)

        end

        table.insert(resultPart, '\r\n|-')

        if firstRow.idx then

            rowSuffix = (rowCounts[spIdx]['rows'] > 1 and '|rowspan="' .. rowCounts[spIdx]['rows'] .. '"') or ''

        table.insert(resultPart, '\r\n|data-sort-value="' .. spAttRow.sourceSort .. '"| ' .. spAttRow.sourceText)

            table.insert(resultPart, '\r\n| ' .. spAttRow.source)

            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) .. '%')

        if firstRow.descType then

            rowSuffix = (rowCounts[spIdx][spAttRow.descType]['rows'] > 1 and '|rowspan="' .. rowCounts[spIdx][spAttRow.descType]['rows'] .. '"') or ''

        end

    end

    return table.concat(resultPart)

function p.getSpecialAttackTable(frame)

    local args = frame.args ~= nil and frame.args or frame

    local tableCategories = {'Monster', 'Item', 'Spell', 'Familiar'}

    if args[1] ~= nil and args[1] ~= '' then

        tableCategories = Shared.splitString(args[1], ',')

    local sourceHeaderLabel = (args['sourceHeader'] ~= '' and args['sourceHeader']) or 'Source'

    if args['includeSource'] ~= nil and string.lower(args['includeSource']) == 'false' then

    end

                table.insert(validEffectNames, k)

            end

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

        end

    end

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