ФЭНДОМ


--Исходно взято с англовики Module:Mods 12.05.2020
 
--Пользовательские функции:
--  buildModGallery()
--  exportFromTemplate()
--  printModRow()
 
-- Функции работы инфобокса:
--  getValue()
--  modEname()
--  modImage()
--  modMode()
--  modName()
--  modSyndicate()
--  modTax()
--  modTransmutable()
--  modType()
 
--Служебные функции:
--  checkAltMisc()
--  checkAltTypes()
--  getEmSubtypes()
--  getFilteredTable()
--  getMod()
--  getModCount()
--  ifModExists()
--  importFromTemplate()
--  modInfobox()
--  toNil()
--  tooltip()
--  tooltiptext()
 
 
local p = {}
 
local ModData = mw.loadData('Модуль:Мод/Данные')
local Shared = require('Модуль:Функции')
local Icons = require('Модуль:Иконка')
 
cat_error = '[[Категория:Ошибка Мод инфобокс]]'
 
local tl = {['Название']        = 'Name',             -- таблица транслитерации
            ['Переход']         = 'Ename',
            ['Изображение']     = 'Image',
            ['Полярность']      = 'Polarity',
            ['Редкость']        = 'Rarity',
            ['Тип']             = 'Type',
            ['Подтип']          = 'Subtype',
            ['Режим']           = 'Mode',
            ['Эксилус']         = 'Exilus',
            ['Преобразование']  = 'Transmutable',
            ['Ссылка']          = 'Link',
            ['Налог']           = 'Tradetax',
            ['Выведен']         = 'Exclude',
    }
 
function p.test(frame)
    local cart ={}
    for modName, Mod in pairs(ModData) do
        if not Mod.Name then
    table.insert(cart, '[['..modName..']]')
    else table.insert(cart, '[['..Mod.Name..']]') end
 
 
    end
    return a --table.concat(cart, ' • ')
 
    end
 
----------------------------------------------------------------
------------------------Возвращает картинку Мода по его названию
----------------------------(используется в Шаблон:Мод инфобокс)
----------------------------------------------------------------
function p.modImage(frame)
    if type(frame)=='table' then ModName = frame.args[1]
    elseif type(frame)=='string' then ModName = frame end
    local Mod = getMod(ModName)
    local ttlo = mw.title.new(ModName..'_вики.png', "Файл")
    local cart ='[[Категория:Моды]]'
 
    if ifModExists(ModName,Mod) and Mod.Exclude then cart = '' end
    if mw.ustring.find(ModName,'Прайм') ~= nil then
        cart = cart..'[[Категория:Прайм моды]]'
    end
 
    if ModName and ifModExists(ModName,Mod) and Mod.Image then 
        if mw.title.new(Mod.Image, "Файл").exists 
            then cart = cart..'[[Файл:'..Mod.Image..'|x300px|center|middle]]'
            else cart = cart..'[[Файл:Мод_рамка_вики.png|x300px|center|middle|link=Файл:'..Mod.Image..']]'
            end
        elseif ttlo.exists then cart = cart..'[[Файл:'..ModName..'_вики.png|x300px|center|middle]]'
        else cart = cart..'[[Файл:Мод_рамка_вики.png|x300px|center|middle|link=Файл:'..ModName..'_вики.png]]'
    end
 
    if toNil(ModName)==nil then
        cart = cart..'<br /><span style="color:red; font-weight:bold;">ОШИБКА: Не указано название Мода</span>'..cat_error
    elseif not ifModExists(ModName,Mod) then
        if not ttlo.exists then
            cart = cart..'<br /><span style="color:red; font-weight:bold;">ОШИБКА: [[:Файл:'..ModName..'_вики.png|Изображение не загружено]]'..cat_error
        else
            cart = cart..'<br /><span style="color:red; font-weight:bold;">ОШИБКА: Данный Мод не найден в базе модов [[:Модуль:Мод/Данные]]</span>'..cat_error
        end
    elseif ifModExists(ModName,Mod) and Mod.Image and not mw.title.new(Mod.Image, "Файл").exists then cart = cart..'<br /><span style="color:red; font-weight:bold;">ОШИБКА: [[:Файл:'..Mod.Image..'|Изображение указанное в Базе Данных не загружено]]'..cat_error
    end
    return cart
 
end
 
----------------------------------------------------------------
-------------------------Возвращает о возможности преобразования
----------------------------(используется в Шаблон:Мод инфобокс)
----------------------------------------------------------------
function p.modTransmutable(frame)
    local ModName
    if type(frame)=='table' then ModName = frame.args[1]
    elseif type(frame)=='string' then ModName = frame end
    local Mod = getMod(ModName)
 
    if ModName == nil or not ifModExists (ModName, Mod) then return nil
    elseif Mod.Transmutable then
        return '[[Преобразование|<span style="color: #fff; font-weight: 700; font-size: 1em;">Преобразуется</span>]][[Категория:Трансмутируемые моды]]'
    else 
        return '[[Преобразование|<span style="color: #ff5454; font-weight: 700;	font-size: 1em;">Не преобразуется</span>]][[Категория:Нетрансмутируемые моды]]'
    end
end
 
