|
|
| (11 intermediate revisions by the same user not shown) |
| Line 1: |
Line 1: |
| local p = {} | | local cargo = mw.ext.cargo |
| | local util_cargo = require('Module:Cargo Utility') |
| | local infobox = require('Module:Infobox') |
|
| |
|
| local luatable = require'Module:Color'
| |
| local textutil = require'Module:Text Utility'
| |
| local process_args = require'Module:ProcessArgs'
| |
| local shaders = require'Module:ColorParse/Templates'
| |
| local stringbyte, stringchar = string.byte, string.char
| |
| local shader_to_class = {
| |
| ['y'] = 'y-dark',
| |
| ['Y'] = 'y',
| |
| ['b'] = 'b-dark',
| |
| ['B'] = 'b',
| |
| ['c'] = 'c-dark',
| |
| ['C'] = 'c',
| |
| ['r'] = 'r-dark',
| |
| ['R'] = 'r',
| |
| ['o'] = 'o-dark',
| |
| ['O'] = 'o',
| |
| ['w'] = 'w-dark',
| |
| ['W'] = 'w',
| |
| ['g'] = 'g-dark',
| |
| ['G'] = 'g',
| |
| ['m'] = 'm-dark',
| |
| ['M'] = 'M',
| |
| ['k'] = 'k-dark',
| |
| ['K'] = 'k',
| |
| ['Y-y-y-K-K-y-y-Y'] = 'scanning'
| |
| }
| |
|
| |
| --[Utility stuff]--
| |
|
| |
| function normalize(input, type)
| |
| type = type or 'xml'
| |
| local b = clean(input)
| |
| local a = '&y'
| |
| if type == 'notxml' then
| |
| a = '&y'
| |
| end
| |
| if not b:match('^%&') then
| |
| b = a .. b
| |
| end
| |
| b = b:gsub("(\\n)","\n")
| |
| return b
| |
| end
| |
|
| |
|
| |
| function clean(input)
| |
| local b = input:gsub("(~J211)", "")
| |
| b = b:gsub("([{}])", "")
| |
| return b
| |
| end
| |
|
| |
|
| |
| function p.determinexml(input)
| |
| return (input:match('&') ~= nil)
| |
| end
| |
|
| |
|
| |
| function strtotbl(str)
| |
| tbl = {stringbyte(str, 1, #str)}
| |
| for i = 1, #tbl do
| |
| tbl[i] = stringchar(tbl[i])
| |
| end
| |
| return tbl
| |
| end
| |
|
| |
|
| |
| function p.linebreaks(frame)
| |
| local b = string.gsub(frame,"(~)","\n")
| |
| return b
| |
| end
| |
|
| |
|
| | local p = {} |
| | local h = {} |
|
| |
|
| --[ The main function. Takes the first argument and snips out stuff we don't need
| |
| --[ depending on regextype.
| |
| function p.parse(frame, regextype)
| |
| args = frame.args or {[1] = frame}
| |
| regextype = regextype
| |
| if regextype == nil then
| |
| if p.determinexml(args[1]) then
| |
| regextype = 'xml'
| |
| else
| |
| regextype = 'notxml'
| |
| end
| |
| end
| |
| --[Determine regex type]
| |
| local regex = "&(%w)([^&\n]*)"
| |
| if regextype == 'notxml' then
| |
| regex = "&(%w)([^&\n]*)"
| |
| end
| |
|
| |
|
| local b = normalize(args[1],regextype)
| | function p.Declare(frame) |
| local a = string.gsub(b, regex, function(color,text)
| | -- [ Declare ItemsTable ] |
| if text ~= nil and text ~= "" then
| | local tablename = 'ItemsTable' |
| local hexcolor = luatable.parse(color)
| | local args = { |
| if hexcolor == nil then
| | ['BasePV']='Integer', |
| error ("There was no specified color for color code: " .. color)
| | ['MaxPV']='Integer', |
| end
| | ['Vibro']='Boolean', |
| text = text or ""
| | ['PoweredPV']='Boolean', |
| return "<span style=\"color: " .. hexcolor .. ";\">" .. text .. "</span>"
| | ['Damage']='String', |
| else
| | ['UnpoweredDamage']='String', |
| return ""
| | ['PrimaryDamageElement']='String', |
| end
| | ['HP']='Integer', |
| end)
| | ['AV']='Integer', |
| return a
| | ['DV']='Integer', |
| | ['MA']='Integer', |
| | ['ToHit']='Integer', |
| | ['Skill']='String', |
| | ['ObjectID']='String', |
| | ['AgilityBonus']='Integer', |
| | ['StrengthBonus']='Integer', |
| | ['WillpowerBonus']='Integer', |
| | ['ToughnessBonus']='Integer', |
| | ['IntelligenceBonus']='Integer', |
| | ['EgoBonus']='Integer', |
| | ['Description']='Wikitext', |
| | ['WornOn']='String', |
| | ['UsesSlots']='List (,) of String', |
| | ['Healing']='String', |
| | ['HarvestedInto']='String', |
| | ['PreservedInto']='Page', |
| | ['PreservedQuantity']='Integer', |
| | ['ElementalDamage']='String', |
| | ['ElementalType']='String', |
| | ['JoinKey']='String' |
| | } |
| | local results = cargo.declare(table, args) |
| end | | end |
|
| |
|
| |
|
| function p.main(frame) | | function p.main(frame) |
| | | -- [Process arguments. Header and image work ok, but |
| local parsetype = nil | | -- additional logic is needed to separate the other args into rows] |
| local unbolded = false
| | local args = require( 'Module:ProcessArgs' ).merge( true ) |
| local tildes = false
| | local infoboxargs = { |
| local text = ''
| | ['class'] = 'qud-item-infobox', |
| local args = process_args.merge(true)
| | ['rows'] = args['rows'] |
| for _, arg in ipairs(args) do
| | } |
| if arg == 'notxml' then
| | |
| parsetype = 'notxml'
| | return infobox.infobox(args) |
| elseif arg == 'unbolded' then
| |
| unbolded = true
| |
| elseif arg == 'tildes are new lines' then
| |
| tildes = true
| |
| elseif text == '' then
| |
| text = arg
| |
| end
| |
| end
| |
|
| |
| local returntext = p.parse(text, parsetype)
| |
| if tildes == true then
| |
| returntext = p.linebreaks(returntext)
| |
| end
| |
| if unbolded == true then
| |
| return returntext
| |
| else
| |
| return '<b>' .. (returntext or '') .. '</b>'
| |
| end
| |
| end | | end |
|
| |
|
| | | function h.addrow(row) |
| -- Shader Parse --
| | -- [ Add html row with given table. I basically just rewrote |
| function p.shader(text, colors, type, rasterize) | | -- Template:Infobox row in lua. likely needs to be refactored] |
| -- split the colors into a list
| | local output = {} |
| local colorlist = textutil.split(colors, '-')
| | local label = row[1] |
| -- check shader type:
| | local class = row['class'] |
| -- default | if pattern is shorter than text, text will remain uncolored (y)
| | local field = row[2] |
| -- sequence | pattern will repeat until text is over
| | |
| -- alternation | pattern will stretch to fit word length (?)
| | if label then |
| local type = type or 'default'
| | output.append('! <div style="text-align:left" class="Searchaux"> '.. label .. '</div>\n') |
| local brasterize = false
| | end |
| if rasterize == 'true' then
| | output.append('|') |
| brasterize = true
| | if class then |
| end
| | output.append('class="'.. class .. '"') |
| local strtbl = strtotbl(text)
| | end |
| local finaltbl = {}
| | if not label then |
| local interval = 1
| | output.append('colspan="2"') |
| local bordered = false
| | end |
| local overflowbehavior = function(f) return 'y' end
| | output.append('\n|' .. field .. '\n|-') |
| if type == 'alternation' then
| | |
| interval = math.floor(#strtbl/#colorlist) --sets interval that color code switches.
| |
| if interval <= 0 then interval = 1 end
| |
| overflowbehavior = function(f) return colorlist[#colorlist] end
| |
| elseif type == 'sequence' or type == 'solid' then
| |
| overflowbehavior = function(f)
| |
| local e = f%#colorlist
| |
| if e == 0 then e = #colorlist end
| |
| return colorlist[e]
| |
| end
| |
| elseif type == 'bordered' then
| |
| bordered = true
| |
| overflowbehavior = function(f)
| |
| -- If it's the first or last character, use the second color, otherwise use the first.
| |
| if #strtbl - f <= 0 or f == 1 then return colorlist[2] else return colorlist[1] end
| |
| end
| |
| elseif type == 'chaotic' then
| |
| overflowbehavior = function(f) return 'y' end -- placeholder
| |
| end
| |
| local ci = 1
| |
| for i=1, #strtbl do
| |
| if ci > #colorlist or ci <= 0 or bordered == true then
| |
| hexcolor = overflowbehavior(ci)
| |
| else
| |
| hexcolor = colorlist[ci]
| |
| end
| |
| if brasterize then
| |
| finaltbl[i] = "<span style=\"color: " .. luatable.parse(hexcolor) .. ";\">" .. strtbl[i].. "</span>"
| |
| else
| |
| finaltbl[i] = "&" .. hexcolor .. strtbl[i]
| |
| end
| |
| if i%interval == 0 then
| |
| ci = ci + 1
| |
| end
| |
| end
| |
| return table.concat(finaltbl)
| |
| end | | end |
|
| |
|
| |
| function p.shadermain(frame)
| |
| local args = process_args.merge(true)
| |
| if args[1] and args[2] then -- shader template
| |
| output = applytemplate(args[1], clean(args[2]), (args['rasterize'] or 'true'))
| |
| else
| |
| output = p.shader(clean(args['text']), args['colors'], args['type'], (args['rasterize'] or 'true'))
| |
| end
| |
|
| |
| if (args['unbolded'] == 'true') then
| |
| return output
| |
| else
| |
| return '<b>' .. (output or '') .. '</b>'
| |
| end
| |
| end
| |
|
| |
|
| |
| function applytemplate(shader, text, raster)
| |
| if shaders[shader] == nil then
| |
| error('There was no shader called ' .. (shader or '') .. '!')
| |
| else
| |
| return p.shader(text, shaders[shader][1], shaders[shader][2], raster)
| |
| end
| |
| end
| |
|
| |
|
| |
| function p.shaderlist()
| |
| local tblheader = '<tr><th>Shader</th><th>Colors</th><th>Type</th></tr>'
| |
| local tr = {}
| |
| i = 0
| |
| for a, v in pairs(shaders) do
| |
| tr[i] = ' <tr><td><b>' .. applytemplate(a, a, 'true') .. '</b></td><td>' .. v[1] .. '</td><td>' .. v[2] .. '</td></tr>'
| |
| i = i + 1
| |
| end
| |
| return '<table class="wikitable sortable">' .. tblheader .. table.concat(tr) .. '</table>'
| |
| end
| |
|
| |
|
| |
| function p.test()
| |
| return p.shader('Spiked', 'R-Y', 'bordered')
| |
| --return applytemplate('soul', 'soulcurding')
| |
| end
| |
|
| |
| return p | | return p |