Alex: Created page with "local hc = require('Module:Paramtest').has_content -- Package local p = {} -- Feature functions local feat = {} local zoomRatios = { { 3, 8 }, { 2, 4 }, { 1, 2 }, { 0, 1 }, { -1, 1/2 }, { -2, 1/4 }, { -3, 1/8 } } -- Default arg values local defaults = { -- Map options type = 'mapframe', width = 300, height = 300, zoom = 2, mapID = 0, -- RuneScape surface x = 3233, -- Lumbridge lodestone y = 3222, plane = 0, align = 'center', -- Feat..."

2024-10-16T23:12:39Z

Created page with "local hc = require('Module:Paramtest').has_content -- Package local p = {} -- Feature functions local feat = {} local zoomRatios = { { 3, 8 }, { 2, 4 }, { 1, 2 }, { 0, 1 }, { -1, 1/2 }, { -2, 1/4 }, { -3, 1/8 } } -- Default arg values local defaults = { -- Map options type = 'mapframe', width = 300, height = 300, zoom = 2, mapID = 0, -- RuneScape surface x = 3233, -- Lumbridge lodestone y = 3222, plane = 0, align = 'center', -- Feat..."

New page

local hc = require('Module:Paramtest').has_content

-- Package
local p = {}
-- Feature functions
local feat = {}

local zoomRatios = {
{ 3, 8 },
{ 2, 4 },
{ 1, 2 },
{ 0, 1 },
{ -1, 1/2 },
{ -2, 1/4 },
{ -3, 1/8 }
}

-- Default arg values
local defaults = {
-- Map options
type = 'mapframe',
width = 300,
height = 300,
zoom = 2,
mapID = 0, -- RuneScape surface
x = 3233, -- Lumbridge lodestone
y = 3222,
plane = 0,
align = 'center',
-- Feature options
mtype = 'pin',
-- Rectangles, squares, circles
radius = 10,
-- Dots
fill = '#ffffff',
-- Pins
icon = 'greenPin',
iconSize = 25,
iconAnchor = 0,
popupAnchor = 0,
group = 'pins',
-- Text
position = 'top'
}

local mtypes = {
singlePoint = { pin=true, rectangle=true, square=true, circle=true, dot=true, text=true },
multiPoint = { polygon=true, line=true }
}

-- Named-only arguments
local namedOnlyArgs = { type=true, width=true, height=true, zoom=true, mapID=true, align=true, caption=true, text=true, nopreprocess=true, smw=true, smwName=true, plainTiles=true, mapVersion=true }

-- Anonymous feature options that should be removed for comma separation
local optsWithCommas = { 'iconSize', 'iconAnchor', 'popupAnchor' }

-- Optional feature properties
local properties = {
any = { title='string', desc='string' },
line = { stroke=true, ['stroke-opacity']=true, ['stroke-width']=true },
polygon = { stroke=true, ['stroke-opacity']=true, ['stroke-width']=true, fill=true, ['fill-opacity']=true },
dot = { fill=true },
pin = { icon=true, iconWikiLink=true, iconSize=true, iconAnchor=true, popupAnchor=true },
text = {}
}

-- Template entry point
function p.map(frame)
return p.buildMap(frame:getParent().args)
end

-- Module entry point to get completed map element
function p.buildMap(_args)
local args = {}

for k, v in pairs(_args) do
args[k] = v
end

local features, mapOpts = p.parseArgs(args)

return p.buildMapFromOpts(features, mapOpts)
end

-- Build full GeoJSON and insert into HTML
-- Can be used to turn Location JSON into completed map
function p.buildMapFromOpts(features, mapOpts)
local noPreprocess = mapOpts.nopreprocess
local collection = {}

if #features > 0 then
collection = {
type = 'FeatureCollection',
features = features
}
end

local map = createMapElement(mapOpts, collection)

if noPreprocess then
return tostring(map)
end

return mw.getCurrentFrame():preprocess(tostring(map))
end

-- Create map HTML element
function createMapElement(mapOpts, collection)
local mapElem = mw.html.create(mapOpts.type)

mapOpts.x = math.floor(mapOpts.x)
mapOpts.y = math.floor(mapOpts.y)