----------------------------------------------------------------
----------------------Возвращает информацию по налогу при обмене 
----------------------------(используется в Шаблон:Мод инфобокс)
----------------------------------------------------------------
function p.modTax(frame)
    local ModName
    if type(frame)=='table' then ModName = frame.args[1]
    elseif type(frame)=='string' then ModName = frame end
    local Mod = getMod(ModName)
 
    if ModName == nil or not ifModExists (ModName, Mod) or Mod.Rarity == nil then return nil end
 
    if Mod.Tradetax then return Mod.Tradetax
    elseif Mod.Rarity == 'Обычный'     then price_ = 2000    cat_ = '[[Категория:'..Mod.Rarity..']]'
    elseif Mod.Rarity == 'Необычный'   then price_ = 4000    cat_ = '[[Категория:'..Mod.Rarity..']]'
    elseif Mod.Rarity == 'Редкий'      then price_ = 8000    cat_ = '[[Категория:'..Mod.Rarity..']]'
    elseif Mod.Rarity == 'Легендарный' then price_ = 1000000 cat_ = '[[Категория:'..Mod.Rarity..']]'
    elseif Mod.Rarity == 'Особенный'   then price_ = 4000    cat_ = '[[Категория:Особенные моды]]'
    elseif Mod.Rarity == 'Амальгама'   then price_ = 0       cat_ = '[[Категория:'..Mod.Rarity..' моды]]'
    else 
        return ''
    end
    return Icons.Item('Кредиты', price_)..cat_
end
 
----------------------------------------------------------------
-------------------------Возвращает название оружия Аугмент мода
----------------------------(Упразднена. Требуется удалить, если где-то используется.)
----------------------------------------------------------------
function p.modWeapon(frame)
 
end
 
----------------------------------------------------------------
----------------------Возвращает название варфрейма Аугмент мода
----------------------------(Упразднена. Требуется удалить, если где-то используется.)
----------------------------------------------------------------
function p.modWarframe(frame)
 
end
 
----------------------------------------------------------------
------------Возвращает режима игры, где может использоваться мод
----------------------------(используется в Шаблон:Мод инфобокс)
----------------------------------------------------------------
function p.modMode(frame)
    if type(frame)=='table' then ModName = frame.args[1]
    elseif type(frame)=='string' then ModName = frame end
    local Mod = getMod(ModName)
 
    if not ifModExists (ModName, Mod) then return nil end
 
    if Mod.Mode == 'Все' then return 'Кооператив<br/>[[Конклав]]'
    elseif Mod.Mode == 'Конклав' then return '[[Конклав]]'
    else return ''
    end
end
 
----------------------------------------------------------------
----------------------------Возвращает название мода при наличии
----------------------------(используется в Шаблон:Мод инфобокс)
----------------------------------------------------------------
function p.modName(frame)
    if type(frame)=='table' then ModName = frame.args[1]
    elseif type(frame)=='string' then ModName = frame end
    local Mod = getMod(ModName)
 
    if not ifModExists (ModName, Mod) then return nil end
 
    if Mod.Name ~= nil and Mod.Name ~= '' then return Mod.Name 
    else return ModName end
end
 
