Module:HeroesOverview

Documentation for this module may be created at Module:HeroesOverview/doc

-- Usage: {{#invoke:HeroesOverview|display|lang=en|faction=Temple}}
local p = {}
local f = mw.ustring.format
local SkillsOverview = require("Module:SkillsOverview")

local FACTION_ORDER = {
    human = 1,
    undead = 2,
    nature = 3,
    demon = 4,
    unfrozen = 5,
    dungeon = 6,
}

local MIGHT_MAGIC_ORDER = {
    might = 1,
    magic = 2,
}

local FACTION_MAPPING = {
    Temple = 'human',
    Necropolis = 'undead',
    Grove = 'nature',
    Hive = 'demon',
    Schism = 'unfrozen',
    Dungeon = 'dungeon',
}

local TYPE_ICONS = {
    might = 'Wip_Might_Specialization_Icon',
    magic = 'Wip_Mage_Specialization_Icon',
}

-- Note: The right side is just a fallback, it will seldom be used.
local TRANSLATION_IDS = {
    wiki_name = 'Name',
    wiki_faction = 'Faction',
    wiki_heroes_type = 'Type',
    wiki_heroes_class = 'Class',
    wiki_hero_specialty = 'Specialty',
    wiki_faction_skill = 'Faction Skill',
    wiki_heroes_starting_skill = 'Starting Skill',
    wiki_spell = 'Spell',
    wiki_might = 'Might',
    wiki_magic = 'Magic',
}

local SPEC_ICON_REPLACEMENTS = {
    Human = 'Temple',
    Necro = 'Necropolis',
    Nature = 'Grove',
    Demon = 'Hive',
    Unfrozen = 'Schism',
}

local PATCH_NAME = {
    ['Summon Avatar'] = 'Summon Avatar (Skill)',
}

-- Displays a variable
------------------------------------------------------------------------------------------------------------------------
local function dump(target)
    return '<pre>' .. mw.dumpObject(target) .. '</pre>'
end

-- Spawns a safe robotic url from an English name, fit for adding it before the visible name
------------------------------------------------------------------------------------------------------------------------
local function getUrl(nameEn, lang)
    if not nameEn then
        return ''
    end
    local url = PATCH_NAME[nameEn] or nameEn
    if lang ~= 'en' then
        url = url .. '/' .. lang
    end
    return url
end

------------------------------------------------------------------------------------------------------------------------
local function convertToTitleCase(str)
    local titleCased = str:lower():gsub("%f[%a]%a", string.upper)
    return titleCased
end

------------------------------------------------------------------------------------------------------------------------
local function cleanHtmlWhitespace(str)
    local cleaned = str:gsub(">%s+", ">"):gsub("%s+<", "<")
    return cleaned
end

-- Retrieves the text for some specific ids from Cargo Translations.
------------------------------------------------------------------------------------------------------------------------
local function translateIds(ids, lang, extra)
    -- Key list
    local list = {}
    for key, _ in pairs(ids) do
        list[#list + 1] = key
    end
    local idListString = '"' .. table.concat(list, '", "') .. '"'

    -- Cargo
    local where = {}
    table.insert(where, 'target_id IN (' .. idListString .. ')')
    table.insert(where, 'language = "' .. lang .. '"')
    if extra then
        table.insert(where, extra)
    end
    local results = mw.ext.cargo.query('Translation', 'target_id, name', {
        where = table.concat(where, ' AND '),
        limit = 100
    })

    -- Dictionary
    local dictionary = mw.clone(ids)
    for key, value in pairs(dictionary) do
        dictionary[key] = value .. '[[Data:WikiTranslations/' .. lang .. '#' .. key .. '|💬]]'
    end
    for _, row in ipairs(results) do
        dictionary[row['target_id']] = row['name']
    end
    return dictionary
end

-- Converts a dictionary into a linear array
------------------------------------------------------------------------------------------------------------------------
local function flatten(hub)
    local list = {}
    for _, entry in pairs(hub) do
        list[#list + 1] = entry
    end
    return list
end

-- Interrogates the Hero Cargo table
------------------------------------------------------------------------------------------------------------------------
local function queryHero(lang, forcedFaction)
    -- fields:
    local fields = {}
    table.insert(fields, 'Hero.id = id');
    table.insert(fields, 'Hero.class_id = class_id');
    table.insert(fields, 'Hero.faction = faction');
    table.insert(fields, 'Hero.class_type = class_type');
    table.insert(fields, 'Hero.icon = icon');
    table.insert(fields, 'Hero.specialization_id = specialization_id');
    table.insert(fields, 'Hero.start_skills = start_skills');
    table.insert(fields, 'Hero.start_skill_levels = start_skill_levels');
    table.insert(fields, 'Hero.start_magics = start_magics');
    table.insert(fields, 'Translation.name = name');
    table.insert(fields, 'Translation.language = language');

    -- where:
    local where = {}
    local _ = forcedFaction and table.insert(where, 'Hero.faction="' .. forcedFaction .. '"')
    table.insert(where, 'Hero.id not like "campaign%"')
    table.insert(where, 'Hero.id not like "tutorial%"')
    table.insert(where, 'Hero.id not like "%_fun_%"')
    table.insert(where, 'Translation.type = "hero"')
    table.insert(where, '(Translation.language = "en" OR Translation.language = "' .. lang .. '")')

    -- query:
    return mw.ext.cargo.query('Hero, Translation', table.concat(fields, ','), {
        join = 'Hero.id = Translation.target_id',
        where = table.concat(where, ' AND '),
        limit = 500
    })
end

-- Interrogates the HeroSpecialization Cargo table
------------------------------------------------------------------------------------------------------------------------
local function queryHeroSpecialization(lang)
    -- fields:
    local fields = {}
    table.insert(fields, 'HeroSpecialization.id = id');
    table.insert(fields, 'HeroSpecialization.icon = icon');
    table.insert(fields, 'Translation.name = name');
    table.insert(fields, 'Translation.description = description');

    -- where:
    local where = {}
    table.insert(where, 'Translation.language = "' .. lang .. '"')

    -- query:
    return mw.ext.cargo.query('HeroSpecialization, Translation', table.concat(fields, ','), {
        join = 'HeroSpecialization.id = Translation.target_id',
        where = table.concat(where, ' AND '),
        limit = 500
    })
end

-- Folds all Cargo results into a single dictionary:
------------------------------------------------------------------------------------------------------------------------
local function consolidateHeroes(lang, heroesResults, specializations, skillsHub, spells)
    -- specializations
    local specHub = {}
    for _, row in ipairs(specializations) do
        specHub[row.id] = {
            icon = row.icon or '',
            name = row.name or '',
            description = row.description or '',
        }
    end

    -- heroes
    local hub = {}
    for _, row in ipairs(heroesResults) do
        local id = row.id
        local entry = hub[id]
        if not entry then
            entry = {}
            entry.id = id or ''
            entry.class_id = row.class_id or ''
            entry.faction = row.faction or ''
            entry.class_type = row.class_type or ''
            entry.icon = row.icon or ''
            entry.start_skills = row.start_skills or ''
            entry.start_skill_levels = row.start_skill_levels or ''
            entry.start_magics = row.start_magics or ''
            local spec = specHub[row.specialization_id] or {}
            entry.specIcon = spec.icon or ''
            entry.specName = spec.name or ''
            entry.specDescription = spec.description or ''
            hub[id] = entry
        end
        if row.language == lang then
            entry.name = row.name or ''
        end
        if row.language == 'en' then
            entry.nameEn = row.name or ''
        end
    end
    return hub
end

------------------------------------------------------------------------------------------------------------------------
local function sortHeroes(a, b)
    local factionA = FACTION_ORDER[a.faction] or 99
    local factionB = FACTION_ORDER[b.faction] or 99
    if factionA ~= factionB then
        return factionA < factionB
    end

    local mmA = MIGHT_MAGIC_ORDER[a.class_type] or 99
    local mmB = MIGHT_MAGIC_ORDER[b.class_type] or 99
    if mmA ~= mmB then
        return mmA < mmB
    end

    return a.id < b.id
end

-- Boilerplate for the header cells
------------------------------------------------------------------------------------------------------------------------
local function addTh(tr, text)
    tr:tag('th'):wikitext(text):done()
end

-- Boilerplate for the body cells
------------------------------------------------------------------------------------------------------------------------
local function addTd(tr, content)
    if type(content) == "string" then
        tr:tag('td'):wikitext(content):done()
    else
        tr:tag('td'):node(content):done()
    end
end

-- Boilerplate for the separator rows
------------------------------------------------------------------------------------------------------------------------
local function addSeparator(htmlTable, className, content)
    htmlTable:tag('tr')
        :addClass('separator')
        :addClass(className)
        :tag('td'):attr('data-sort-value', ''):attr('colspan', 100):wikitext(content):done()
end

------------------------------------------------------------------------------------------------------------------------
local function renderFactionHeader(frame, words)
    local file = '[[File:Base_passive_staunch_1.png|32px|link=]]';
    local text = words.wiki_faction_skill
    return frame:preprocess('{{Hint|' .. file .. '|' .. text .. '}}')
end

------------------------------------------------------------------------------------------------------------------------
local function createHeader(htmlTable, frame, words)
    local tr = htmlTable:tag('tr')
    addTh(tr, words.wiki_name)
    addTh(tr, words.wiki_heroes_type)
    addTh(tr, words.wiki_heroes_class)
    addTh(tr, words.wiki_hero_specialty)
    addTh(tr, renderFactionHeader(frame, words))
    addTh(tr, words.wiki_heroes_starting_skill)
    addTh(tr, words.wiki_spell)
end

------------------------------------------------------------------------------------------------------------------------
local function renderFaction(faction, lang, frame)
    return frame:preprocess('{{F|' .. faction .. '|' .. lang .. '}}')
end

------------------------------------------------------------------------------------------------------------------------
local function renderName(name, nameEn, lang)
    local url = getUrl(nameEn, lang)
    return f('[[File:%s.png|70px|link=%s]]<br>[[%s|%s]]', nameEn, url, url, name)
end

------------------------------------------------------------------------------------------------------------------------
local function renderType(type, words, frame)
    local file = '[[File:' .. TYPE_ICONS[type] .. '.png|32px|link=]]';
    local text = type == 'magic' and words.wiki_magic or words.wiki_might
    return frame:preprocess('{{Hint|' .. file .. '|' .. text .. '}}')
end

------------------------------------------------------------------------------------------------------------------------
local function renderClass(class, lang, frame)
    return frame:preprocess('{{LinkIcon|type=hero_class|id=' .. class .. '|suffix=_icon.png|lang=' .. lang .. '}}')
end

------------------------------------------------------------------------------------------------------------------------
local function renderSpecialty(icon, name, description)
    icon = convertToTitleCase(icon)
    for key, value in pairs(SPEC_ICON_REPLACEMENTS) do
        icon = string.gsub(icon, key, value)
    end
    local markup = [=[
        <div class='specialty'>
            <div class='specialty-icon'>
                [[File:%s.png|64px|link=]]
            </div>
            <div class='specialty-text'>
                <b>%s</b>: %s
            </div>
        </div>
    ]=]
    return cleanHtmlWhitespace(f(markup, icon, name, description))
end

------------------------------------------------------------------------------------------------------------------------
local function renderFactionSkill(startSkills, skillsHub, lang, frame)
    local factionSkill = mw.text.split(startSkills, ',')[1] or ''
    local skill = skillsHub[factionSkill] or {}
    local ranks = skill.ranks or {}
    local rank = ranks[1] or { icon = '' }
    local url = getUrl(skill.nameEn, lang)
    local file = f('[[File:%s.png|32px|link=%s]]', rank.icon, url);
    local text = skill.name
    return frame:preprocess('{{Hint|' .. file .. '|' .. text .. '}}')
end

------------------------------------------------------------------------------------------------------------------------
local function renderStartSkill(startSkills, skillsHub, lang)
    local parts = mw.text.split(startSkills, ',')
    local skill
    local rank
    local name
    if parts[2] then
        skill = skillsHub[parts[2]] or {}
        local ranks = skill.ranks or {}
        rank = ranks[1] or { icon = '', name = '' }
        name = skill.name
    else
        skill = skillsHub[parts[1]] or {}
        local ranks = skill.ranks or {}
        rank = ranks[2] or { icon = '', name = '' }
        name = rank.name
    end
    local url = getUrl(skill.nameEn, lang)
    local file = f('[[File:%s.png|32px|link=%s]]', rank.icon, url);
    local link = '[[' .. url .. '|' .. name .. ']]'
    return file .. ' ' .. link
end

------------------------------------------------------------------------------------------------------------------------
local function renderSpell(startMagics, frame, lang)
    if startMagics == '' then return '' end

    local ids = mw.text.split(startMagics, ',')
    local texts = {}
    for _, id in ipairs(ids) do
        if id ~= 'change_use_necromancy' and not id:find('astral_summon') then
            local cleanId = string.gsub(id, '_special$', '')
            local text = frame:preprocess(f('{{LinkIcon|type=spell|id=%s|lang=%s}}', cleanId, lang))
            if cleanId ~= id then
                text = text .. '+'
            end
            table.insert(texts, text)
        end
    end

    return table.concat(texts, '<br>')
end

------------------------------------------------------------------------------------------------------------------------
local function createBody(htmlTable, heroes, lang, frame, words, skillsHub)
    local currentType = #heroes > 0 and heroes[1].class_type
    local currentFaction = #heroes > 0 and heroes[1].faction
    for _, hero in ipairs(heroes) do
        -- separators
        if hero.faction ~= currentFaction then
            currentFaction = hero.faction
            currentType = hero.class_type
            addSeparator(htmlTable, 'separator-large', renderFaction(currentFaction, lang, frame))
        elseif hero.class_type ~= currentType then
            currentType = hero.class_type
            addSeparator(htmlTable, 'separator-tiny', '')
        end

        local tr = htmlTable:tag('tr'):addClass('hero')
        addTd(tr, renderName(hero.name, hero.nameEn, lang))
        addTd(tr, renderType(hero.class_type, words, frame))
        addTd(tr, renderClass(hero.class_id, lang, frame))
        addTd(tr, renderSpecialty(hero.specIcon, hero.specName, hero.specDescription))
        addTd(tr, renderFactionSkill(hero.start_skills, skillsHub, lang, frame))
        addTd(tr, renderStartSkill(hero.start_skills, skillsHub, lang))
        addTd(tr, renderSpell(hero.start_magics, frame, lang))
    end
end

-- M A I N
------------------------------------------------------------------------------------------------------------------------
function p.display(frame)
    --do return dump(frame) end

    -- Args
    local args = frame.args
    local lang = args.lang ~= '' and args.lang or 'en'
    --lang = 'ja'
    local forcedFaction = FACTION_MAPPING[args.faction] or nil

    -- Language
    local words = translateIds(TRANSLATION_IDS, lang)

    -- Cargo
    local heroesResults = queryHero(lang, forcedFaction)
    local specializations = queryHeroSpecialization(lang)
    local skillsHub = SkillsOverview.getSkillsFromCargo(lang)
    local heroesHub = consolidateHeroes(lang, heroesResults, specializations, skillsHub)
    local heroes = flatten(heroesHub);

    -- Various manipulations
    table.sort(heroes, sortHeroes)

    -- Table
    local htmlTable = mw.html.create('table')
    htmlTable:addClass('wikitable sortable')
    createHeader(htmlTable, frame, words)
    createBody(htmlTable, heroes, lang, frame, words, skillsHub)

    -- Output
    local styleTag = frame:extensionTag('templatestyles', '', { src = frame:getTitle() .. '/styles.css' })
    return styleTag .. tostring(htmlTable)
end

return p