-- Remove unnecessary values
mapOpts.type = nil
mapOpts.range = nil
mapOpts.maxPinY = nil
mapOpts.nopreprocess = nil

mapElem:attr(mapOpts):newline():wikitext(toJSON(collection)):newline()

-- Set mapOpts in SMW so queries can rebuild with #buildMapFromOpts
-- Need to remove these opts just before setting
if hc(mapOpts.smw) then
local smwOpts = {
x = mapOpts.x,
y = mapOpts.y,
mapID = mapOpts.mapID,
plane = mapOpts.plane,
zoom = mapOpts.zoom
}

parseSMW(mapOpts, smwOpts)
end

return mapElem
end

-- Parse all arguments
function p.parseArgs(args)
local features = {}
local mapOpts = p.parseMapArgs(args)

-- Parse anon args and add features to table
local anonFeatures = p.parseAnonArgs(args, mapOpts)
combineTables(features, anonFeatures)

if #anonFeatures == 0 and hc(args.mtype) then
-- Parse named args and add feature to table
local namedFeature = p.parseNamedArgs(args, mapOpts)
table.insert(features, namedFeature)
end

if #features == 0 then
mapOpts.range = {
xMin = mapOpts.x or defaults.x,
xMax = mapOpts.x or defaults.x,
yMin = mapOpts.y or defaults.y,
yMax = mapOpts.y or defaults.y
}
end

calculateView(args, mapOpts)

return features, mapOpts
end

function calculateView(args, mapOpts)
if not tonumber(args.x) then
mapOpts.x = math.floor((mapOpts.range.xMax + mapOpts.range.xMin) / 2)
else
mapOpts.x = args.x
end

if not tonumber(args.y) then
mapOpts.y = math.floor((mapOpts.range.yMax + mapOpts.range.yMin) / 2)
else
mapOpts.y = args.y
end

local width, height = mapOpts.width, mapOpts.height

if args.type == 'maplink' then
width, height = 800, 800

mapOpts.width = nil
mapOpts.height = nil
end

if not tonumber(args.zoom) then
local zoom, ratio = defaults.zoom, 1

local xRange = mapOpts.range.xMax - mapOpts.range.xMin
local yRange = mapOpts.range.yMax - mapOpts.range.yMin

-- Ensure space between outer-most points and view border
local bufferX, bufferY = width / 25, height / 25

for _, v in ipairs(zoomRatios) do
local sizeX, sizeY = width / v[2], height / v[2]

-- Check if the dynamic sizes are greater than the buffered ranges
if sizeX > xRange + bufferX and sizeY > yRange + bufferY then
zoom = v[1]
ratio = v[2]
break
end
end

if mapOpts.maxPinY then
-- Default pin height relative to zoom 1
local pinHeight = 40
-- Northern-most pin Y plus its dynamic height
local maxPinHeightY = mapOpts.maxPinY + (pinHeight / ratio)
-- New Y range using this value
local yRangeMaxPin = maxPinHeightY - mapOpts.range.yMin

if maxPinHeightY > mapOpts.range.yMax then
-- Move the view up by half the pin's dynamic height
mapOpts.y = mapOpts.y + (pinHeight / ratio / 2)

-- Zoom out if new range is too big
if yRangeMaxPin + bufferY > height / ratio then
zoom = zoom - 1
end
end
end

if zoom > defaults.zoom then
zoom = defaults.zoom
end

mapOpts.zoom = zoom
end
end

function adjustRange(coords, mapOpts)
for _, v in ipairs(coords) do
if v[1] > mapOpts.range.xMax then
mapOpts.range.xMax = v[1]
end

if v[1] < mapOpts.range.xMin then
mapOpts.range.xMin = v[1]
end

if v[2] > mapOpts.range.yMax then
mapOpts.range.yMax = v[2]
end

if v[2] < mapOpts.range.yMin then
mapOpts.range.yMin = v[2]
end
end
end