----------------------------------------------------------------
--------------------Возвращает Тип и Подтип Мода по его названию
----------------------------(используется в Шаблон:Мод инфобокс)
----------------------------------------------------------------
function p.modType(frame)
    if type(frame)=='table' then ModName = frame.args[1]
    elseif type(frame)=='string' then ModName = frame end
    local Mod = getMod(ModName)
 
    if not ifModExists (ModName, Mod) then return nil end
 
    type_ = ''
    -----------------------------------
    if Mod.Type == 'Варфрейм' then 
        if Mod.Subtype == 'Аура' then type_ = '[[Ауры|Аура]][[Категория:Ауры]]'
        else type_ = '[[:Категория:Моды_Варфреймов|Мод варфрейма]][[Категория:Моды_Варфреймов]]'
        end
    -----------------------------------
    elseif Mod.Type == 'Основное оружие' then 
        if Mod.Subtype == 'Винтовка' then type_ = '[[:Категория:Моды винтовок|Мод винтовки]][[Категория:Моды винтовок]]'
        elseif Mod.Subtype == 'Дробовик' then type_ = '[[:Категория:Моды дробовика|Мод дробовика]][[Категория:Моды дробовика]]'
        elseif Mod.Subtype == 'Снайперская винтовка' then type_ = '[[:Категория:Моды снайперского оружия|Мод снайперской винтовки]][[Категория:Моды снайперского оружия]]'
        elseif Mod.Subtype == 'Лук' then type_ = '[[:Категория:Моды луков|Мод лука]][[Категория:Моды луков]]'
        elseif Mod.Subtype == 'Установка' then type_ = '[[:Категория:Моды установок|Мод лука]][[Категория:Моды установок]]'
        else type_ = 'Мод Основного оружия[[Категория:Моды винтовок]][[Категория:Моды дробовика]]'
        end
    -----------------------------------    
    elseif Mod.Type == 'Вторичное оружие' then 
        if Mod.Subtype == 'Метательное' then type_ = '[[:Категория:Моды метательного|Мод метательного]][[Категория:Моды метательного]]'
        else type_ = '[[:Категория:Моды_пистолета|Мод пистолета]][[Категория:Моды_пистолета]]'
        end
    -----------------------------------
    elseif Mod.Type == 'Холодное оружие' then 
        if Mod.Subtype == 'Стойка' then type_ = '[[:Категория:Стойки|Стойка]][[Категория:Стойки]]'
        elseif Mod.Subtype == 'Глефа' then type_ = '[[Глефы#Стойки и моды|Мод глеф]][[Категория:Моды глефы]]'
        elseif Mod.Subtype == 'Кинжал' then type_ = '[[:Категория:Моды кинжалов|Мод кинжалов]][[Категория:Моды кинжалов]]'
        else type_ = '[[:Категория:Моды_холодного_оружия|Мод ближнего боя]][[Категория:Моды_холодного_оружия]]'
       end
    -----------------------------------
    elseif Mod.Type == 'Компаньон' then
        type_ = '[[:Категория:Моды Компаньонов|Мод компаньона]][[Категория:Моды Компаньонов]]'
    -----------------------------------
    elseif Mod.Type == 'Заповедь' then
         type_ = '[[:Категория:Заповедь|Заповедь компаньона]][[Категория:Заповедь]]'
    -----------------------------------    
    elseif Mod.Type == 'Арчвинг' then type_ = '[[:Категория:Арчвинг_моды|Мод арчвинга]][[Категория:Арчвинг_моды]]'
    elseif Mod.Type == 'Основное оружие арчвинг' then type_ = '[[:Категория:Мод оружия арчвинга|Мод Арч-основного]][[Категория:Мод оружия арчвинга]]'
    elseif Mod.Type == 'Холодное оружие арчвинг' then type_ = '[[:Категория:Мод арч-ближнего боя|Мод Арч-ближнего]][[Категория:Мод арч-ближнего боя]]'
    -----------------------------------
    elseif Mod.Type == 'Некрамех' then type_ = '[[:Категория:Некрамех_моды|Мод некрамеха]][[Категория:Некрамех_моды]]'
    -----------------------------------
    elseif Mod.Type == 'Аугмент' then 
        type_ = '[[:Категория:Моды-аугменты|Мод-аугмент]][[Категория:Моды-аугменты]]'
    elseif Mod.Type == 'Аугмент оружия' then
        type_ = '[[:Категория:Моды-аугменты_оружия|Мод-аугмент оружия]][[Категория:Моды-аугменты_оружия]]'
    -----------------------------------
    elseif Mod.Type == 'К-Драйв' then type_ = '[[:Категория:Моды_К-Драйва|Мод К-Драйва]][[Категория:Моды_К-Драйва]]'
    -----------------------------------
    elseif Mod.Type == 'Паразон' then
        if Mod.Subtype == 'Реквием' then type_ = '[[:Категория:Реквием|Реквием-мод]][[Категория:Реквием]]'
            else type_ = '[[:Категория:Моды паразона|Мод паразона]][[Категория:Моды паразона]]'
        end
    -----------------------------------
    elseif not toNil(Mod.Type) then type_ = Mod.Type
    else type_ = '[[:Категория:Ошибка Мод инфобокс|Ошибка базы данных]]'..cat_error
    end
 
    if Mod.Exilus then type_ = type_..'<br/>'..Icons.Pol("Эксилус","Эксилус мод")..'[[Категория:Эксилус мод]]' end
    return type_
end
 
----------------------------------------------------------------
--------Возвращает ссылку на англ. страницу Мода по его названию
----------------------------(используется в Шаблон:Мод инфобокс)
----------------------------------------------------------------
function p.modEname(frame)
    local ModName
    if type(frame)=='table' then ModName = frame.args[1]
    elseif type(frame)=='string' then ModName = frame end
 
    local Mod = getMod(ModName)
    if ModName == nil or not ifModExists (ModName, Mod) then return nil
    elseif Mod.Ename ~= nil then return '[[en:'..Mod.Ename..']]' end
end
 
----------------------------------------------------------------
------------------Возвращает список синдикатов для аугмент Модов
----------------------------(используется в Шаблон:Мод инфобокс)
----------------------------------------------------------------
function p.modSyndicate(frame)
    local ModName
    if type(frame)=='table' then ModName = frame.args[1]
    elseif type(frame)=='string' then ModName = frame end
    local Mod = getMod(ModName)
 
    local title = '<span style="font-weight:bold;">Синдикаты:</span><br />'
 
    if (ModName == nil or not ifModExists (ModName,Mod) or Mod.Syndicates == nil or type(Mod.Syndicates) ~= 'table' or Shared.tableCount(Mod.Syndicates) == 0) then return ''
    end
 
    local synResult = ''
    for i, _syn in pairs(Mod.Syndicates) do
        syn = _syn[1]
        if _syn[2] == nil or _syn[2] == '' then point = ''
        else point = ': '..Icons.Item('Очки Синдиката',_syn[2]) end
        if syn == 'Конклав' and (_syn[2] == nil or _syn[2] == '') then
            synResult = synResult..'Награда за '..Icons.Syn(syn, syn)..' миссии [[Категория: Конклав моды]]<br/>'
        else synResult = synResult..Icons.Syn(syn, syn)..point..'[[Категория: Моды синдиката '..syn..']]<br />'
        end
    end
    return title..synResult
end
 
