Module:ColorParse

Documentation

[purge]

This module parses the game's color codes in strings and formats them for the wiki. This shouldn't be directly called anymore. Use Template:Qud text instead. If the text in question has pronouns in syntax =pronouns.(pronountype)= or a similar style, use Template:Grammar.

Usage

{{#invoke: ColorParse | parse |(your text here)}}

Code:

{{#invoke: ColorParse | parse |&RS&rt&Ko&yp&Ys&Rv&ra&Kl&yi&Yn&Rn&y}}

Result:

Stopsvalinn

The above documentation is transcluded from Module:ColorParse/doc. (edit | history)

---

local p = {}

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


--[ 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)
  local a = string.gsub(b, regex, function(color,text)
       if text ~= nil and text ~= "" then
          local class = shader_to_class[color]
          if class == nil then
            error ("There was no specified color for color code: " .. color)
          end
          text = text or ""
          return "<span class=\"qud-text " .. class .. "\">"  .. text .. "</span>"
       else
          return ""
       end
  end)
return a
end


function p.main(frame)

	local parsetype = nil
  	local unbolded = false
  	local tildes = false
  	local text = ''
 	local args = process_args.merge(true)
 	for _, arg in ipairs(args) do
    	if arg == 'notxml' then
        	parsetype = 'notxml'
      	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
  	return returntext
end


-- Shader Parse --
function p.shader(text, colors, type, rasterize)
    -- split the colors into a list 
    local colorlist = textutil.split(colors, '-')
    -- check shader type:
    -- default     | if pattern is shorter than text, text will remain uncolored (y)
    -- sequence    | pattern will repeat until text is over
    -- alternation | pattern will stretch to fit word length (?)
    local type = type or 'default'
    local brasterize = false
    if rasterize == 'true' then
       brasterize = true
    end
    local strtbl = strtotbl(text)
    local finaltbl = {}
    local interval = 1
    local bordered = false
    local overflowbehavior = function(f) return 'y' end
    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] = "&amp;" .. hexcolor .. strtbl[i]
          end
       if i%interval == 0 then
          ci = ci + 1
       end      
    end
    return table.concat(finaltbl)
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

    return output
end


function applytemplate(shader, text, raster)
	shader = shader:gsub(" ", "-")
   class = shader_to_class[shader]
   if class ~= nil then
   	 shader = class
   end
   return '<span class=\"qud-text ' .. shader .. '\">' .. text .. '</span>'
end


function p.shaderlist()

   local tblheader = '<tr><th>Shader</th><th>Colors</th><th>Type</th></tr>'
   local tr = {}
   local sorted_shaders = {}
   -- Sort keys --
   for k,v in pairs(shaders) do table.insert(sorted_shaders, k) end
   table.sort(sorted_shaders)
   -- Do logic on the sorted table --
   for i, a in ipairs(sorted_shaders) do
   	   local v = shaders[a]
       tr[i] = ' <tr><td>' .. applytemplate(a, a, 'true') .. '</td><td>' .. v[1] .. '</td><td>' .. v[2] .. '</td></tr>'
   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