-- Parse named map arguments
function p.parseMapArgs(args)
local opts = {
type = ternary(hc(args.type), args.type, defaults.type),
x = ternary(hc(args.x), args.x, defaults.x),
y = ternary(hc(args.y), args.y, defaults.y),
width = ternary(hc(args.width), args.width, defaults.width),
height = ternary(hc(args.height), args.height, defaults.height),
mapID = ternary(hc(args.mapID), args.mapID, defaults.mapID),
plane = ternary(hc(args.plane), args.plane, defaults.plane),
zoom = ternary(hc(args.zoom), args.zoom, defaults.zoom),
align = ternary(hc(args.align), args.align, defaults.align),
nopreprocess = args.nopreprocess,
smw = args.smw,
smwName = args.smwName,
range = {
xMin = 10000000,
xMax = -10000000,
yMin = 10000000,
yMax = -10000000
}
}

-- Feature grouping across map instances
if hc(args.group) then
opts.group = args.group
end

-- Plain map tiles
if hc(args.plainTiles) then
opts.plainTiles = 'true'
end

-- Alternate map tile version
if hc(args.mapVersion) then
opts.mapVersion = args.mapVersion
end

-- Map type
if hc(args.type) and args.type ~= 'mapframe' and args.type ~= 'maplink' then
mapError('Argument `type` must be either `mapframe`, `maplink`, or not provided')
end

-- Caption or link text
if args.type == 'maplink' then
if args.text then
if args.text:find('[%[%]]') then
mapError('Argument `text` cannot contain links')
end

opts.text = args.text
else
opts.text = 'Maplink'
end
elseif hc(args.caption) then
opts.text = args.caption
else
opts.frameless = ''
end

return opts
end

-- Parse named arguments
-- This is called per anon feature as well
function p.parseNamedArgs(_args, mapOpts)
local args = mw.clone(_args)

if not feat[args.mtype] then
mapError('Argument `mtype` has an unsupported value')
end

-- Use named X and Y as coords only if no other points
if #args.coords == 0 and args.x and args.y then
args.coords = { {
tonumber(args.x) or defaults.x,
tonumber(args.y) or defaults.y
} }
end

-- No feature if no coords
if not args.coords or #args.coords == 0 then
return nil
end

-- Save northern-most pin Y for later view adjustment
if args.mtype == 'pin' and not args.iconWikiLink then
if mapOpts.maxPinY then
if args.coords[1][2] > mapOpts.maxPinY then
mapOpts.maxPinY = args.coords[1][2]
end
else
mapOpts.maxPinY = args.coords[1][2]
end
end

-- Center all points of combo multi-point and line features
if (args.isInCombo and mtypes.multiPoint[args.mtype]) or args.mtype == 'line' then
for _, v in ipairs(args.coords) do
centeredCoords(v)
end
end

-- Handle range adjustment individually for these types
if not isCenteredPointFeature(args.mtype) then
adjustRange(args.coords, mapOpts)
end

if not mapOpts.group and args.mtype == 'pin' then
mapOpts.group = args.group or defaults.group
end

-- This key must match a key found in `defaults`
parseIconXYArg(args, 'iconSize')
parseIconXYArg(args, 'iconAnchor')
parseIconXYArg(args, 'popupAnchor')

args.desc = parseDesc(args)

local featJson = feat[args.mtype](args, mapOpts)

-- Set feature in SMW
if hc(mapOpts.smw) then
parseSMW(mapOpts, featJson)
end

return featJson
end

-- Parse icon X/Y argument
function parseIconXYArg(args, key)
if hc(args[key]) then
if args[key]:find(',') then
local xy = mw.text.split(args[key], '%s*,%s*')
args[key] = { tonumber(xy[1]) or defaults[key], tonumber(xy[2]) or defaults[key] }
else
args[key] = { tonumber(args[key]) or defaults[key], tonumber(args[key]) or defaults[key] }
end
elseif hc(args[key..'X']) and hc(args[key..'Y']) then
args[key] = { tonumber(args[key..'X']), tonumber(args[key..'Y']) }
end
end

-- Parse anonymous arguments and add to the features table
-- Note 1: Anon X/Y coords generate anon features
-- Note 2: "Repeatable" means a feature that can be created once for each X/Y
function p.parseAnonArgs(args, mapOpts)
local features = {}
local i = 1

-- Collect unusable anon coords for use by named feature
args.coords = {}

while args[i] do
local arg = mw.text.trim(args[i])