----------------------------------------------------------------
-------------------------Возвращает требуемую информацию по Моду 
----------------------------(используется в Шаблон:Мод инфобокс)
----------------------------------------------------------------
function p.getValue(frame)
    local ModName = frame.args[1]
    local ValName = frame.args[2]
    local Mod = getMod(ModName)
 
    if ModName == nil then
        return 'ОШИБКА: Не указано название Мода'
    elseif ValName == nil then
        return 'ОШИБКА: Параметр не указан'
    --elseif tl[ValName] == nil then 
    --    return 'ОШИБКА: Указан неверный параметр'
    elseif not ifModExists (ModName,Mod) then return nil
    end
 
    if ValName == 'Название' then
        return ModName[Name]
    elseif ValName == 'ПолярностьИконка' then
        if Mod.Polarity == '-' then
            return '-'
        elseif Mod.Polarity ~= nil then
            return Icons.Pol(Mod.Polarity)..'[[Категория:'..Mod.Polarity..']]'
        else
            return 'Отсутствует'
        end
    elseif ValName == 'Налог'  then
        return p.modTax(ModData[Mod])
    elseif ValName == 'Преобразование'  then
        if Mod.Transmutable ~= nil then
            if Mod.Transmutable  then
                return '[[Преобразование|<span style="color:green">Преобразуется</span>]][[Категория:Трансмутируемые моды]]'
            else
                return '[[Преобразование|<span style="color:red">Не преобразуется</span>]][[Категория:Нетрансмутируемые моды]]'
            end
        else
            return '[[Преобразование|<span style="color:green">Преобразуется</span>]][[Категория:Трансмутируемые моды]]'
        end
    elseif ValName == 'Получение' then
        if Mod.Syndicates ~= nil then
            return Mod.Syndicates[1]..', '..Mod.Syndicates[2]
        else
            return 'Ошибка'
        end
    else
        for ru, en in Shared.skpairs(tl) do
            if mw.ustring.upper(ru)==mw.ustring.upper(ValName) then
            return Mod[tl[ValName]] or 'Отсутствует' end 
        end
    end
end
 
-- Фильтрует моды в соответствии с аргументами и выводит список викитекстом
-- Для обновление таблиц вручную? Может пригодиться?
-- Подразумевает доступ к коду, чтобы изменить шаблон в table.insert на желаемый.
-- Для отображения [ и ] используйте &#91; и ]] соответственно.
function p.printModRow(frame)
    local cart ={}
    local filteredTable = p.getFilteredTable(frame)
 
    for i, modName in Shared.skpairs(filteredTable) do
        Mod=ModData[modName]
        if Mod.Name ~= nil and Mod.Name ~= '' then
            name_ = Mod.Name
        else name_ = Mod
        end
        table.insert(cart, '{{Мод|'..name_..'}}')
    end
    return table.concat(cart, ' •&nbsp;')
end
 
----------------------------------------------------------------
------------------------------------Возвращает Мод из базы модов
----------------------------------------------------------------
function getMod(name)
    local _mod = ModData[name]
    if _mod ~= nil and _mod.Name == name then
        return _mod
    else
        for modName, Mod in Shared.skpairs(ModData) do
            if modName == name or Mod.Name == name then
                return Mod
            end
        end
    end
end
 
----------------------------------------------------------------
------------------------------Проверка наличия Мода в базе модов
----------------------------------------------------------------
function ifModExists(name, _mod)
    if type(_mod) ~= table then
        _mod = ModData[name]
    elseif _mod.Name == name then
        return true
    end
 
    if _mod ~= nil and _mod.Name == name then
        return true
    else
        for modName, Mod in Shared.skpairs(ModData) do
            if modName == name or Mod.Name == name then
                return true
            end
        end
    end
    return false
end
 
------------------------------------------------------------------------
---Сканирует переданные Шаблоном значения из допустимых транслитератором
----------Возвращает две таблицы: ключи для ModData и введённые значения
------------------------------------------------------------------------
function p.importFromTemplate(frame)
    local varImported = {}
    local varIndex = {}
    local i = 0
    for ru, en in pairs(tl) do
        imported = frame.args[ru] or nil
        if imported ~=nil and imported~='' then
            i=i+1
            varIndex[i]=en  --string.Upper не работает для кирилицы. Использовать mw.ustring.upper--
            if mw.ustring.upper(imported) == 'ДА' or mw.ustring.upper(imported) == 'YES' or mw.ustring.upper(imported) == 'TRUE' 
                then varImported[i]=true
            elseif mw.ustring.upper(imported) == 'НЕТ' or mw.ustring.upper(imported) == 'NO' or mw.ustring.upper(imported) == 'FALSE'
                then varImported[i]=false
            elseif mw.ustring.upper(imported) == 'NIL' or mw.ustring.upper(imported) == 'NILL' or mw.ustring.upper(imported) == 'КООПЕРАТОВ' or mw.ustring.upper(imported) == 'КООП'
                then varImported[i]=nil        
            else varImported[i]=imported
            end
        end
    end
    return varIndex,varImported
end
 
----------------------------------------------------------------------------
-------Выводит таблицу, содержащую modName для ModData всех подходящих модов.
-------Исключает .Exclude моды, когда не запрошено иначе.
-------По-умолчанию импортирует значения из frame через p.importFromTemplate.
-------Для ручного импорта, указать (frame, true ) после чего две таблицы
-------содержащие ключи для ModData в 1м и искомые значения во 2м в соответствующих порядках
-----------------------------------------------------------------------------
function p.getFilteredTable (frame, override, index, augments)
    local varIndex, varImported
    local carted={}
 
    if override == true then
        varIndex = index 
        varImported = augments
    else varIndex, varImported = p.importFromTemplate(frame) end
 
    local varCount = table.maxn( varIndex )
    local hitsRequred = varCount
    local hitsScored
 
    for modName, Mod in Shared.skpairs(ModData) do
        hitsScored = 0
        for i=1, varCount do
        if varIndex[i] then 
            if varIndex[i] == 'Type' then
                if varImported[i] == Mod.Type or varImported[i] == Mod.Subtype then
                    hitsScored=hitsScored+1
                end
            elseif varIndex[i] == 'Exclude' then
                if varImported[i] and toNil(Mod.Exclude)    
                    then hitsScored = hitsScored+2       -- мод исключен и ищем исключенные
                elseif not varImported[i] and not toNil(Mod.Exclude)
                    then hitsScored = hitsScored+1      -- мод не_исключен и ищем не_исключенные
                else break
                end
            elseif varImported[i] == toNil(Mod[varIndex[i]]) then
                hitsScored = hitsScored + 1
            end
        else 
            break -- прерывание если хотя бы один varImported НЕ_совпадает с не-нулевым varIndex
        end
    end
        if toNil(Mod.Exclude) then hitsScored = hitsScored - 1 end
        if hitsScored == hitsRequred then table.insert( carted, modName )
        end
    end
    return carted
end
 
----------------------------------------------------------------
------------Выведение картинок модов с определенными параметрами
----------------------------------------------------------------
function p.buildModGallery(frame)
    imported = p.getFilteredTable(frame)
    limit=table.maxn(imported)
    local Gallery=''
    for i=1, limit do
        if ModData[imported[i]].Link ~= nil then
            link_ = ModData[imported[i]].Link
        elseif ModData[imported[i]].Name ~= nil and ModData[imported[i]].Name ~= '' then
            link_ = ModData[imported[i]].Name
        else link_ = imported[i]
        end
        if ModData[imported[i]].Image ~= nil then
            image_ = ModData[imported[i]].Image
        elseif ModData[imported[i]].Name ~= nil and ModData[imported[i]].Name ~= '' then
            image_ = ModData[imported[i]].Name..'_вики.png'
        else image_ = imported[i]..'_вики.png'
        end
        Gallery = Gallery.. '[[Файл:' ..image_.. '|x180px|link='..link_..']]'
    end
return 'Модов с указанными параментрами на текущий момент - ' ..limit..':<br/>' ..Gallery
 
end
 
 
function toNil(thing)
    if thing==nil or thing=='' then return nil else return thing end
end
 
 
function p.tooltip(Mod)
    local Name = Mod.args ~= nil and Mod.args[1]
    local newName = Mod.args ~= nil and Mod.args[2]
    local Mod = nil
 
    if newName == '' then newName = nil end
 
    if Name == nil then
        return '<span style="color:red;">{{[[Шаблон:МодТ|МодТ]]}} Введите название Мода.</span>[[Категория:'..'Ошибка Tooltip Моды]]'
    else
        Mod = getMod(Name)
    end
 
    if Mod == nil then
        return '<span style="color:red;">{{[[Шаблон:МодТ|МодТ]]}} "'..Name..'" не найден</span>[[Категория:'..'Ошибка Tooltip Моды]]'
    else
        local Link = Mod.Link ~= nil and Mod.Link or nil
 
        local linkText = ''
        if newName ~= nil then
            linkText = newName
        else
            linkText = Name
        end
 
        --mw.log(Link)
        local tMod = '{{Подсказка|'..Name..'|#Preview|[['..Name..'|<span title="">'..linkText..'</span>]]}}'
 
--[[
        table.insert(tMod,'<span class="mod-tooltip" data-param="'..Name..'">')
        table.insert(tMod,'[_[File:Mod_TT_20px.png|link='..Name..']_]'..'&thinsp;[_[')
        table.insert(tMod,linkText..']_]</span>')
]]--
 
        return tMod
    end
end
 
----------------------------------------------------------------
--Всплывающее окно при наведении на надпись Мода в тексте статьи 
----------------------------(используется в Шаблон:Мод инфобокс)
----------------------------------------------------------------
function p.tooltipText(Mod) --добить по всплывающей подсказке под нашу вики
    local Name = Mod.args ~= nil and Mod.args[1]
    local newName = Mod.args ~= nil and Mod.args[2]
    local Mod = nil
    if newName == '' then newName = nil end
 
    if Name == nil then
        return '<span style="color:red;">{{[[Шаблон:Моды|Mod]]}} Введите название Мода.</span>[[Категория:'..'Ошибка Tooltip Моды]]'
    else
        Mod = getMod(Name)
    end
 
    if Mod == nil then
        return '<span style="color:red;">{{[[Шаблон:Моды|Mod]]}} "'..Name..'" не найден</span>[[Категория:'..'Ошибка Tooltip Моды]]'
    else
        local Link = Mod.Link ~= nil and Mod.Link or nil
 
        local linkText = ''
        if Link ~= nil and newName ~= nil then
            linkText = Link..'|'..newName
        elseif newName ~= nil then
            linkText = Name..'|'..newName
        elseif Link ~= nil then
            linkText = Link..'|'..Name
        else
            linkText = Name
        end
 
        --mw.log(Link)
        local tMod ={}
        table.insert(tMod,'<span class="mod-tooltip" data-param="'..Name..'">')
        table.insert(tMod,'[[File:Mod_TT_20px.png|link='..Name..']]'..'&thinsp;[[')
        table.insert(tMod,linkText..']]</span>')
 
        return table.concat(tMod)
    end