if hc(arg) then
local anonOpts = { coords = {} }
local rawOpts = {}
-- Track all X and Y to find mismatches
local xyCount = 0

-- Remove opts with commas manually
-- Big workaround for Lua not supporting positive lookaheads
for _, opt in ipairs(optsWithCommas) do
arg = arg:gsub(opt..':%d+,%d+', function(s)
table.insert(rawOpts, s)
return ''
end)
end

-- Temporarily replace escaped commas for use in text opts
arg = arg:gsub('\\,', '**')

-- Split arg into options by "," and put extra commas back
for opt in mw.text.gsplit(arg, '%s*,%s*') do
opt = opt:gsub('%*%*', ',')
table.insert(rawOpts, opt)
end

for _, opt in ipairs(rawOpts) do
if hc(opt) then
-- Temporarily replace escaped colons for use in text opts
opt = opt:gsub('\\:', '^^')

-- Split option into key/value by ":"
local kv = mw.text.split(opt, '%s*:%s*')

-- If option is a value with no key, assume it's a standalone X or Y
if #kv == 1 then
xyCount = xyCount + 1
addXYToCoords(anonOpts.coords, kv[1])
else
if namedOnlyArgs[kv[1]] then
mapError('Anonymous option `'..kv[1]..'` can only be used as a named argument')
-- Add X/Y pair
elseif tonumber(kv[1]) and tonumber(kv[2]) then
xyCount = xyCount + 2
table.insert(anonOpts.coords, { tonumber(kv[1]), tonumber(kv[2]) })
-- Add individual X or Y
elseif kv[1] == 'x' or kv[1] == 'y' then
xyCount = xyCount + 1
addXYToCoords(anonOpts.coords, kv[2])
else
-- Put extra colons back
kv[2] = kv[2]:gsub('%^%^', ':')
anonOpts[kv[1]] = mw.text.trim(kv[2])
end
end
end
end

if xyCount % 2 > 0 then
mapError('Feature contains mismatched coordinates')
end

-- Named args are applied to all anon features if not specified
-- An anon feature opts take precedence over named args
for k, v in pairs(args) do
if not tonumber(k) and
k ~= 'x' and k ~= 'y' and
not namedOnlyArgs[k] and
not anonOpts[k] then
anonOpts[k] = v
end
end

if not anonOpts.mtype then
if #anonOpts.coords > 0 then
-- Save coord without an mtype to apply to map view X/Y
table.insert(args.coords, anonOpts.coords[1])
end
elseif mtypes.singlePoint[anonOpts.mtype] then
if #anonOpts.coords == 0 then
mapError('Anonymous `'..anonOpts.mtype..'` feature must have at least one point')
end

addFeaturePerCoord(features, anonOpts, mapOpts)
elseif mtypes.multiPoint[anonOpts.mtype] then
parseMultiPointFeature(features, anonOpts, mapOpts, true, args)
elseif anonOpts.mtype:find('-') then
parseComboFeature(features, anonOpts, mapOpts, true, args)
end
end

i = i + 1
end

if #args.coords > 0 then
-- Use first coord without mtype as map view X/Y
if not args.mtype then
mapOpts.x = args.coords[1][1]
mapOpts.y = args.coords[1][2]
elseif mtypes.singlePoint[args.mtype] then
addFeaturePerCoord(features, args, mapOpts)
elseif mtypes.multiPoint[args.mtype] then
parseMultiPointFeature(features, args, mapOpts, false)
elseif args.mtype:find('-') then
parseComboFeature(features, args, mapOpts, false)
end
end

return features
end