end
 
 
----------------------------------------------------------------
--------------------------------------------Построение инфобокса 
----------------------------(используется в Шаблон:Мод инфобокс)
----------------------------------------------------------------
function p.modInfobox(ModName)
    name = '{{{Название|{{PAGENAME}}}}}'
    Mod = getMod(ModName)
    local Infobox = ''
 
    Infobox = Infobox..'<onlyinclude>'
    Infobox = Infobox..'\n<infobox theme="mod">'
    Infobox = Infobox..'\n<title source = "Название"><default>'..name..'</default></title>'
    Infobox = Infobox..'\n<data source = "Изображение">'
    Infobox = Infobox..'\n<default>{{{Изображение|'..modImage(name)..'}}}<br /><div style="text-align:center; font-weight:bold; font-size:15px;">{{{Преобразование|'..modTransmutable(name)..'}}}</div></default>'
    Infobox = Infobox..'\n</data>'
    Infobox = Infobox..'\n<data source="Тип"><label>Тип</label><default><includeonly>{{{Тип|'..getValue(name,"Тип")..'}}}</includeonly></default></data>'
    Infobox = Infobox..'\n<data source="Полярность"><label>Полярность</label><default><includeonly>{{{Полярность|'..getValue(name, 'ПолярностьИконка')..'}}}</includeonly></default></data>'
    Infobox = Infobox..'\n<data source="Налог"><label>Налог торговли</label><default><includeonly>{{{Налог|'..modTax(name)..'}}}</includeonly></default></data>'
    Infobox = Infobox..'\n<header>Получение<br/></header>'
    Infobox = Infobox..'\n<data source="Получение"><default><includeonly><div>{{{Получение|'..modSyndicate(name)..'}}}</div></includeonly></default></data>'
    Infobox = Infobox..'\n<header> </header>'            --[[ отрисовка пустого раздела для                                                                 корректной работы - "костыль" ]]--
    Infobox = Infobox..'\n</infobox>'
    Infobox = Infobox..'\n{{#if:{{{name|}}}|[[en:{{{name|}}}]]}}'
    Infobox = Infobox..'\n</onlyinclude>'
end
 
 
 
-----------------------------------------------------------
--Экспорт из Шаблона для полу-автоматического обновления БД
-------Используется в (используется в Шаблон:Мод инфобокс2)
-----------------------------------------------------------
function p.exportFromTemplate(frame)
    local Mod={}
    local Im={Name=frame.args["Название"],
               Image=frame.args["Изображение"],
               Polarity=frame.args["Полярность"],
               Type=frame.args["Тип"],
               Mode=frame.args["Режим"],
               Ename=frame.args["name"],
               Tradetax=frame.args["Налог"],
               Transmutable=frame.args["Преобразование"],
               Exilus=frame.args["Эксилус"]
    }
 
 
    --распознавание типа и подтипа
    local Type=checkAltTypes(Im.Type)
 
    if not Type then Mod.Type = nil
        elseif Type == 'Варфрейм' then Mod.Type='Варфрейм'
        elseif Type == 'Аура' then Mod.Subtype='Аура' Mod.Type='Варфрейм'
 
        elseif Type == 'Основное оружие' then Mod.Type='Основное оружие'
        elseif Type == 'Винтовка' then Mod.Subtype='Винтовка' Mod.Type='Основное оружие'
        elseif Type == 'Дробовик' then Mod.Subtype='Дробовик' Mod.Type='Основное оружие'
        elseif Type == 'Снайперская винтовка' then Mod.Subtype='Снайперская винтовка' Mod.Type='Основное оружие'
        elseif Type == 'Лук' then Mod.Subtype='Лук' Mod.Type='Основное оружие'
        elseif Type == 'Установка' then Mod.Subtype='Установка' Mod.Type='Основное оружие'
 
        elseif Type == 'Вторичное оружие' then Mod.Type='Вторичное оружие'
        elseif Type == 'Метательное' then Mod.Subtype='Метательное' Mod.Type='Вторичное оружие'
 
        elseif Type == 'Холодное оружие' then Mod.Type='Холодное оружие'
        elseif Type == 'Стойка' then Mod.Subtype='Стойка' Mod.Type='Холодное оружие'
        elseif Type == 'Глефа' then Mod.Subtype='Глефа' Mod.Type='Холодное оружие'
        elseif Type == 'Кинжал' then Mod.Subtype='Кинжал' Mod.Type='Холодное оружие'
 
        elseif Type == 'Компаньон' then Mod.Type='Компаньон'
        elseif Type == 'Заповедь' then Mod.Type='Заповедь'
 
        elseif Type == 'Страж' then Mod.Subtype='Страж' Mod.Type='Компаньон'
        elseif Type == 'Кават' then Mod.Subtype='Кават' Mod.Type='Компаньон'
        elseif Type == 'Кубрау' then Mod.Subtype='Кубрау' Mod.Type='Компаньон'
        elseif Type == 'Моа' then Mod.Subtype='Моа' Mod.Type='Компаньон'
        elseif Type == 'Робототехника' then Mod.Subtype='Робототехника' Mod.Type='Компаньон'
        elseif Type == 'Зверь' then Mod.Subtype='Зверь' Mod.Type='Компаньон'
 
        elseif Type == 'Вульпафила' then Mod.Subtype='Вульпафила' Mod.Type='Компаньон'
        elseif Type == 'Придазит' then Mod.Subtype='Придазит' Mod.Type='Компаньон'
 
        elseif Type == 'Некрамех' then Mod.Type='Некрамех'
 
        elseif Type == 'Аугмент' then Mod.Type='Аугмент'
        elseif Type == 'Аугмент оружия' then Mod.Type='Аугмент оружия'
 
        elseif Type == 'К-Драйв' then Mod.Type='К-Драйв'
 
        elseif Type == 'Паразон' then Mod.Type='Паразон'
        elseif Type == 'Реквием' then Mod.Subtype='Реквием' Mod.Type='Паразон'
    end
 
 
    --Добавление заголовка
    Mod.Name = toNil(Im.Name) or "Укажите Название Мода"
    local cart = mw.html.create('pre'):wikitext('    ["'..Mod.Name..'"] = {')
 
    --Добавление Изображения
    if Im.Image==Mod.Name.."_вики.png" or Im.Image==Mod.Name.." вики.png" then Mod.Image=nil 
        else Mod.Image= toNil(Im.Image) end
    if Mod.Image then cart:newline():wikitext('        Image = "'..Mod.Image..'",') end
 
    --Добавление Полярности
    Mod.Polarity=checkAltMisc(Im.Polarity)
    if Mod.Polarity then cart:newline():wikitext('        Polarity = "'..Mod.Polarity..'",') 
        elseif toNil(Im.Polarity) then 
            cart:
              newline():wikitext('        Polarity = "",')
              :newline():wikitext('        --ОШИБКА: Полярность ('..Im.Polarity..') Не была распознана<br /> --Доступные Полярности: "Мадурай", "Нарамон", "Зенурик", "Вазарин", "Унайру", "Умбра", "Заповедь"')
            end
 
    --Добавление Редкости
    cart
      :newline():wikitext('        Rarity = "",')
      :newline():wikitext('--Укажите редкость. <br />--Доступны: "Обычный", "Необычный", "Редкий", "Легендарный", "Амальгама"')
 
    --Добавление Типа
    if Mod.Type then 
        cart:newline():wikitext('        Type = "'..Mod.Type..'",') 
        if Mod.Subtype then cart:newline():wikitext('        Subtype = "'..Mod.Subtype..'",') end
        else
    cart
     :newline():wikitext('        Type = "",')
     :newline():wikitext('        Subtype = "",')
     :newline():wikitext('        --ОШИБКА: Тип ('..Im.Type..') Не был распознан')
     :newline():wikitext('--Доступные типы: Варфрейм", "Арчвинг", "Основное оружие", "Вторичное оружие", "Холодное оружие", "Основное оружие арчвинг", "Холодное оружие арчвинг", "Аугмент", "Аугмент оружия", "К-Драйв", "Компаньон", "Заповедь", "Паразон"')
     :newline():wikitext('--Доступные подтипы: "Винтовка", "Снайперская винтовка", "Дробовик", "Лук", "Установка", "Метательное","Глефа", "Кинжал", "Аура", "Стойка", "Реквием"')
        end
 
    --Добавление Режима
    Mod.Mode=checkAltMisc(Im.Mode)
    if Mod.Mode then
        if not Mod.Mode=="Кооператив" then 
        cart:newline():wikitext('        Mode = "'..Mod.Mode..'",') end
    elseif toNil(Im.Mode) then
        cart
          :newline():wikitext('        Mode = "",')
          :newline():wikitext('--ОШИБКА: Режим ('..Im.Mode..') Не был распознан')
          :newline():wikitext('--Доступные режимы: "Конклав", "Все". Кооперативный режим указывать не требуется')
 
    end
 
    --Добовление ссылки на англовики
    Mod.Ename=toNil(Im.Ename)
    if Mod.Ename then 
        cart:newline():wikitext('        Ename = "'..Mod.Ename..'",') end
 
    --Добавление Налога
    Mod.Tradetax=toNil(Im.Tradetax)
    if Mod.Tradetax then 
        cart:newline():wikitext('        Tradetax = "'..Mod.Tradetax..'",') end
 
    --Добавление Эксилуса
    Mod.Exilus=checkAltMisc(Im.Exilus)
    if Mod.Exilus=="true" then 
        cart:newline():wikitext('        Exilus = '..Mod.Exilus..',') 
    elseif Mod.Exilus~="false" and toNil(Im.Exilus) then
        cart
        :newline():wikitext('        Exilus = "",')
        :newline():wikitext('--ОШИБКА: Значение ('..Im.Exilus..') Не распознано<br />--Доступные Значения: true, false, - без кавычек')
        end
 
    --Добавление Преобразования
    Mod.Transmutable=checkAltMisc(Im.Transmutable)
    if Mod.Transmutable=="true" then
        cart:newline():wikitext('        Transmutable = '..Mod.Transmutable..',') 
    elseif Mod.Transmutable~="false" and toNil(Im.Transmutable) then
        cart
        :newline():wikitext('        Transmutable = "",')
        :newline():wikitext('--ОШИБКА: Значение ('..Im.Transmutable..') Не распознано<br />--Доступные Значения: true, false, - без кавычек')
 
        end
 
    return cart:newline():wikitext('    },')
end
 