-- Add individual X or Y to next coord set
-- Handles coords split by commas (e.g., `|1000,2000`)
function addXYToCoords(coords, value)
local xy = coords[#coords]

if xy and #xy == 1 then
local y = tonumber(value) or defaults.y
table.insert(xy, y)
else
local x = tonumber(value) or defaults.x
table.insert(coords, { x })
end
end

-- Parse opts to build multi-point feature
function parseMultiPointFeature(features, opts, mapOpts, isAnon, namedArgs)
-- Anon multi-point can't have 0 coords
if isAnon and #opts.coords == 0 then
mapError('Anonymous multi-point `'..opts.mtype..'` feature must have at least 1 point')
elseif isAnon and #opts.coords == 1 then
if not namedArgs.mtype then
mapError('Anonymous multi-point `'..opts.mtype..'` feature must have 2 or more points')
end

-- Single coord for multi-point isn't possible,
-- so save coord to apply to named feature
table.insert(namedArgs.coords, opts.coords[1])
-- Named multi-point can't have <2 coords
elseif not isAnon and #opts.coords < 2 then
mapError('Named multi-point `'..opts.mtype..'` feature must have 2 or more points')
else
local feature = p.parseNamedArgs(opts, mapOpts)
table.insert(features, feature)
end
end

-- Parse opts to build multi-point feature
function parseComboFeature(features, opts, mapOpts, isAnon, namedArgs)
local combo = mw.text.split(opts.mtype, '-')

if #combo ~= 2 or not mtypes.singlePoint[combo[1]] or not mtypes.multiPoint[combo[2]] then
mapError('Feature `'..opts.mtype..'` is not a single-point + multi-point combo')
end

if isAnon and #opts.coords == 0 then
mapError('Anonymous feature in `'..opts.mtype..'` combo must have at least 1 point')
elseif #opts.coords == 1 then
if isAnon then
if not namedArgs.mtype then
mapError('Anonymous feature `'..combo[2]..'` in `'..opts.mtype..'` combo must have 2 or more points')
else
-- Create single-point and also save to use with named multi-point
opts.mtype = combo[1]
local feature = p.parseNamedArgs(opts, mapOpts)
table.insert(features, feature)
table.insert(namedArgs.coords, opts.coords[1])
end
else
mapError('Named feature `'..combo[2]..'` in `'..opts.mtype..'` combo must have 2 or more points')
end
else
-- Create all anon single-points
if isAnon then
opts.mtype = combo[1]
addFeaturePerCoord(features, opts, mapOpts)
end

-- Create named multi-point
opts.mtype = combo[2]
opts.isInCombo = true
local feature = p.parseNamedArgs(opts, mapOpts)
table.insert(features, feature)
end
end

-- Add feature per coordinate provided
function addFeaturePerCoord(features, opts, mapOpts)
local tempOpts = mw.clone(opts)

for _, v in ipairs(opts.coords) do
tempOpts.coords = { v }

local feature = p.parseNamedArgs(tempOpts, mapOpts)
table.insert(features, feature)
end
end

function feat.rectangle(featOpts, mapOpts)
local x, y = featOpts.coords[1][1], featOpts.coords[1][2]

local r = tonumber(featOpts.r)
local rectX = tonumber(featOpts.rectX or featOpts.squareX) or defaults.radius * 2
local rectY = tonumber(featOpts.rectY or featOpts.squareY) or defaults.radius * 2

if hc(r) and r % 1 > 0 then
x = x + 0.5
y = y + 0.5
end

local rectXR = r or math.floor(rectX / 2) or defaults.radius
local rectYR = r or math.floor(rectY / 2) or defaults.radius

local xLeft = x - rectXR
local xRight = x + rectXR
local yTop = y + rectYR
local yBottom = y - rectYR

if rectX % 2 > 0 then
xRight = x + (rectXR + 1)
end

if rectY % 2 > 0 then
yTop = y + (rectYR + 1)
end

local corners = {
{ xLeft, yBottom },
{ xLeft, yTop },
{ xRight, yTop },
{ xRight, yBottom }
}

local featJson = {
type = 'Feature',
properties = {
mapID = featOpts.mapID or mapOpts.mapID,
plane = featOpts.plane or defaults.plane
},
geometry = {
type = 'Polygon',
coordinates = { corners }
}
}

adjustRange(corners, mapOpts)
setProperties(featJson, featOpts, 'polygon')

return featJson
end

-- Create a square/rectangle feature
function feat.square(featOpts, mapOpts)
return feat.rectangle(featOpts, mapOpts)
end

-- Create a polygon feature
function feat.polygon(featOpts, mapOpts)
local points = {}
local lastPoint = featOpts.coords[#featOpts.coords]

for _, v in ipairs(featOpts.coords) do
table.insert(points, { v[1], v[2] })
end

-- Close polygon
if not (points[1][1] == lastPoint[1] and points[1][2] == lastPoint[2]) then
table.insert(points, { points[1][1], points[1][2] })
end

local featJson = {
type = 'Feature',
properties = {
mapID = featOpts.mapID or mapOpts.mapID,
plane = featOpts.plane or defaults.plane
},
geometry = {
type = 'Polygon',
coordinates = { points }
}
}

setProperties(featJson, featOpts, 'polygon')

return featJson
end

-- Create a line feature
function feat.line(featOpts, mapOpts)
local featJson = {
type = 'Feature',
properties = {
shape = 'Line',
mapID = featOpts.mapID or mapOpts.mapID,
plane = featOpts.plane or defaults.plane
},
geometry = {
type = 'LineString',
coordinates = featOpts.coords
}
}

setProperties(featJson, featOpts, 'line')

return featJson
end

-- Create a circle feature
function feat.circle(featOpts, mapOpts)
local radius = tonumber(featOpts.r) or defaults.radius
local featJson = {
type = 'Feature',
properties = {
shape = 'Circle',
radius = radius,
mapID = featOpts.mapID or mapOpts.mapID,
plane = featOpts.plane or defaults.plane
},
geometry = {
type = 'Point',
coordinates = featOpts.coords[1]
}
}

local corners = {
{ featOpts.coords[1][1] - radius, featOpts.coords[1][2] - radius },
{ featOpts.coords[1][1] - radius, featOpts.coords[1][2] + radius },
{ featOpts.coords[1][1] + radius, featOpts.coords[1][2] - radius },
{ featOpts.coords[1][1] + radius, featOpts.coords[1][2] + radius }
}

adjustRange(corners, mapOpts)
setProperties(featJson, featOpts, 'polygon')

return featJson
end

-- Create a dot feature
function feat.dot(featOpts, mapOpts)
local featJson = {
type = 'Feature',
properties = {
shape = 'Dot',
mapID = featOpts.mapID or mapOpts.mapID,
plane = featOpts.plane or defaults.plane,
fill = featOpts.fill or defaults.fill,
},
geometry = {
type = 'Point',
coordinates = centeredCoords(featOpts.coords[1])
}
}

setProperties(featJson, featOpts, 'dot')

return featJson
end

-- Create a pin feature
function feat.pin(featOpts, mapOpts)
local featJson = {
type = 'Feature',
properties = {
providerID = 0,
mapID = featOpts.mapID or mapOpts.mapID,
plane = featOpts.plane or defaults.plane,
group = featOpts.group or defaults.group
},
geometry = {
type = 'Point',
coordinates = centeredCoords(featOpts.coords[1])
}
}

if hc(featOpts.iconWikiLink) then
featOpts.iconWikiLink = mw.ext.GloopTweaks.filepath(featOpts.iconWikiLink)
else
featOpts.icon = ternary(hc(featOpts.icon), featOpts.icon, defaults.icon)
end

setProperties(featJson, featOpts, 'pin')

return featJson
end

-- Create a text feature
function feat.text(featOpts, mapOpts)
if not featOpts.label then
mapError('Argument `label` missing on text feature')
end

local featJson = {
type = 'Feature',
properties = {
shape = 'Text',
label = featOpts.label,
direction = featOpts.position or defaults.position,
class = featOpts.class or 'lbl-bg-grey',
mapID = featOpts.mapID or mapOpts.mapID,
plane = featOpts.plane or defaults.plane
},
geometry = {
type = 'Point',
coordinates = centeredCoords(featOpts.coords[1])
}
}

setProperties(featJson, featOpts, 'text')

return featJson
end

-- Create feature description
function parseDesc(args)
local pageName = mw.title.getCurrentTitle().text

local coordsStr = 'X/Y: '..math.floor(args.coords[1][1])..','..math.floor(args.coords[1][2])
local coordsElem = mw.html.create('p')
:wikitext(coordsStr)
:attr('style', 'font-size:10px; margin:0px;')

if args.ptype == 'item' or
args.ptype == 'monster' or
args.ptype == 'npc' or
args.ptype == 'object' then
local tableElem = mw.html.create('table')
:addClass('wikitable')
:attr('style', 'font-size:12px; text-align:left; margin:0px; width:100%;')

if args.ptype == 'item' then
addTableRow(tableElem, 'Item', args.name or pageName)
addTableRow(tableElem, 'Quantity', args.qty or 1)

if hc(args.respawn) then
addTableRow(tableElem, 'Respawn time', args.respawn)
end
elseif args.ptype == 'monster' then
addTableRow(tableElem, 'Monster', args.name or pageName)

if hc(args.levels) then
addTableRow(tableElem, 'Level(s)', args.levels)
end

if hc(args.respawn) then
addTableRow(tableElem, 'Respawn time', args.respawn)
end
elseif args.ptype == 'npc' then
addTableRow(tableElem, 'NPC', args.name or pageName)

if hc(args.levels) then
addTableRow(tableElem, 'Level(s)', args.levels)
end

if hc(args.respawn) then
addTableRow(tableElem, 'Respawn time', args.respawn)
end
elseif args.ptype == 'object' then
addTableRow(tableElem, 'Object', args.name or pageName)
end

if hc(args.id) then
addTableRow(tableElem, 'ID', args.id)
end

return tostring(tableElem)..tostring(coordsElem)
end

local desc = ''

if hc(args.desc) then
desc = args.desc
end

return desc..tostring(coordsElem)
end

-- Add row to table element
function addTableRow(table, label, value)
local row = table:tag('tr')
row:tag('td'):wikitext("'''"..label.."'''")
row:tag('td'):wikitext(value)
end

-- Move coords to tile center
function centeredCoords(coords)
for k, v in ipairs(coords) do
coords[k] = v + 0.5
end

return coords
end

-- Set GeoJSON properties
-- If an option exists in the allowed feature props, add it
function setProperties(featJson, opts, mtype)
for k, v in pairs(opts) do
if properties[mtype][k] or properties.any[k] then
if k == 'desc' then
featJson.properties.description = v
else
-- If marked as string, use value as is, otherwise try number
featJson.properties[k] = ternary(properties.any[k] == 'string', v, tonumber(v) or v)
end
end
end
end

-- Parse SMW args
function parseSMW(args, data)
if args.smw:lower() == 'yes' then
if not hc(args.smwName) then
setSMW(data, 'Location JSON')
else
setSMW(data, 'Location JSON', args.smwName)
end
elseif args.smw:lower() == 'hist' then
setSMW(data, 'Historic Location JSON')
end
end

-- Create SMW entry
function setSMW(obj, prop, subobjectName)
if not subobjectName then
mw.smw.set({ [prop] = toJSON(obj) })
else
mw.smw.subobject({ [prop] = toJSON(obj) }, subobjectName)
end
end

-- Helper function to get rendered map through SMW lookup
function p.getMap(name, _mapOpts)
local features, mapOpts = {}, {}
local query = {
'?Location JSON',
'limit=1'
}

if name then
table.insert(query, string.format('[[%s]][[Location JSON::+]]', name))
else
return nil
end

local results = mw.smw.ask(query) or {}
local page = results[1]
local entries = page and page['Location JSON']

if not entries then
return nil
end

for _, entry in ipairs(entries) do
local data = mw.text.jsonDecode(entry)

if data.type then
table.insert(features, data)
else
mapOpts = data
end
end

if #features > 0 then
for k, v in pairs(_mapOpts or {}) do
mapOpts[k] = v
end

return p.buildMapFromOpts(features, mapOpts)
else
return nil
end
end

-- Test if feature is based on a center point with calculated size
function isCenteredPointFeature(mtype)
return
mtype == 'rectangle' or
mtype == 'square' or
mtype == 'circle'
end

-- Add all elements of table 2 to table 1
function combineTables(table1, table2)
for _, v in ipairs(table2) do
table.insert(table1, v)
end
end

-- Create JSON
function toJSON(val)
local good, json = pcall(mw.text.jsonEncode, val)

if good then
return json
end

mapError('Error converting value to JSON')
end

-- Makeshift ternary operator
function ternary(condition, a, b)
if condition then
return a
else
return b
end
end

-- Produce an error
function mapError(message)
error('[Module:Map] '..message, 0)
end

return p

Module:Exchange/Maple bird house - Revision history