function checkAltTypes(imported)
    if imported==nil or imported==""  then return nil end
        local pseudo={
            ["Варфрейм"]={'Мод варфрейма','Мод варфреймов','Варфрейм','Мод варфрэйма','Мод варфрэймов','Варфрэйм'},
            ["Аура"]={"Аура",'Ауры','Мод ауры'},
            ["Основное оружие"]={'Мод Основного оружия','Основное','Основное Оружие'},
            ["Винтовка"]={'Мод винтовки','Винтовка','Мод винтовок'},
            ["Дробовик"]={'Мод дробовика','Дробовик','Мод дробовиков'},
            ["Снайперская винтовка"]={'Мод снайперской винтовки','Снайперская винтовка','Снайпер','Мод снайперских винтовок','Снайперское оружие','Мод снайперского оружия'},
            ["Лук"]={'Лук','Луки','Мод лука','Мод луков'},
            ["Установка"]={'Установка','Мод установки','Мод установок'},
            ["Вторичное оружие"]={'Вторичное оружие','Пистолет','Пистолеты','Мод пистолета','Мод пистолетов'},
            ["Метательное"]={'Метательное','Метательное оружие','Мод метательного оружия'},
            ["Холодное оружие"]={'Холодное оружие','Мод ближнего боя','Ближний бой','Мод холодного оружия'},
            ["Стойка"]={'Стойка','Стойки','Мод стойка','Мод стойки'},
            ["Глефа"]={'Мод глефы','Глефа','Мод глеф'},
            ["Кинжал"]={'Кинжал','Мод кинжала','Мод кинжалов'},
            ["Компаньон"]={'Компаньон','Мод компаньона','Мод компаньонов'},
            ["Заповедь"]={'Заповедь','Заповедь компаньона','Мод заповедь'},
            ["Аугмент"]={'Аугмент','Мод-аугмент','мод аугмент'},
            ["Аугмент оружия"]={'Аугмент оружия','Мод аугмент оружия','Мод-аугмент оружия'},
            ["К-Драйв"]={'К-Драйв','Кдрайв','Мод к-драйва','мод кдрайва'},
            ["Паразон"]={'Паразон','Мод паразона'},
            ["Реквием"]={'Реквием','Мод реквием','Реквием мод','Мод-реквием','Реквием-мод'}
    }
    for TypeName, psdn in pairs(pseudo) do
        for j, ncase in pairs(psdn) do
            if mw.ustring.upper(imported)==mw.ustring.upper(ncase) then return TypeName end
        end
    end
    return imported
 
end
 
function checkAltMisc(imported)
    if imported==nil or imported==""  then return nil end
    local pseudo={
            ["Нарамон"]={'Нарамон','-','T','Т'},
            ["Мадурай"]={'Мадурай','V'},
            ["Зенурик"]={'Зенурик','черточки','чёрточки'},
            ["Вазарин"]={'Вазарин','D','Д'},
            ["Унайру"]={'Унайру','Унаиру'},
            ["Заповедь"]={'Заповедь','Заповедь компаньона','Мод заповедь', 'I'},
            ["Умбра"]={'Умбра'},
 
            ["true"]={'да','yes','+','true'},
            ["false"]={'нет','no',' - ','-','false'},
 
            ["Конклав"]={'Конклав','Мод конклава'},
            ["Все"]={'Все','Общий','Общий мод'},
            ["Кооператив"]={'Кооп','Кооператив','Кооперативная игра','ко-оп','Мод коопа'}
    }
 
    for TypeName, psdn in pairs(pseudo) do
        for j, ncase in pairs(psdn) do
            if mw.ustring.upper(imported)==mw.ustring.upper(ncase) then return TypeName end
        end
    end
    return nil
 
end
 
 
----------------------------------------------------------------
----------------------------Выводит все текущие подтипы использованные в Данных
----------------------------(Только для отладки)
----------------------------------------------------------------
function p.getEmSubtypes()
    local index= {}
    local a
    local limit
    for modName, Mod in Shared.skpairs(ModData) do
        a=false
        limit=table.maxn( index )
        for i=0, limit do
         if Mod.Subtype==index[i] then a=true break end
         end
        if a==false then table.insert( index, Mod.Subtype )end
 
    end
    --return index
    return table.concat(index, ' | ')
end
 
 
-- accepts three parameters: 
-- a string that represents mod rarity: 'Common', 'Uncommon', 'Rare', 'Legendary', 'Amalgam', 'Peculiar', 'Requiem', 'All', or ''
-- a string that represents polarity: 'Madurai', 'Naramon', 'Vazarin', 'Zenurik', 'Unairu', 'Penjaga', or nil
-- a string that represents transmutability: 'true', 'false', '', or nil (counting both transmutable and non-transmutable mods)
function p.getModCount(Mod)
    local total = 0
    local rarity = Mod.args[1]
    local polarity = Mod.args[2]
    local transmutable = Mod.args[3]
 
    if (rarity == '' or rarity == nil) then
       rarity = 'All' 
    end
 
    if (polarity == '' or polarity == nil) then
        polarity = 'All'
    end
 
    if transmutable == 'true' then
        transmutable = true
    elseif transmutable == 'false' then
        transmutable = false
    else
        transmutable = 'All'
    end
 
    -- treating mods without Transmutable attribute as transmutable
    for name, Mod in Shared.skpairs(ModData['Моды']) do
        if ((Mod['Rarity'] == rarity or rarity == 'All') and 
            (Mod['Polarity'] == polarity or polarity == 'All') and
            (Mod['Transmutable'] == nil or Mod['Transmutable'] == transmutable or transmutable == 'All') and
            not Shared.contains(ModData['IgnoreInCount'], name)) then
 
            total = total + 1
        end
    end
 
    return total
end
 
return p
Материалы сообщества доступны в соответствии с условиями лицензии CC-BY-SA , если не указано иное.